欧美精品久久久久久,国模极品一区二区三区,亚洲高清在线观看

��Z��么要使用EJB�Q?�?

liaojiyong — Wed, 02 Aug 2006 07:56:00 GMT

板桥里�h http://www.jdon.com 2004/03/08

　　首先�Q�我们必��L��，��Z��么要使用J2EE�Q�J2EE优点是什么？使用J2EE的主要原因是多层�l�构�Q�传�l�的两层C/S�l�构难于�l�护�Q�稳定性极差，界面代码和数据库代码��h��在一��P��牵一动百�Q�多层结构��得界面和数据库完全分��，�q�且诞生了中间�g�q�样的技术，如下图：

Web+EJB能组成真正的多层�l�构

　　��Z��么��用EJB我原先认��不是一个讨论的话题�Q�因为EJB是J2EE重要的组成部分，可以说没有EJB的J2EE只是一�U�Web�pȝ��Q�这��L��pȝ��非常�Ҏ(gu��)��丧失了多层结构的大部分优点（仔细��x��那些混合多种层次功能JavaBeans和传�l�两层结构有什么区别？�Q��?/p>

　　当然�Q�可以�h为地在Javabeans之间�q�行层次划分�Q�例如Hibernate��数据持久层�Q�某些JavaBeans是业务核心层�Q�但是因为都是普�?JavaBeans�Q�这�U�划分没有一�U�强制性和明显标志性，�q�样的系�l�更换了��d��人员或设计师�Q�可能就会被新的�E�序员修改得非常混�ؕ�?/p>

　　我们先看看一个包含EJB的J2EE�pȝ��是如何清晰地表达层次。如下图�Q?/p>

　　Web完全只是一个MVC模式的实玎ͼ�关键业务核心是在EJB的服务层实现�Q�这样做的优�Ҏ(gu��)��Q�Web只负责界面相关部分，因�ؓ�Q�如果是一个智能客��L��Q�如Swing或J2ME�Q�在不需要修改�Q何业务核心的情况下能够方便地更换。同��P��提供Web Services功能�Q�也只是�?Web层修改，不会涉及EJB斚w��的修改，同样保证了系�l�的�E�_��性，保证了系�l�升�U�和未来的扩展性�?/p>

　　如果不��用EJB�Q�在EJB服务层实现的业务核心?y��u)��由普通JavaBeans实现�Q��用何�U�架构或设计能够保证负责MVC的JavaBeans和负责业务核心的JavaBeans清晰地分开�Q�又如何保证在新的程序员不会破坏和打�׃��_�ֿ�布局的JavaBeans架构�Q?/p>

EJB提供性能优化支持

　　最主要的是性能问题�Q�由于以前国内中文Java�|�站有些人弯曲EJB�Q�认为EJB性能低，其实�q�是一�U�非常肤��错误的认识�Q�我们首先看看在一般Java环境中是如何提高性能�?/p>

　　假定一个JavaBeans为A�Q�那么一般��用这个JavaBeans命��o如下�Q?/p>

　　A a = new A();

　　但是�Q�在高访问量的环境中�Q�new A()其实是很�Ҏ(gu��)��消耗系�l�性能的，因此�Q�能不能在��Y件系�l�启动时候就预先建立一些对象，�q�样�Q�系�l�运行时�Q�从�q�些已经生成的对象池中借用一个，�q�样�Q�就无需在��用时�q�行New�Q�节�U�了开销�Q�提高了性能�Q�因此，真正成熟性能解决�Ҏ(gu��)��都是需要对象池�{�支持�?/p>

　　在一个纯Web�l�构的系�l�（也就是只能运行在Tomat环境中）�Q�例如Struts + Hibernate�{�这��L��pȝ��Q�除非自己动手做�Q�一般是没有对象池技术支持的�Q�因此他们的性能只能��是Demo演示版本的性能�Q�根本无法承受大定w��q�发讉K��Q�也无法�U�Cؓ一个成熟的�pȝ��Q�所以，我们研究成熟的开源Web�pȝ��Q�如Jive、OFBize�Q�LifeRay�{�，他们都在Web层拥有自��q��对象�?和缓存池�?/p>

　　对象池和�~�存机制是J2EE必须的吗�Q�当�Ӟ��是所有成熟系�l�必��ȝ��Q�Windows�pȝ��如果��L��~�存��会变得怎样�Q?/p>

　　自己动手开发对象池和缓存机制�ƈ不是一件简单的事情�Q�需要对多线�E�以及同步锁�{�底层原理有深层�ơ的把握�Q�这其实也是一门非常深入的Java研究分支�Q�所以，你可以抛开你的客户焦急的催促�Q�精心研�I�开发自��q��对象池和�~�存池�?/p>

　　但是�Q�EJB容器�Q�如JBoss�Q�已�l�提供了对象池和�~�存机制�Q�所以，没有事务机制的无状态Session Bean的性能肯定要强于普通JavaBeans。EJB容器不但在单��Z��提供了对象池和缓存，而且可以跨服务器实现动态负载��^衡，�q�些都无需开发者自�?开发�Q何��Y件代码，�l�构如下�Q?/p>

EJB�l��g能提供真正的可重用框�?/h3>
　　每一个jar包代表一个EJB�l��g�Q�一个系�l�可以由多个可重用的EJB�l��g构成�Q�例如：树�Ş�l�构EJB�l��g�Q�自增序号EJB�l��g�Q�用戯��料EJB�l��g�{�，�q�样的EJB�l��g可以象积木一��h��配在大部分应用系�l�中�Q�提高了�pȝ��的开发效率，保证了开发质量�?/p>
　　下图是某个新的具体系�l�时应用到的EJB�l��g图，在这个新的应用中�Q�由于��用了以前大量可重用的EJB�l��g�Q�新的开发工作基本集中在界面设计和流�E�安排上�Q?/p>

EJB提供了事务机�?/h3>
　　事务机制对于一些关键事务是很重要的�Q�例如ATM机提�ƾ，提款有多个动作：修改数据库以及数��q��Q�如果这其中有�Q何一个环节出错，那么其它已经实现的操作必��还原，否则�Q�就会出玎ͼ�提款人没有拿到钱�Q�但是卡上已�l�扣�Ƅ��不可思议的事情发生�?/p>
　　EJB提供的事务机刉��常周全，但事务机制带来的�~�点是性能的降低，因此�Q�有些�h认�ؓEJB很重�Q�因为在实际应用中，有的用户�pȝ��可能不需要事务机�Ӟ�� 只是需要EJB提供的性能优化机制�Q�这��P��如果使用EJB�Q�就象叫一个�h来背东西�Q�他除了背着我要的东西外�Q�还背着我不要的东西�?/p>
　　除非你是一个完��主义，在一般企业应用或数据库系�l�应用中�Q�EJB不会对你构成很重的包袱�?/p>

CMP独特的优�?/h3>
　　开源以及一些数据库持久层技术崇拜者，一直抨击CMP�Q�认为CMP慢无用，实际最大的问题是他们的设计和��用问题�?/p>
　　�׃��EJB容器�Q�如JBoss�Q�对CMP实现有事务机制的�~�存优化�Q�因此，CMP特别适合多个用户同时更新同一个数据源的情况，CMP�q�种严格的事务完整性保证多个用户同时操作一个数据记录时�Q�能够保证性能优化和数据的完整性，如果�q�个数据记录是是软�g�pȝ��的状态标志，它的状态会影响�pȝ��中很多的环节�Q?那么状态更改的重要性不�a�而喻�?/p>
　　如果没有事务完整性支持，你的软�g�pȝ��在用戯��问量变大�Q�就会变得发生各�U�不可能发生的逻辑错误�Q�查看程序逻辑是正��的�Q�那么问题出在哪里？出在数据完整性上�?/p>
　　�׃��每个CMP在内存中都有一个缓存，在实际应用中�Q�如果��用CMP扚w��L��据库数据�Q�几万条查询完毕�Q�内存中充满了几万条CMP�~�存�Q�如果这时你�?EJB容器讄��不当�Q�如使用JBoss�~�省配置�Q�，那么JVM的垃圑֛�收机制就会频�J�启动，��D��你的�pȝ��变慢甚至��L��Q�这也是一些�h抨击CMP慢的原因所在，其实他们使用�Ҏ(gu��)��不当�Q�或者没有正��配�|�EJB容器CMP�~�存�?/p>
　　对于�q�种情况�Q�根据J2EE核心模式�Q�推荐��用DAO+JDBC方式�?/p>

��结

　　除非你对设计模式非常�_�深�Q�能够将自己�pȝ��中的JavaBeans使用模式或某�U�框架进行固定分层，同时�Q�你孜孜不倦研发出对象池，又熟�l�于JTA�{�事务机�Ӟ��你可以选择没有EJB的纯Web�l�构�Q�就象Jive、OFBiz那样。当然还有一个前提，老板不懂或者非常有挑战性（做与IBM SUN 微��Y齐名的公司和技术）�?/p>

　　不要再被TSS那些狂热的开源先生误��|��他们有时间有保障可以做他们喜�Ƣ的事情�Q�作��Z��业的J2EE�E�序员，按照J2EE标准��d��习去行动�Q�也不要认�ؓ�Q�只要��用了J2EE其中某个技术如Jsp或JavaBeans��心安理得认��q��pȝ��是J2EE了�?/p>

　　当然�Q�我�q�不是说�U�Web�pȝ��不能实现多层�l�构�Q�但是至��在很多斚w��没有Web+EJB�l�构完善和清晎ͼ�所以，EJB不是J2EE可以忽视的部分，而是主要的重要的部分�Q�重要业务功能核心都��装在EJB中，相反Web层是一�U�次要的、和界面相关的层�ơ�?/p>

　　补充�Q�什么情况下不需要EJB�Q�在SUN的SECA架构师试卷中回答�Q�小型系�l�和不需要事务。另外过去那�U�认为“EJB有性能问题”根本是一�U�缪误，具体可参考下面有关问题�?/p>

liaojiyong 2006-08-02 15:56 发表评论

liaojiyong — Thu, 20 Jul 2006 17:39:00 GMT

在EJB 3.0 学习�W�记——准备工作中只是��单的搭好了EJB3.0开发的基本环境�Q�之

后就可以开发最��单的Session Bean了，我感兴趣的还是Entity Bean�Q�所以接下来

我想先试验一下Entity Bean�?br />
一、在JBoss中配�|�好Data Source
我��用的是MySQL数据库，所以首先将MySQL的JDBC驱动复制�?br />jboss-4.0.3SP1\server\all\lib目录�Q�然后将jboss-4.0.3SP1\docs\examples\jca

下的mysql-ds.xml作出适当修改后复制到jboss-4.0.3SP1\server\all\deploy目录

下，�q�是我修改后的mysql-ds.xml文�g�Q?/p>

    MySqlDS
    jdbc:mysql://localhost:3306/test
    com.mysql.jdbc.Driver
    test

name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter

on-sorter-class-name>

       mySQL


�q�样之后�Q�JBoss下的MySQL Data Source配置完成�?/p>

二、创建数据库�q�编写Entity Bean代码

create table book(
id int not null auto_increment primary key,
title varchar(20) not null,
author varchar(40) not null
);
新徏Java Project�Q�导入User Library�Q�EJB3_JBoss�Q�以下是�c�M��码�?/p>

//Book.java
package ejb.bean.entity;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="book")
public class Book implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private Integer id;
private String title;
private String author;

public Book() {
  super();
}
public Book(Integer id, String title, String author) {
  super();
  this.id = id;
  this.title = title;
  this.author = author;
  }
@Override
public String toString() {

  return "Book: " + getId() + " Title " + getTitle() + "

Author " + getAuthor();
}
public String getAuthor() {
  return author;
}

@Id @GeneratedValue(strategy=GenerationType.AUTO)
public Integer getId() {
  return id;
}
public String getTitle() {
  return title;
}
public void setAuthor(String author) {
  this.author = author;
}
public void setId(Integer id) {
  this.id = id;
}
public void setTitle(String title) {
  this.title = title;
}

}

三、编写一个简单的Stateless Session Bean �q�进行测�?/p>

//BookTestLocal.java
package ejb.bean.entity;

import javax.ejb.Local;

@Local
public interface BookTestLocal {

public void test();
}

//BookTestRemote.java
package ejb.bean.entity;

import javax.ejb.Remote;
@Remote
public interface BookTestRemote {

public void test();

}

//BookTestBean.java
package ejb.bean.entity;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class BookTestBean implements BookTestLocal, BookTestRemote {

@PersistenceContext
EntityManager em;
public void test() {
// TODO Auto-generated method stub
Book book = new Book(null, "My first bean book",

"Sebastian");
em.persist(book);

}

//Client.java
package ejb.client.entity;

import ejb.bean.entity.*;

import javax.naming.InitialContext;

/**
* Comment
*
* @author Bill">mailto:bill@jboss.org">Bill Burke
* @version $Revision: 1.1.6.7 $
*/
public class Client
{
   public static void main(String[] args) throws Exception
   {
      InitialContext ctx = new InitialContext();
      BookTestRemote book = (BookTestRemote) ctx.lookup

("BookTestBean/remote");

      book.test();

      System.out.println("test successful! ");

}
}

三、其他文�?br />��jboss-EJB-3.0_RC5-PFD\docs\tutorial中的扑ֈ�的jndi.properties、log4j.xml

、builder.xml�{�复制到当前工程中，其中builder.xml需要修攏V�?br />//builder.xml

               destdir="${build.classes.dir}"
         debug="on"
         deprecation="on"
         optimize="off"
         includes="**">

dir=".">

fork="yes" dir=".">

最后，在工�E�目录下新徏目录META-INF�Q�在目录META-INF新徏persistence.xml文�g

�Q�以下是文�g内容�Q?br />


      java:/MySqlDS

value="org.hibernate.dialect.MySQLDialect"/>

四、运行测�?br />run as->ant build后，选择�q�行目标为run.entity->run�?br />�q�行�l�果�Q?br />Buildfile: D:\Programs\Java\EclipseWork\EJB3\build.xml
prepare:
compile:
ejbjar:
run.entity:
[java] test successful!
BUILD SUCCESSFUL
Total time: 9 seconds

MySQL中select * from book;
id title author
1 My first bean book Sebastian
已经成功写入�?/p>

liaojiyong 2006-07-21 01:39 发表评论

EJB 3.0开发指南之�l�合主键

liaojiyong — Tue, 04 Jul 2006 01:28:00 GMT

在前面的所有的实体Bean的例子中�Q�我们所用的主键都是Id,而且都是由容器自动生成的�?

　　�?

@Id(generate = GeneratorType.AUTO)
public int getId()
{
　return id;
}

　　事实�?主键可以是�Q意的java基本�c�d��、或者是基本�c�d��的包装类�Q�如Integer、String�c�d��、或者是带字�D�|��属性的主键�c�R��注意，如果�q�样使用主键,你需要将主键的注释中的生成规则改为NONE。就是由�E�序生成主键倹{�?br />
　　主键�c�d��d��现hashCode和equals�Ҏ(gu��)��?br />
　　�q�个例子前面举例�q�，��是一个存储学生信息的实体bean�Q�在那个例子中，使用Name�c�M��为属性，�q�且以Id作�ؓ主键�Q�在�q�个例子中，我们��用name作�ؓ主键�Q�注意name的类型一个java�c�R��和前面的例子一��P��我们�q�是使用Client��试�?br />
　　Name.java�Q�主键�?br />
　　Student.java�Q�实体Bean�c�R�?br />
　　StudentDAO.java�Q�会话Bean的业务接�?br />
　　StudentDAOBean.java�Q�会话Bean的实现类

　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />
　　Name.java

package com.kuaff.ejb3.composite;

import java.io.Serializable;
import javax.ejb.AccessType;
import javax.ejb.DependentObject;

@DependentObject(access = AccessType.PROPERTY)

public class Name implements java.io.Serializable
{
　private String first;
　private String last;

　public Name()
　{
　}

　public Name(String first, String last)
　{
　　this.first = first;
　　this.last = last;
　}

　public String getFirst()
　{
　　return first;
　}

　public void setFirst(String first)
　{
　　this.first = first;
　}

　public String getLast()
　{
　　return last;
　}

　public void setLast(String last)
　{
　　this.last = last;
　}

　public int hashCode()
　{
　　return (first+last).hashCode();
　}

　public boolean equals(Object object)
　{
　　if (this == object) return true;
　　if (object == null) return false;
　　if (! (object instanceof Name)) return false;
　　Name name = (Name)object;
　　if ((name.first.equals(first)) && (name.last.equals(last)))
　　　return true;
　　else
　　　return false;
　}

}

　　Student.java

package com.kuaff.ejb3.composite;

import javax.ejb.Dependent;
import javax.ejb.DependentAttribute;
import javax.ejb.Column;
import javax.ejb.Entity;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.Table;

@Entity @Table(name = "STUDENT") public class Student implements java.io.Serializable
{
　private Name name;
　private String grade;
　private String email;

　public void setName(Name name)
　{
　　this.name = name;
　}

　@Id(generate = GeneratorType.NONE)
　@Dependent(
　　{ @DependentAttribute(name = "first", column ={ @Column(name = "FIRST") }),
　　　@DependentAttribute(name = "last", column ={ @Column(name = "LAST") }) })
　　　public Name getName()
　　　{
　　　　return name;
　　　}

　public void setGrade(String grade)
　{
　　this.grade = grade;
　}

　@Column(name = "GRADE")
　public String getGrade()
　{
　　return grade;
　}

　public void setEmail(String email)
　{
　　this.email = email;
　}

　@Column(name = "EMAIL")

　public String getEmail()
　{
　　return email;

　　StudentDAO.java

package com.kuaff.ejb3.composite;

import javax.ejb.Remote;
import java.util.List;

@Remote

public interface StudentDAO

{

void create(String first, String last, String grade, String email);

Student find(Name name);

List findByFirstName(String name);

List findByLastName(String name);

List findByEmail(String email);

void merge(Student s);

}

　　StudentDAOBean.java

package com.kuaff.ejb3.composite;

import java.util.List;
import javax.ejb.EntityManager;
import javax.ejb.Inject;
import javax.ejb.Stateless;

@Stateless

public class StudentDAOBean implements StudentDAO
{
　@Inject
　private EntityManager manager;

　public void create(String first, String last, String grade, String email)
　{
　　Student student = new Student();
　　student.setName(new Name(first,last));
　　student.setGrade(grade);
　　student.setEmail(email);
　　manager.create(student);
　}

　public Student find(Name name)
　{
　　return manager.find(Student.class, name);
　}

　public List findByFirstName(String name)
　{
　　return manager.createQuery("from Student s where s.name.last = :name").setParameter("name", name).listResults();

　}

　public List findByLastName(String name)
　{
　　return manager.createQuery("from Student s where s.name.first = :name").setParameter("name", name).listResults();
　}

　public List findByEmail(String email)
　{
　　return manager.createQuery("from Student s where s.email = :email").setParameter("email", email).listResults();
　}

　public void merge(Student s)
　{
　　manager.merge(s);
　}

}

　　Client.java

package com.kuaff.ejb3.composite;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.List;

public class Client
{
　public static void main(String[] args) throws NamingException
　{
　　InitialContext ctx = new InitialContext();
　　StudentDAO dao = (StudentDAO) ctx.lookup(StudentDAO.class.getName());
　　dao.create("�?,"��x��","8","smallnest@kuaff.com");
　　dao.create("�?,"立焕","6","zhuzhu@kuaff.com");
　　Name name = new Name("�?,"立焕");

　　//List list = dao.findByEmail("zhuzhu@kuaff.com");

　　Student s = dao.find(name);
　　System.out.printf("%s %s的email:%s%n",s.getName().getFirst(),s.getName().getLast(),s.getEmail());
　　/*
　　　for(Object o:list)
　　　{
　　　　Student s = (Student)o;
　　　　System.out.printf("%s %s的email:%s%n",s.getName().getFirst(),s.getName().getLast(),s.getEmail());
　　　}
　　*/
　}
}

　　�q�个客户端用来测试�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB�Q�然后调用startDatabaseManager()�Ҏ(gu��)��Q�打开HSQL��理工具��理数据库�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:28 发表评论

EJB3.0开发指南之多对多和一对一

liaojiyong — Tue, 04 Jul 2006 01:27:00 GMT

在前面的例子中，我们演示了一对多和多对一的例子，在本章将演示多对多和一对一的关�p�R�?

　　学生和老师��是多对多的关系。一个学生有多个老师�Q�一个老师教多个学生�?br />
　　学生和档案就是一对一的关�p�（不知道国外的学生有没有档案？�Q��?br />
　　��Z��实现多对多的关系�Q�数据库中需要关联表�Q�用以在两个实体间徏立关联。JBoss可以自动生成兌��表，你也可以@AssociationTable来指定关联表的信息�?br />
　　�?

@ManyToMany(cascade = {CascadeType.CREATE, CascadeType.MERGE}, fetch = FetchType.EAGER, isInverse = true)
@AssociationTable(table = @Table(name = "STUDENT_TEACHER"),

joinColumns = {@JoinColumn(name = "TEACHER_ID")},inverseJoinColumns = {@JoinColumn(name = "STUDENT_ID")})

@ AssociationTable的注释声明如下：
@Target({METHOD, FIELD})

public @interface AssociationTable {
　Table table() default @Table(specified=false);
　JoinColumn[] joinColumns() default {};
　JoinColumn[] inverseJoinColumns() default {};
}

　　兌��表注释指定了兌��表的名称、主表的列和从表的列�?br />
　　��Z��实现一对一的关�p�，需要用@OneToOne来注释�?

　　�?

@OneToOne(cascade = {CascadeType.ALL})
@JoinColumn(name = "DOSSIER_ID")

public Dossier getDossier()
{
　return dossier;
}

　　�q�定义了一个单向的一对一的关�p�R��如果在Dossier也定义了相关的关联，那么它就是双向的。双向的意思就是通过一个Student实体��可以查扑ֈ�一个Dossier�Q�通过一个Dossier��可以查扑ֈ�一个Student�?br />

@ OneToOne的注释声明如下：
@Target({METHOD, FIELD}) @Retention(RUNTIME)

public @interface OneToOne {
　String targetEntity() default "";
　CascadeType[] cascade() default {};
　FetchType fetch() default EAGER;
　boolean optional() default true;
}

　　�q�个例子主要有以下几个文�Ӟ��q�个例子主要实现了学生和老师、学生和档案之间的关�p�R��Student、Teacher、Dossier都是实体Bean。Student和Dossier是一个双向的OneToOne之间的关�p�，Student和Teacher是ManyToMany的关�p�，也是双向的。和前面的例子一��P��我们�q�是使用Client��试�?br />
　　Student.java�Q�实体Bean�?br />
　　Dossier.java�Q�实体Bean所依赖的类�?br />
　　Teacher.java�Q�实体Bean所依赖的类�?br />
　　EntityTest.java�Q�会话Bean的业务接�?br />
　　EntityTest Bean.java�Q�会话Bean的实现类

　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />
　　Student.java

package com.kuaff.ejb3.relationships;
import javax.ejb.CascadeType;
import javax.ejb.Entity;
import javax.ejb.FetchType;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.JoinColumn;
import javax.ejb.OneToOne;
import javax.ejb.ManyToMany;
import javax.ejb.Table;
import javax.ejb.AssociationTable;
import java.util.ArrayList;
import java.util.Set;
import java.util.Collection;
import java.io.Serializable;

@Entity

@Table(name = "STUDENT")

public class Student implements Serializable

{
　private int id;
　private String first;
　private String last;
　private Dossier dossier;
　private Set teachers;

　@Id(generate = GeneratorType.AUTO)

　public int getId()
　{
　　return id;
　}

　public void setId(int id)
　{
　　this.id = id;
　}

　public void setFirst(String first)
　{
　　this.first = first;
　}

　public String getFirst()
　{
　　return first;
　}

　public void setLast(String last)
　{
　　this.last = last;
　}

　public String getLast()
　{
　　return last;
　}

　public void setDossier(Dossier dossier)
　{
　　this.dossier = dossier;
　}

@OneToOne(cascade = {CascadeType.ALL})
@JoinColumn(name = "DOSSIER_ID")

public Dossier getDossier()
{
　return dossier;
}

public void setTeacher(Set teachers)
{
　this.teachers = teachers;
}

@ManyToMany(cascade = {CascadeType.CREATE, CascadeType.MERGE}, fetch = FetchType.EAGER, isInverse = true)
@AssociationTable(table = @Table(name = "STUDENT_TEACHER"),

joinColumns = {@JoinColumn(name = "TEACHER_ID")},inverseJoinColumns = {@JoinColumn(name = "STUDENT_ID")})

public Set getTeacher()
{
　return teachers;
}
}

　　Dossier.java

package com.kuaff.ejb3.relationships;

import javax.ejb.Entity;
import javax.ejb.GeneratorType;
import javax.ejb.Id;

@Entity

public class Dossier implements java.io.Serializable
{
　private Long id;
　private String resume;

　@Id(generate = GeneratorType.AUTO)
　public Long getId()
　{
　　return id;
　}

　public void setId(Long id)
　{
　　this.id = id;
　}

　public void setResume(String resume)
　{
　　this.resume = resume;
　}

　public String getResume()
　{
　　return resume;
　}
}

　　Teacher.java

package com.kuaff.ejb3.relationships;

import javax.ejb.AssociationTable;
import javax.ejb.Basic;
import javax.ejb.CascadeType;
import javax.ejb.Column;
import javax.ejb.Entity;
import javax.ejb.FetchType;
import javax.ejb.Id;
import javax.ejb.JoinColumn;
import javax.ejb.ManyToMany;
import javax.ejb.Table;
import javax.ejb.Transient;
import javax.ejb.Version;
import java.util.Set;
import javax.ejb.GeneratorType;

@Entity

public class Teacher implements java.io.Serializable
{
　private Long id;
　private String resume;
　private String name;
　private String info;
　private Set students;

　@Id(generate = GeneratorType.IDENTITY)

　public Long getId()
　{
　　return id;
　}

　public void setId(Long id)
　{
　　this.id = id;
　}

　public void setName(String name)
　{
　　this.name = name;
　}

　public String getName()
　{
　　return name;
　}

　public void setInfo(String info)
　{
　　this.info = info;
　}

　public String getInfo()
　{
　　return info;
　}

　public void setStudents(Set students)
　{
　　this.students = students;
　}

　@ManyToMany(cascade = {CascadeType.CREATE, CascadeType.MERGE}, fetch = FetchType.EAGER)
　@AssociationTable(table = @Table(name = "STUDENT_TEACHER"),

　joinColumns = {@JoinColumn(name = "TEACHER_ID",referencedColumnName="ID")},
　inverseJoinColumns = {@JoinColumn(name = "STUDENT_ID",referencedColumnName="ID")})

　public Set getStudents()
　{
　　return students;
　}
}

　　EntityTest.java

package com.kuaff.ejb3.relationships;

import javax.ejb.Remote;
import java.util.List;

@Remote

public interface EntityTest
{
　public void createData();
　public List findByName(String name);
}

　　EntityTestBean.java
　

package com.kuaff.ejb3.relationships;

import javax.ejb.EntityManager;
import javax.ejb.Inject;
import javax.ejb.Stateless;
import java.util.HashSet;
import java.util.Set;
import java.util.List;

@Stateless

public class EntityTestBean implements EntityTest
{
　private @Inject EntityManager manager;
　public void createData()
　{
　　Teacher teacher1 = new Teacher();
　　Teacher teacher2 = new Teacher();

　　Set students1 = new HashSet();
　　Set students2 = new HashSet();
　　Student student1 = new Student();
　　Student student2 = new Student();
　　Student student3 = new Student();

　　Dossier dossier1 = new Dossier();
　　Dossier dossier2 = new Dossier();
　　Dossier dossier3 = new Dossier();
　　teacher1.setId(new Long(1));
　　teacher1.setName("hushisheng");
　　teacher1.setInfo("胡时胜教授，博士生导�?);
　　manager.create(teacher1);
　　teacher2.setId(new Long(2));
　　teacher2.setName("liyongchi");
　　teacher2.setInfo("李永池教授，博士生导�?);
　　manager.create(teacher2);

　　student1.setFirst("�?);
　　student1.setLast("��x��");
　　dossier1.setResume("�q�是晁岳攀的档�?);
　　student1.setDossier(dossier1);
　　students1.add(student1);

　　student2.setFirst("�?);
　　student2.setLast("志伟");
　　dossier2.setResume("�q�是赵志伟的档案");
　　student2.setDossier(dossier2);
　　students1.add(student2);

　　student3.setFirst("�?);
　　student3.setLast("�?);

　　dossier3.setResume("�q�是田明的档�?);
　　student3.setDossier(dossier3);
　　students2.add(student3);

　　teacher1.setStudents(students1);
　　teacher2.setStudents(students2);

　}

　public List findByName(String name)
　{
　　return manager.createQuery("from Teacher t where t.name = :name").setParameter("name", name).listResults();
　}

}

　　在这个会话Bean中提供了创徏各个实体Bean的方法，�q�提供了查找老师的方法�?br />
　　Client.java

package com.kuaff.ejb3.secondary;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.List;

public class Client
{
　public static void main(String[] args) throws NamingException
　{
　　InitialContext ctx = new InitialContext();
　　StudentDAO dao = (StudentDAO) ctx.lookup(StudentDAO.class.getName());
　　int id = dao.create("�?,"��x��","8","smallnest@kuaff.com","�?);
　　dao.create("�?,"立焕","6","zhuzhu@kuaff.com","�?);
　　List list = dao.findAll();
　　for(Object o:list)
　　{
　　　Student s = (Student)o;
　　　System.out.printf("%s%s的性别:%s%n",s.getName().getFirst(),s.getName().getLast(),s.getGender());
　　　dao.evict(s);
　　}
　}
}

　　�q�个客户端用来测试�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
　　http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB�Q�然后调用startDatabaseManager()�Ҏ(gu��)��Q�打开HSQL��理工具��理数据库�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?/span>

liaojiyong 2006-07-04 09:27 发表评论

EJB 3.0开发指南之多表映射

liaojiyong — Tue, 04 Jul 2006 01:26:00 GMT

在前面的例子中，我们每一个实体Bean只映��到数据库中的一张表上。事实上�Q�一个实体Bean可以映射到多张表上。在一些需要字典表的项目上会经常用刎ͼ�象以前我做过的项目，使用到很多国标规定的数据表。在我们下面�q�个例子中，性别作�ؓ一个字典表存在�Q�学生这个实体将映射到学生信息表、性别表这两个表�?

　　从表可以使用@SecondaryTable来注释：

@Target({TYPE}) @Retention(RUNTIME)

public @interface SecondaryTable {
　String name();
　String catalog() default "";
　String schema() default "";
　JoinColumn[] join() default {};
　UniqueConstraint[] uniqueConstraints() default {};
}

　　�q�个注释可以指定表名、分�c�R��schema、联合列、约束等。假如你使用多张表，你可以��用下面的注释来声明多张表:

@SecondaryTable
@Target({TYPE}) @Retention(RUNTIME)

public @interface SecondaryTables {
　SecondaryTable[] value() default {};
}

　　�q�个例子主要有以下几个文�Ӟ��q�个例子主要实现了管理学生的功能。Student是一个实体Bean�Q�这个Bean的name属性是一个类�Q�也��是Name�c�，�q�个Name�c�d��是一个依赖值对象。学生的性别映射到第二张表中。StudentDAOBean是一个无状态的会话Bean�Q�用来调用实体Bean。和前面的例子一��P��我们�q�是使用Client��试�?br />
　　�q�个例子和上一个例子基本相同，只是Student.java和Client有所不同�?br />
　　　Student.java�Q�实体Bean�?br />
　　　Name.java�Q�实体Bean所依赖的类�?br />
　　　StudentDAO.java�Q�会话Bean的业务接�?br />
　　　StudentDAOBean.java�Q�会话Bean的实现类

　　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />

Student.java

package com.kuaff.ejb3.secondary;

import javax.ejb.Dependent;
import javax.ejb.DependentAttribute;
import javax.ejb.Column;
import javax.ejb.Entity;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.Table;
import javax.ejb.SecondaryTables;
import javax.ejb.SecondaryTable;
import javax.ejb.JoinColumn;

@Entity
@Table(name = "STUDENT")
@SecondaryTables({
@SecondaryTable(name = "GENDER", join = {@JoinColumn(name = "GENDER_ID")})
})

public class Student implements java.io.Serializable
{
　private int id;
　private Name name;
　private String grade;
　private String email;
　private String gender;

　@Id(generate = GeneratorType.AUTO)

　public int getId()
　{
　　return id;
　}

　public void setId(int id)
　{
　　this.id = id;
　}

　public void setName(Name name)
　{
　　this.name = name;
　}

@Dependent({ @DependentAttribute(name = "first", column ={ @Column(name = "FIRST") }),

@DependentAttribute(name = "last", column ={ @Column(name = "LAST") }) })

public Name getName()
{
　return name;
}

public void setGrade(String grade)
{
　this.grade = grade;
}

@Column(name = "GRADE")

public String getGrade()
{
　return grade;
}

public void setEmail(String email)
{
　this.email = email;
}

@Column(name = "EMAIL")

public String getEmail()
{
　return email;
}

public void setGender(String gender)
{
　this.gender = gender;
}

@Column(name = "gender", secondaryTable = "GENDER")

public String getGender()
{
　return gender;
}

}

　　Student.java实现了Student实体Bean�Q�它提供学生的基本情��c��在�c�M��声明上加上了�W�二张表的注释：

@SecondaryTables({
@SecondaryTable(name = "GENDER", join = {@JoinColumn(name = "GENDER_ID")})
})

　　在gender属性上加上了映��第二张的注释：

@Column(name = "gender", secondaryTable = "GENDER")

Client.java

package com.kuaff.ejb3.secondary;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import java.util.List;

public class Client
{
public static void main(String[] args) throws NamingException

{

InitialContext ctx = new InitialContext();

StudentDAO dao = (StudentDAO) ctx.lookup(StudentDAO.class.getName());

int id = dao.create("�?,"��x��","8","smallnest@kuaff.com","�?);

dao.create("�?,"立焕","6","zhuzhu@kuaff.com","�?);

List list = dao.findAll();

for(Object o:list)

{

Student s = (Student)o;

System.out.printf("%s%s的性别:%s%n",s.getName().getFirst(),s.getName().getLast(),s.getGender());

dao.evict(s);

}

　　�q�个客户端增加学生的分数�Q��ƈ且测试显�C��个学生的email�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB�Q?br />
　　然后调用startDatabaseManager()�Ҏ(gu��)��Q�打开HSQL��理工具��理数据库�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:26 发表评论

EJB 3.0开发指南之使用实体Bean

liaojiyong — Tue, 04 Jul 2006 01:25:00 GMT

　在上面一个例子中�Q�实体Bean的属性对应到数据表中的列�Q�都是采用默认的讄��。通过Column�Q�你可以为属性指定数据表中的列名�?
Column的声明如下：

@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface Column {
　String name() default "";
　boolean primaryKey() default false;
　boolean unique() default false;
　boolean nullable() default true;
　boolean insertable() default true;
　boolean updatable() default true;
　String columnDefinition() default "";
　String secondaryTable() default "";
　int length() default 255;
　int precision() default 0;
　int scale() default 0;
　boolean specified() default true; // For internal use only
}

　　EntityManager 是用来处理实体Bean的辅助类。它可以用来产生/删除持久化的实体Bean�Q�通过主键查找实体bean�Q�通过查询语言来查询实体Bean�?br />
　　下面是EntityManager接口的声明：

package javax.ejb;

import java.sql.Connection;
/**
* 用来和持久化上下文交互的接口
*/

public interface EntityManager {

　/**
　* 使实体bean受持久化��理
　* @param entity
　*/

　public void create(Object entity);
　
　/**
　* ��给定的实体Bean的状态和持久化上下文�l�合。类似数据库的更新操作�?br />　* @param entity
　* @return 被结合的实体实例
　*/

　public T merge(T entity);

　/**
　* 删除实例
　* @param entity
　*/

　public void remove(Object entity);
　/**
　* �Ҏ(gu��)��主键查找.
　* @param entityName
　* @param primaryKey
　* @return 查询实例
　*/

　public Object find(String entityName, Object primaryKey);
　/**
　* �Ҏ(gu��)��主键查找
　* @param primaryKey
　* @return 查询实例
　*/

　public T find(Class entityClass, Object primaryKey);
　/**
　* 持久化上下文与底层数据库的同�?br />　*/

　public void flush();
　/**
　* 执行一个EJBQL查询
　* @param ejbqlString EJBQL查询语句
　* @return the new query instance
　*/

　public Query createQuery(String ejbqlString);
　/**
　* 执行命名的查�?br />　* @param name 预定义的查询名称
　* @return 查询实例
　*/

　public Query createNamedQuery(String name);
　/**
　* 执行一个本地SQL查询语句
　* @param sqlString 本地查询语句
　* @return �q�回查询实例
　*/

　public Query createNativeQuery(String sqlString);
　/**
　* 更新到数据库�?br />　* @param entity
　*/

　public void refresh(Object entity);
　/**
　* 持久化上下文中删除实�?br />　* @param entity
　*/

　public void evict(Object entity);
　/**
　* ��查当前上下文中是否包含此实体
　* context.
　* @param entity
　* @return
　*/

　public boolean contains(Object entity);
}

　　@JoinColumns

　　用来指示�W�合主键�Q�在后面的章节中介绍�?br />
　　 �q�个例子主要有以下几个文�Ӟ��q�个例子主要实现了管理学生分数的功能。Student是一个实体Bean�Q�管理学生的基本信息�Q�姓名和各课分数�Q�，其中学生的分数又是一个实体Bean。TacherBean是一个无状态的会话Bean�Q�用来调用实体Bean。和前面的例子一��P��我们�q�是使用Client��试�?br />
　　·Student.java�Q�实体Bean�?br />
　　·Score.java�Q�实体Bean�?br />
　　·Teacher.java�Q�会话Bean的业务接�?br />
　　·TeacherBean.java�Q�会话Bean的实现类

　　·Client.java�Q�测试EJB的客��L��c�R�?br />
　　·jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　·Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />
　　Student.java

package com.kuaff.ejb3.entity;

import javax.ejb.CascadeType;
import javax.ejb.Entity;
import javax.ejb.FetchType;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.JoinColumn;
import javax.ejb.OneToMany;
import javax.ejb.Table;
import java.util.ArrayList;
import java.util.Collection;
import java.io.Serializable;

@Entity
@Table(name = "STUDENT")

public class Student implements Serializable
{
　//主键
　private int id;
　//学生�?br />　private String name;
　//学生的分�?br />　private Collection scores;
　//主键自动产生

　@Id(generate = GeneratorType.AUTO)

　public int getId()
　{
　　return id;
　}

　public void setId(int id)
　{
　　this.id = id;
　}

　public String getName()
　{
　　return name;
　}

　public void setName(String name)
　{
　　this.name = name;
　}

　public void addScores(String name,int number)
　{
　　if (scores == null)
　　{
　　　scores = new ArrayList();
　　}
　　Score score = new Score();
　　score.setName(name);
　　score.setNumber(number);
　　score.setStudent(this);
　　scores.add(score);
　}

　@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
　@JoinColumn(name = "student_id")

　public Collection getScores()
　{
　　return scores;
　}

　public void setScores(Collection scores)
　{
　　this.scores = scores;
　}
}

　　Student.java实现了Student实体Bean�Q�它提供学生的基本情况以及学生的得分情况�Q�得分是另外一个实体Bean。Student实体Bean和Score实体Bean是一对多的关�p�，站在Score的角度看是多对一的关�p�R�?br />
　　实体Bean需要��用@Entity做注释，另外它指定这个实体Bean与表STUDENT对应�Q�通过注释@Table(name = "STUDENT")�Q�，你可以在JBOSS的数据库中看到这个表�?br />
　　Score.java

package com.kuaff.ejb3.entity;

import java.io.Serializable;
import javax.ejb.Entity;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.JoinColumn;
import javax.ejb.ManyToOne;
import javax.ejb.Table;

@Entity
@Table(name = "Score")

public class Score implements Serializable
{
　private int id;
　private String name;
　private int number;
　private Student student;

　//主键自动产生

　@Id(generate = GeneratorType.AUTO)

　public int getId()
　{
　　return id;
　}

　public void setId(int id)
　{
　　this.id = id;
　}

　public String getName()
　{
　　return name;
　}

　public void setName(String name)
　{
　　this.name = name;
　}

　public int getNumber()
　{
　　return number;
　}

　public void setNumber(int number)
　{
　　this.number = number;
　}

　@ManyToOne
　@JoinColumn(name = "student_id")

　public Student getStudent()
　{
　　return student;
　}

　public void setStudent(Student student)
　{
　　this.student = student;
　}

}

　　�q�个实体Bean存放学生的分数�?br />
　　Teacher.java

package com.kuaff.ejb3.entity;

import javax.ejb.Remote;

import javax.ejb.Remove;

import java.util.Map;

@Remote

public interface Teacher

{

public void addScore(String studentName,Map map);

public Student getStudent();

@Remove

public void leave();

}

　　�q�个会话Bean接口提供增加分数和得到用��L��Ҏ(gu��)��?br />
　　TeacherBean.java

package com.kuaff.ejb3.entity;

import javax.ejb.EntityManager;
import javax.ejb.Inject;
import javax.ejb.Remove;
import javax.ejb.Stateful;
import java.util.Map;
import java.util.Set;

@Stateful

public class TeacherBean implements Teacher
{
　@Inject
　private EntityManager manager;
　private Student student;

　public Student getStudent()
　{
　　return student;
　}

　public void addScore(String studentName, Map map)
　{
　　if (student == null)
　　{
　　　student = new Student();
　　}
　　student.setName(studentName);
　　Set set = map.keySet();
　　for (String sname:set)
　　{
　　　student.addScores(sname,map.get(sname).intValue());
　　}
　}

　@Remove

　public void leave()
　{
　　manager.create(student);
　}

}

　　�q�个是会话Bean的实现类�?br />
　　Client.java

package com.kuaff.ejb3.entity;

import java.util.Map;
import java.util.HashMap;
import java.util.Collection;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client
{
　public static void main(String[] args) throws NamingException
　{
　　InitialContext ctx = new InitialContext();
　　Teacher teacher = (Teacher) ctx.lookup(Teacher.class.getName());
　　Map map = new HashMap();
　　map.put("语文",new Integer(98));
　　map.put("化学",new Integer(149));
　　map.put("物理",new Integer(143));
　　teacher.addScore("smallnest",map);
　　Student student = teacher.getStudent();
　　String name = student.getName();
　　System.out.printf("昄��%s的分�?%n",name);
　　Collection c = student.getScores();

　　for (Score score:c)
　　{
　　　System.out.printf("%s:%s%n",score.getName(),score.getNumber()+"");
　　}
　}
}

　　�q�个客户端增加学生的分数�Q��ƈ且测试显�C��个学生的相关信息�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB�Q�然后调用startDatabaseManager()�Ҏ(gu��)��Q�打开HSQL��理工具��理数据库�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:25 发表评论

liaojiyong — Tue, 04 Jul 2006 01:25:00 GMT

在上面的章节我们提到�Q�实体bean的属性可以是java基本对象、Date�{�，事实上，实体Bean的属性也可以是其他的java对象。这些Java对象不能直接从持久化上下文中��d��Q�它依赖于主实体bean。不象关联实体Bean�Q�在EJB3.0中不支持依赖值对象的集合�?

　　依赖值对象不支持�l�承�Q�这��在EJB3.1中在讨论�?br />
　　依赖�c�需要��用◎DependentObject来注释：

@Target({TYPE}) @Retention(RUNTIME)
public @interface DependentObject {
　AccessType access() default PROPERTY;
}

　　�q�个注释可以指定容器讉K��q�个�cȝ��Ҏ(gu��)��Q�是通过属性还是直接通过字段来访问�?br />
　　在实体Bean的一个属性需要��用依赖值对象，那么�q�个属性的get�Ҏ(gu��)��需要��用@Dependent注释�Q?br />

@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Dependent {
　DependentAttribute[] value() default {};
}

　　�q�个注释可以指定依赖的属性DependentAttribute�Q?br />

@Target({}) @Retention(RUNTIME)

public @interface DependentAttribute {
　String name();
　Column[] column() default {};
}

　　可以指定属性名�U�和映射的列名。这里，一个主实体Bean的属性可以映��到数据表中的多列�?br />
　　如果你还不太明白�Q�看下面的例子�?br />
　　�q�个例子主要有以下几个文�Ӟ��q�个例子主要实现了管理学生的功能。Student是一个实体Bean�Q�这个Bean的name属性是一个类�Q�也��是Name�c�，�q�个Name�c�d��是一个依赖值对象。StudentDAOBean是一个无状态的会话Bean�Q�用来调用实体Bean。和前面的例子一��P��我们�q�是使用Client��试�?br />
　　·Student.java�Q�实体Bean�?br />
　　·Name.java�Q�实体Bean所依赖的类�?br />
　　·StudentDAO.java�Q�会话Bean的业务接�?br />
　　·StudentDAOBean.java�Q�会话Bean的实现类

　　·Client.java�Q�测试EJB的客��L��c�R�?br />
　　·jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　·Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />
　　Student.java

package com.kuaff.ejb3.dependent;

import javax.ejb.Dependent;
import javax.ejb.DependentAttribute;
import javax.ejb.Column;
import javax.ejb.Entity;
import javax.ejb.GeneratorType;
import javax.ejb.Id;
import javax.ejb.Table;

@Entity @Table(name = "STUDENT") public class Student implements java.io.Serializable
{
　private int id;
　private Name name;
　private String grade;
　private String email;

　@Id(generate = GeneratorType.AUTO)

　public int getId()
　{
　　return id;
　}

　public void setId(int id)
　{
　　this.id = id;
　}

　public void setName(Name name)
　{
　　this.name = name;
　}

@Dependent(
{ @DependentAttribute(name = "first", column ={ @Column(name = "FIRST") }),
　@DependentAttribute(name = "last", column ={ @Column(name = "LAST") }) })
　public Name getName()
　{
　　return name;
　}

　public void setGrade(String grade)
　{
　　this.grade = grade;
　}

　@Column(name = "GRADE")

　public String getGrade()
　{
　　return grade;
　}

　public void setEmail(String email)
　{
　　this.email = email;
　}

　@Column(name = "EMAIL")

　public String getEmail()
　{
　　return email;
　}
}

　　Student.java实现了Student实体Bean�Q�它提供学生的基本情��c��学生的姓名是Name�c�，通过@Dependent(

{ @DependentAttribute(name = "first", column ={ @Column(name = "FIRST") }),

@DependentAttribute(name = "last", column ={ @Column(name = "LAST") }) })

来声明，�q�指定这个依赖类的两个属性first和last�Q��ƈ映射到数据表的FIRST和LAST列上�?br />
　　Name.java

package com.kuaff.ejb3.dependent;

import java.io.Serializable;
import javax.ejb.AccessType;
import javax.ejb.DependentObject;

@DependentObject(access = AccessType.PROPERTY)

public class Name implements java.io.Serializable
{
　private String first;
　private String last;

　public Name()
　{}

　public Name(String first, String last)
　{
　　this.first = first;
　　this.last = last;
　}

　public String getFirst()
　{
　　return first;
　}

　public void setFirst(String first)
　{
　　this.first = first;
　}

　public String getLast()
　{
　　return last;
　}

　public void setLast(String last)
　{
　　this.last = last;
　}
}

　　�q�个值对象也很简单，和一般的javaBean差不多，但有两个地方需要注意：

　　1�Q?�q�个�c�d��C��java.io.Serializable接口

　　2�Q?�q�个�c�M��用@DependentObject做了注释

　　StudentDAO.java

package com.kuaff.ejb3.dependent;

import javax.ejb.Remote;
import java.util.List;

@Remote

public interface StudentDAO
{
　int create(String first, String last, String grade, String email);
　Student find(int id);
　List findByFirstName(String name);
　List findByLastName(String name);
　List findByEmail(String email);

　void merge(Student s);
}

　　�q�个会话Bean接口提供查找用户的方法�?br />
　　StudentDAOBean.java

package com.kuaff.ejb3.dependent;

import java.util.List;
import javax.ejb.EntityManager;
import javax.ejb.Inject;
import javax.ejb.Stateless;

@Stateless

public class StudentDAOBean implements StudentDAO
{
　@Inject
　private EntityManager manager;

　public int create(String first, String last, String grade, String email)
　{
　　Student student = new Student();
　　student.setName(new Name(first,last));
　　student.setGrade(grade);
　　student.setEmail(email);
　　manager.create(student);
　　return student.getId();
　}

　public Student find(int id)
　{
　　return manager.find(Student.class, id);
　}

　public List findByFirstName(String name)
　{
　　return manager.createQuery("from Student s where s.name.last = :name").setParameter("name", name).listResults();
　}
　public List findByLastName(String name)
　{
　　return manager.createQuery("from Student s where s.name.first = :name").setParameter("name", name).listResults();
　}

　public List findByEmail(String email)
　{
　　 return manager.createQuery("from Student s where s.email = :email").setParameter("email", email).listResults();
　}

　public void merge(Student s)
　{
　　manager.merge(s);
　}

}

　　�q�个是会话Bean的实现类。可以看到根据值对象的属性查找主实体Bean�?br />
　　Client.java

package com.kuaff.ejb3.dependent;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.List;

public class Client
{
　public static void main(String[] args) throws NamingException
　{
　　InitialContext ctx = new InitialContext();
　　StudentDAO dao = (StudentDAO) ctx.lookup(StudentDAO.class.getName());
　　int id = dao.create("�?,"��x��","8","smallnest@kuaff.com");
　　dao.create("�?,"立焕","6","zhuzhu@kuaff.com");
　　List list = dao.findByEmail("zhuzhu@kuaff.com");
　　for(Object o:list)
　　{
　　　Student s = (Student)o;
　　　System.out.printf("%s %s的email:%s%n",s.getName().getFirst(),s.getName().getLast(),s.getEmail());
　　}
　}
}

　　�q�个客户端增加学生的分数�Q��ƈ且测试显�C��个学生的email�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB�Q�然后调用startDatabaseManager()�Ҏ(gu��)��Q�打开HSQL��理工具��理数据库�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:25 发表评论

EJB 3.0 开发指南之定时服务

liaojiyong — Tue, 04 Jul 2006 01:24:00 GMT

在EJB2.1的规范中需要实现ejbTimeout�Ҏ(gu��)��Q�当然还有ejbPassivate、ejbRemove�{�方法。在EJB3.0中，只有你想用它们的时候，你才必须创徏它们�Q�否则不必实现�?

　　�q�个例子主要�?个文�Ӟ��q�个例子的Bean是一个无状态会话Bean�Q?br />
　　NewsTimer.java�Q�业务接口�?br />
　　NewsTimer.java�Q�业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean�Q��?br />
　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />

NewsTimer.java

package com.kuaff.ejb3.schedule;
import javax.ejb.Remote;
@Remote

public interface NewsTimer
{
　public void fiveNews();
}

　　�q�个接口定义了fiveNews�Ҏ(gu��)��Q�如果这个方法被调用�Q?分钟后将往控制��C��输出一条新闅R�?br />
　　你不必配�|�它的JNDI名称�Q�也不必写它的配�|�文件。在JBOSS实现的EJB3.0中，你不必写��M��的EJB部��v文�g和jboss部��v文�g。JBOSS默认使用接口的全�U�C��为它的JNDI名。在上面的例子中�Q�它的全�U�可以通过NewsTimerclass.forName()得到�?br />

NewsTimerBean.java

package com.kuaff.ejb3.schedule;
import java.util.Date;
import javax.ejb.Inject;
import javax.ejb.SessionContext;
import javax.ejb.Stateless;
import javax.ejb.Timer;

@Stateless

public class NewsTimerBean implements NewsTimer
{
　private @Inject SessionContext ctx;
　public void fiveNews()
　{
　　ctx.getTimerService().createTimer(new Date(new Date().getTime() + 300000), "子虚乌有�?sh��)视�?分钟新闻栏目:现在�q?分钟�Q�又到即时新闻节目的旉��了�?);
　}

　public void ejbTimeout(Timer timer)
　{
　　System.out.printf("旉��?%n%s%n" , timer.getInfo());
　　timer.cancel();
　}
}

Client.java

package com.kuaff.ejb3.schedule;

import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client
{
　public static void main(String[] args) throws NamingException
　{
　　InitialContext ctx = new InitialContext();
　　NewsTimer timer = (NewsTimer) ctx.lookup(NewsTimer.class.getName());
　　timer.fiveNews();
　}
}

　　�q�个�cȝ��来测试我们发布的计数器EJB。首先通过

ctx = new InitialContext();

　　得到上下文，然后通过lookup查找NewsTimer�Q�然后启动计时。�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:24 发表评论

EJB 3.0开发指南之依赖注入

liaojiyong — Tue, 04 Jul 2006 01:23:00 GMT

依赖注入�Q�Dependency Injection�Q�，又称作控制反�?IOC)�Q�本来是一�U�设计模式，现在被吵得热火朝天，有点�q�了。比较有名项目如String,picoContainer�{��?

　　在EJB3.0中，可以通过在字�D�和讄��Ҏ(gu��)��上加上注释注入依赖，我想在很快会有新的项目，或者在原来的项目的基础上，一些IOC容器会采用注释的方式注入依赖�Q�JDK5.0加入的注释的��是一个很强大的功能，相对而言�Q�在.net中的属性却没有发挥那么大的价倹{��这��是开源的威力�Q�成千上万的在开源java�E�序员不断涌现出新的��x��新的功能�?br />
　　看下面的例子�Q�我们知�?JBOSS中已�l�默认配�|�了一个数据源�Q�它的JNDI名称�?java:/DefaultDS"。下面这个例子声明了一个数据源�Q�通过注释�Q�就可以��JBOSS的这个默认的数据源赋值给它�?br />

@Resource(jndiName="java:/DefaultDS")
public DataSource customerDB;
Resource注释的声�?br />@Target({TYPE, METHOD, FIELD, PARAMETER}) @Retention(RUNTIME)

public @interface Resource {

String name() default "";

String resourceType() default "";

AuthenticationType authenticationType() default CONTAINER;

boolean shareable() default true;

String jndiName() default "";

}

public enum Authentication Type {

CONTAINER,

APPLICATION

}

@Target(TYPE) @Retention(RUNTIME)

public @interface Resources {

Resource[] value();

}

　　Resource的name指向一个在环境属性中命名的资源，AuthenticationType用来指定是容器还是EJB�l��g来进行��n份验证，sharebale指定是否�׃�n,jndiName用来指定JDNI中的名称。resourceType()用来指定资源的类型�?br />
　　如果name和resourceType都指向被注释的程序成员，AuthenticationType和resourceType都是�~�省的，则可以��用Inject注释�Q?br />

@Inject(jndiName="java:/DefaultDS")

public DataSource customerDB;

　　对于单例的成员，你可以更��化：

@Inject javax.ejb.SessionContext ctx;

@Inject javax.ejb.TimerService timer;

@Inject javax.ejb.UserTransaction ut;

@Inject javax.ejb.EntityManager manager;

　　Resources注释可以注入多个资源�?br />
　　在Eclipse中导入本文提供的例子DI�?br />
　　�q�个例子从数据库中读取JMS_USER表，�q�显�C��中的内容。这个例子��用依赖注入的方式得到JBOSS默认的数据源�?br />
　　�q�个例子主要�?个文�Ӟ��

　　　JmsUsers.java�Q�业务接口�?br />
　　　JmsUsersBean.java�Q�业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean�Q��?br />
　　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />

JmsUsers.java

package com.kuaff.ejb3.di;
import java.util.List;
import javax.ejb.Remote;
import javax.sql.*;

@Remote
public interface JmsUsers
{
　public List getUsers();
}

　　�q�个接口很简单，定义了一个得到全部用��L��Ҏ(gu��)��Q�JBOSS默认使用接口的全�U�C��为它的JNDI名。在上面的例子中�Q�它的全�U�可以通过JmsUsers.class。getName�Q�）得到�?br />

CounterBean.java

package com.kuaff.ejb3.di;
import java.util.List;
import java.util.ArrayList;
import javax.ejb.Stateless;
import javax.ejb.Resource;
import javax.sql.*;
import java.sql.*;

@Stateless
public class JmsUsersBean implements JmsUsers
{
　@Resource(jndiName="java:/DefaultDS",resourceType="javax.sql.DataSource")
　public DataSource customerDB;
　public List getUsers()
　{
　　List list = new ArrayList();
　　try
　　{
　　　Connection conn = customerDB.getConnection();
　　　Statement st = conn.createStatement();
　　　ResultSet rs = st.executeQuery("select * from jms_users");
　　　while(rs.next())
　　　{
　　　　list.add(rs.getString("userid"));
　　　}
　　}
　　catch(SQLException e)
　　{}
　　return list;
　}
}

　　�q�个是业务逻辑的具体实现。一旦这个EJB被容器��生，则容器将JBOSS的数据源注入到customerDB变量上，所以不要以为customerDB没有被初始化�Q�这些工作是容器做的�?br />

Client.java

package com.kuaff.ejb3.di;
import java.util.List;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client
{
　public static void main(String[] args)
　{
　　InitialContext ctx;
　　try
　　{
　　　ctx = new InitialContext();
　　　JmsUsers users = (JmsUsers) ctx.lookup(JmsUsers.class.getName());
　　　List jmsUsers = users.getUsers();
　　　for(String user:jmsUsers)
　　　{
　　　　System.out.printf("用户�?%s%n",user);
　　　}
　　}
　　catch (NamingException e)
　　{
　　　e.printStackTrace();
　　}
　}
}

　　�q�个�cȝ��来测试我们发布的EJB�l��g。显�C�Z��JMS_USERS表中��d��的数据�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB

　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-04 09:23 发表评论

EJB 3.0开发指南之消息驱动Bean

liaojiyong — Tue, 04 Jul 2006 01:23:00 GMT

消息驱动Bean的业务接口已�l�被定义�Q�对于��用JMS来说那就是MessageListener接口�Q�这个接口定义了OnMessage�Ҏ(gu��)��?

　　实现�c�d��M��用MessageDriven注释。可以实��C��可以不实现setMessageDrivenContext和ejbRemove�Ҏ(gu��)��?br />
　　在JBOSS中，通过ConnectionConfig指定消息的队列的JNDI名称�?br />

@ConnectionConfig(destinationType = javax.jms.Queue.class, destinationJndiName = "queue/kuaffejb3/sample", durable = true, subscriptionId = "kuaffMessage")

　　在Eclipse中导入本文提供的例子Messager�?br />
　　�q�个例子从客��L��发送一个TextMessage�Q�这个Bean�l��g接收到这个消息后�Q�将把这个消息输出到控制��C��?br />
　　�q�个例子主要�?个文�Ӟ��

　　　Messager.java�Q�业务组件�?br />　　
　　　Client.java�Q�测试EJB的客��L��c�R�?br />　
　　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　　queue-example-service.xml�Q�消息服务，用来��试消息�?br />
　　下面针对每个文�g的内容做一个介�l��?br />

Messager.java

package com.kuaff.ejb3.messager;

import org.jboss.ejb3.mdb.ConnectionConfig;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.TextMessage;
import javax.jms.MessageListener;

@MessageDriven
@ConnectionConfig(destinationType = javax.jms.Queue.class, destinationJndiName = "queue/kuaffejb3/sample", durable = true, subscriptionId = "kuaffMessage")

public class Messager implements MessageListener
{
　public void onMessage(Message recvMsg)
　{
　　System.out.println("接收到的消息:");
　　try
　　{
　　　TextMessage message = (TextMessage)recvMsg;
　　　System.out.println(message.getText());
　　}
　　catch (JMSException e)
　　{
　　　e.printStackTrace();
　　}
　}
}

　　�q�个消息Bean很简单，接收到消息后不做什么处理，��是��消息内容输出到控制��C��Q?br />

Client.java

package com.kuaff.ejb3.messager;

import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.TextMessage;
import javax.naming.InitialContext;

public class Client
{
　public static void main(String[] args) throws Exception
　{
　　QueueConnection cnn = null;
　　QueueSender sender = null;
　　QueueSession session = null;
　　InitialContext ctx = new InitialContext();
　　Queue queue = (Queue) ctx.lookup("queue/kuaffejb3/sample");
　　QueueConnectionFactory factory = (QueueConnectionFactory) ctx.lookup("ConnectionFactory");
　　cnn = factory.createQueueConnection();
　　session = cnn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
　　TextMessage msg = session.createTextMessage("江湖快报:玉树临风风流倜傥的公子小巢又出现了�?);
　　sender = session.createSender(queue);
　　sender.send(msg);
　　System.out.println("消息已经发出");
　}
}

　　�q�个客户端将发送一个文本消息到队列中�?br />

queue-example-service.xml
�Q?xml version="1.0" encoding="UTF-8"?�Q?br />�Q�server�Q?br />�Q�mbean code="org.jboss.mq.server.jmx.Queue" name="jboss.mq.destination:service=Queue,name=kuaffMessage"�Q?br />　�Q�attribute name="JNDIName"�Q�queue/kuaffejb3/sample�Q?attribute�Q?br />　�Q�depends optional-attribute-name="DestinationManager"�Q�jboss.mq:service=DestinationManager�Q?depends�Q?br />�Q?mbean�Q?br />�Q?server�Q?/td>

　　配置�q�个�E�序所需的消息服务�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?

liaojiyong 2006-07-04 09:23 发表评论

EJB3.0开发指南之有状态会话Bean(�?

liaojiyong — Mon, 03 Jul 2006 01:43:00 GMT

　和无状态会话Bean一��P��一个有状态会话Bean必须有一个业务接口，�q�个接口�׃��话Bean来实玎ͼ�或者也可以�׃��话Bean来��生。这��P��你可以只写一个文�Ӟ��可以生成业务逻辑实现�c�R��远�E�接口、本地接口等�?

　　在目前jboss的实��C��Q�必��要有一个独立的业务接口�?br />
　　�q�个接口不必实现EJBObject或者EJBLocalObject�?br />
　　一个有状态会话Bean 必须使用Statelfull注释�Q�以表明它是一个有状态的会话Bean。EJB容器��根据这个注释来判定它的�c�d��。或者实现javax.ejb.SessionBean接口�?br />
　　一个有状态的会话Bean可以实现setSessionContext�Ҏ(gu��)��Q�也可以不实现�?br />
　　在EJB2.0中调用EJBObject.remove�Ҏ(gu��)��以达��C��容器中删除有状态会话Bean的功能。在EJB3.0中只需在一些方法加上Remove注释。一旦这些被标记的方法被调用后，此EJB��从容器中删除�?br />
　　一个有状态的会话Bean可以通过依赖注入获取容器的资源和环境属性�?br />
　　在Eclipse中导入本文提供的例子Stateful�?br />
　　�q�个例子和无状态会话Bean的例子类��|��下面只列��Z��不同的代码�?br />
　　�q�个例子主要�?个文�Ӟ��

　　　Counter.java�Q�业务接口�?br />
　　　CounterBean.java�Q�业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean�Q��?br />
　　　Client.java�Q�测试EJB的客��L��c�R�?br />
　　　jndi.properties�Q�jndi属性文�Ӟ��提供讉K��jdni的基本配�|�属性�?br />
　　　Build.xml�Q�ant 配置文�g�Q�用以编译、发布、测试、清除EJB�?br />
　　下面针对每个文�g的内容做一个介�l��?br />

Counter.java
…�?br />import javax.ejb.Remove;
…�?br />@Remote

public interface Counter
{
　…�?br />　@Remove
　public void clean();
}

　　�q�个接口很简单，和无状态会话Bean基本相同�Q�但新增加了一个Clean�Ҏ(gu��)��Q��ƈ为此�Ҏ(gu��)��加上Remove注释。一旦此�Ҏ(gu��)��被执行完毕，此Bean��被从容器中删除�?br />
　　JBOSS默认使用接口的全�U�C��为它的JNDI名。在上面的例子中�Q�它的全�U�就是：com.kuaff.ejb3.stateful.Counter�Q�你也可以通过Counter.class得到�?br />

CounterBean.java
…�?br />import javax.ejb.Stateful;
…�?br />@Stateful

public class CounterBean implements Counter
{
　//增加事务支持
　@Tx(TxType.REQUIRESNEW)
　public int getNumber()
　{
　　return number;
　}

　@Remove

　public void clean()
　{
　　System.out.println("我，被删除了!");
　}
}

　　�q�个是计数器的实现类。注意这个类使用Stateful做了注释�Q�这是必��ȝ��。同�Ӟ��q�个例子也演�C�Z��如何使用事务。事务的详细用法��在后面的章节中介绍�?br />

Client.java
package com.kuaff.ejb3.stateful;

import javax.ejb.EJBException;
import java.rmi.NoSuchObjectException;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class Client
{
　public static void main(String[] args)
　{
　　InitialContext ctx;
　　try
　　{
　　　ctx = new InitialContext();
　　　Counter counter = (Counter) ctx.lookup(Counter.class.getName());
　　　counter.add(10);
　　　System.out.println("当前的number:" + counter.getNumber());
　　　counter.add(10);
　　　System.out.println("当前的number:" + counter.getNumber());
　　　Counter counter2 = (Counter) ctx.lookup(Counter.class.getName());
　　　counter2.add(10);
　　　System.out.println("当前的number:" + counter2.getNumber());
　　　//删除
　　　counter2.clean();
　　　//下面如果再��用counter2,��出�?br />　　　try
　　　{
　　　　System.out.println("当前的number:" + counter2.getNumber());
　　　}
　　　catch(EJBException ex)
　　　{
　　　　if (ex.getCausedByException() instanceof NoSuchObjectException)
　　　　{
　　　　　System.out.println("我都被删除啦�Q�还找我�Q?);
　　　　}
　　　　else
　　　　{
　　　　　throw ex;
　　　　}
　　　}
　　}
　　catch (NamingException e)
　　{
　　　e.printStackTrace();
　　}
　}
}

　　�q�个�cȝ��来测试我们发布的计数器EJB。首先通过

　　ctx = new InitialContext();得到上下文，然后通过lookup查找计数器，然后�l�计数器�?0�Q�显�C�当前的计数器信息。最后调用Clean�Ҏ(gu��)��Q�一旦这个方法执行完毕，此EJB��从容器中删除，在��用这个EJB��会出现异常�?br />
　　误��行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS�?br />
　　在Eclipse的Ant视图中执行ejbjar target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant ejbjar,��编译打包发布此EJB�?br />
　　在Eclipse的Ant视图中执行run target。或者在命��o行下�Q�进入到此工�E�目录下�Q�执行ant run,��试�q�个EJB�?br />

liaojiyong 2006-07-03 09:43 发表评论

liaojiyong — Mon, 03 Jul 2006 01:30:00 GMT

本文关键字：EJB, 设计模式, pattern, session bean, entity bean, message driven bean, command, dto, factory

文章工具
推荐�l�朋�?/a>
打印文章

一�Q?设计模式重要�?br />采用�Q�Ｊ�Q�技术的�Q�２�Q��I��目中，�Q�Ｊ�Q�架构的设计好坏��直接媄响系�l�的性能、可扩展性、可�l�护性、组件可重用性及开发效率。项目越复杂�Q�项目队伍越庞大则越能体现良好设计的重要性�?

二．常见EJB设计模式

Session Facade Pattern
通常��目中，客户端往往需要频�J�的�Ҏ(gu��)��务器端数据进行操作。当采用实体�Q�Ｊ�Q�作为数据的抽象层时�Q�如果直接让客户端程序与实体�Q�Ｊ�Q�交互，会��生实��C��个业务需求便需要大量的�Q�Ｊ�Q�属性操作（如下图１�Q�。这直接��D��如下问题�Q�网�l�负载大�Q�远�E�客��L��Ӟ��、�ƈ发性能低、客��L��与服务器端关联度大、可重用性和可维护性差、性能
因此有必要在客户端与实体�Q�Ｊ�Q�层间加入Session　�Q�Ｊ�Q�层�Q�在Sessino EJB中实现商业逻辑�q�封装对实体�Q�Ｊ�Q�的操作。（如下图２�Q?br />
图１�Q�客��L��直接与实体��I�Q��交互

图２�Q�通过SessionEJB层实�?br />Session Fa?ade模式的好处是�Q�降低了�|�络负蝲�Q�SessionEjb可以调用实体�Q�Ｊ�Q�的本地接口�Q�将商业逻辑与商业数据隔��；�l�护与开发方便；显著提高性能�?br />Session Fa?ade模式因其��单��用，是目前��用很�q�的模式。但具体应用�q�程中应注意�Q�避免将所有的操作��装��C��个很大的SessionEJB内；服务器端数据�l�构应由实体EJB实现,除非特例否则避免直接的数据库操作�Q�SessionEjb内某些系�l�通用操作的代码容易重复（比如权限��查等�Q�解军_��法是��系�l�通用服务��装在Java Class内）�?/p>

Message Facade Pattern
很多时候，一�ơRequest需要操作多个��I�Q��又不需要得到即时返回。对�q�种异步调用�Q�通常应用Message Fa?ade Pattern.
�q�种时候，如采用Session Fa?ade Pattern存在如下问题�Q?br />1. 客户端等待返回的旉��q�长。一个SessionEjb的实例在完成客户��h��q�程中中涉及到的每一�ơ对其他实体Ejb的调用过�E�中都会被锁定直到得到实体EJB�q�回信息后才能进行下一步操作。这样造成客户不必要的�{�待�Q��ƈ很容易因旉��D��整个事务��p�|�?br />2. �pȝ��可靠性和定w��性低。如果需要调用不同系�l�或服务器上或多个异构数据源的多个��I�Q��Ӟ��M��一个环节出错，均导致客戯��求失败�?br />以Message-Driven Bean为基��的Message Facade Pattern则可以解决上�q�异步请求需求。具体架构见下图�Q?

　图３�Q��用Message Facade Pattern

Message Facade Pattern的不��之处在于：
�Q�． Message-Driven Bean没有�q�回倹{��这样通知客户执行�l�果只能依赖于��Iｍａｉｌ或�h工等其他手段�?br />�Q�． Message-Driven Bean执行�q�程中无法将捕获的异常直接返回给客户端，��x��法��客户端直接直到错误信息�?br />�Q�． Message-Driven Bean通过接收Message响应客户��h��Q�对Message内容的合法性（比如对象的类型等�Q�依赖与客户�?�Ҏ(gu��)��产生�q�行旉��误�?br />Message Facade Pattern�l�常与Session Facade Pattern在同一个项目里共同使用�?/p>

EJB Command Pattern

Session Facade Pattern中将商业逻辑实现��装在Session EJB中，�q�种做法带来诸多益处之外也带来如下问题：
�Q�． �׃��业务�l�常的变化，��D��l�常需要更新Session EJB代码�?br />�Q�．客户端代码不得不包含大量EJB相关的Ａ�Q�;��Q�不利于后期��目�l�护�?br />�Q�． ��目开发测试需要经常的EJB重部�|�过�E��?br />引�v上述问题的重要根�l�就是Session EJB本��n重量�U�组�Ӟ��其开发测试部�|�工作量较大�Q�开发周期较�ѝ��以上不��_��以通过EJB Command Pattern克服�?br />EJB Command Pattern中将商业逻辑实现��装在普通的Java Class�Q�称之�ؓCommand Bean�Q�中。该模式的具体实现有很多�U�，通常的框枉��包括三部分：
�Q�． Command Bean.由应用开发者写的具体实现某商业操作的Java Class.主要包含getXXX(),setXXX(),execute()�Ҏ(gu��)��?br />�Q�． Client-Side Routing Logic.由多个Class�l�成�Q�用于将��h��转发至Command Sever�Q�这个过�E�对客户是透明的。这部分代码可以跨项目��用。�\��p��则中可以考虑用��Q�Ｌ技术�?br />�Q�． Remote Command Server.实际执行商业操作��h��。通常可以用Session EJB层实现�?/p>

　整个框架见下图４�Q?br />

　图４�Q�Command的基本框�?br />EJB Command Pattern��h��如下好处�Q?br />�Q�．适应与需要快速开发环境。因Command Bean是轻量��的Java Class�Q�其�~�译和调试比较方�ѝ�?br />�Q�． ��表现层与商业实现层隔离�Q�同时将客户端代码与EJB层隔��R�?br />�Q�． ��客��L��代码开发与服务器端代码开发相�Ҏ(gu��)��晰。早期可以创建空的Command Bean方便客户端代码调试�?br />　　　　EJB Command Pattern的弱处在于：
�Q�． Command Bean中对事务的控制不如Session EJB中�?br />�Q�． Command Bean是无状态的�?br />�Q�．无法��异常直接返回给客户�?br />�Q�．在大��目中，�׃��商业逻辑复杂�Q�常��D��大数量的Command Bean存在.
�Q�．作�ؓCommand Server的Session EJB打包时必��d��含Command Bean以致存在�l�护上的不便�?br />　　EJB Command Pattern的一个实际实现可以参考IBM's Command Framework.

Data Transfer Object Factory
��Z��EJB的J2EE��目�Q�经帔R��要在客户端与服务器端传输大量数据。数据的�l�织形式常用的是DTO(Data Transfer Object�Q�服务器端数据对象的抽象)。但因�ؓ客户端表现层�l�常是变化的�Q�所需要服务器端数据也变动频繁�Q�换句话��_��DTO的数量和属性经常要更改。因此如何以及在何处生成和维护DTO便是需要考虑的问题�?br />一�U�解��x��案是直接在Entity EJB中直接处理，卛_��Entity EJB的Bean�c�M��加入getXXXDTO()、setXXXDTO()�{�。但�q�样做导致EJB与DTO层紧紧绑定。一旦DTO更改�Q�与该DTO相关的EJB即需要重�~�译打包。EJB层与客户端层相关联不仅�ɾl�护困难而且��D��EJB的重用性大大降低�?br />更好的解��x��案是利用Data Transfer Object Factory��装对DTO的操作逻辑�Q�如下图�Q�）�?br />

图６�Q�DTO Factory�C�Z��
DTO Factory具体实现方式通常有两�U�：
�Q�．普通Java Class实现�Q�用于Session Facade Pattern使用DTO环境下�?br />�Q�． Stateless Session EJB实现�Q�用于非EJB客户端��用DTO环境下（见图�Q�）�?br />

图７�Q�SessionEJB实现DTOFactory
DTO Factory带来如下好处�Q?br />�Q�．使Entity EJB的重用成为可能。由于不含DTO处理逻辑�Q�Entity EJB功能单一化，只作为数据源。不通客��L��通过各自的DTO Factory可以从同一个Entity EJB得到各自所需的个性化数据�Q�自定义DTO�Q��?br />�Q�．提高可维护性和性能�?br />�Q�．可以�Ҏ(gu��)��在DTO Factory层生成很复杂的DTO�l�构�Q�诸如��ѝ��关联关�pȝ��Q�而对客户端提供一个透明、细化的数据接口�?br />　　　使用DTO Factory旉��要注意的是：不需为每个Entity EJB定义一个Factory。可以�ؓ一�p�d��相关的Entity EJB创徏一个Factory�Q�或者只创徏一个Factory�?/p>

Generic Attribute Access

使用Entity EJB作�ؓ商业数据层时�Q�我们首先需要从数据库加载数据，创徏对应的Entity EJB实例�Q�之后对内存中Entity EJB实例的属性进行相应操作。对属性的操作比较直接的做法是�Q�直接调用Entity EJB的getXXX()/setXXX()�Q�通常利用EJB2.0的本地接口；通过DTO Factory生成DTO。但�q�两�U�做法都存在如下问题�Q?br />�Q�．当Entity EJB的属性特别多时候，以上做法会带来复杂罗嗦的代码�Q��EJB变的庞大无比�?br />�Q�．使Entity EJB的客��L��Q�比如Session EJB�Q�和Entity EJB的接口紧密关联。Entity EJB属性的增删都需要更改客��L��代码�Q�给��目开发和�l�护带来不便�?br />事实上可以利用更通用的方式访问Entity EJB的属性，卛_��义Generic Attribute Access Interface。见下图�Q�：

　图８�Q�Generic Attribute Access Interface�C�Z��

Generic Attribute Access Interface由Entity EJB的本地或�q�程接口实现�Q��ƈ利用Hash Maps传输数据。实现方式常见如下：
�Q�． BMP�c�d��实体EJB可以在Bean�c�M��定义包含所有属性的�U�有成员变量HashMap�?br />�Q�． CMP�c�d��实体EJB可以在Bean�c�M��可以适用Java Reflection API实现�?br />�Q�．建立一个父�c�，在不同的情况下定义子�c�重载父�c�L��法�?br />使用Generic Attribute Access Interface需要在客户端与服务器端对属性以及对应的关键字徏立统一的命名习惯。常见的做法如下�Q?br />�Q�．建立�q�保持良好的文档记录和命名约定�?br />�Q�．在实体EJB的实现类中定义静态成员映��属性�?br />�Q�．创徏�׃�n静态类�Q�通过成员变量映射实体EJB属性�?br />�Q�．通过JNDI在服务器端保存属性映��关�p�R�?br />Generic Attribute Access Interface的运用带来一下益处：
�Q�．接口实现后对不通实体EJB都适用�?br />�Q�．对属性较多实体EJB能精��代码�Q��ƈ更具�l�护性�?br />�Q�．使运行中动态增删实体EJB属性成为可能�?br />Generic Attribute Access Interface的缺点在于：
�Q�．讉K��EJB属性时增加了额外的操作。需要通过关键字映��属性，最后还需�q�行�c�d��转换�?br />�Q�．需要徏立客��L��与服务器端的命名�U�定�?
�Q�．因�ؓ通过HashMap操作时候需要进行类型�{换，�Ҏ(gu��)��产生�q�行时类型不匚w��异常�?/p>

Business Interface

EJB规范要求Bean实现�c�d��d��现所有在�q�程�Q�或本地�Q�接口中定义的所有方法，同时不允许Bean实现�cȝ��接��承远�E�（或本圎ͼ�接口。这��导致编译时候很�Ҏ(gu��)��产生两者不一致的问题�Q�即�q�程�Q�或本地�Q�接口中定义的某�Ҏ(gu��)��为在Bean实现�c�M��被实现等错误。�ؓ避免上诉错误�Q�可以利用应用服务器厂商所提供的工兗��但也可以应用EJB的设计架构来实现�Q�定义商业接口�?br />Business Interface卛_��定义商业接口�Q�在接口中定义所有EJB提供的商业方法，�q�让Bean实现�c�d��q�程�Q�或本地�Q�接口都实现该商业接口。其�l�承关系见下图９�Q?br />

图９�Q�商业接口的使用
Business Interface是个普通的Java Class。依赖于使用本地接口与远�E�接口的不通，Business Interface的定义略有不同：应用与远�E�接口时�Q�在接口中的�Ҏ(gu��)��需要抛出java.rmi.RemoteException�Q�而应用与本地接口时候则不需要作��M��特别处理�?br />应用Business Interface时候必��L��意一点：EJB规范不允许直接EJB的实例将对自��q��引用�Q�this对象�Q�返回给客户端，否则�~�译时候即报错。但使用Business Interface后，�~�译时候无法检查出有无��this对象�q�回�l�客��L��。这一炚w��要程序员自己保证�?/p>

三．内部数据转换�{�略

Data Transfer Object
��Z��EJB的J2EE多层架构应用中，�l�常涉及的一个问题就是如何在各层之间传递批量数据，比如客户端对服务器端数据的批量读写操作等。比如需要得到实体EJB的属性，直接的方法是多次调用不通的属性，如下图１�Q�：

图１�Q�：低效的数据传递方�?br />　　但这�U�方法容易导致许多问题，比如性能以及代码的复杂度�{�，更有效的办法是在一个调用中得到所有需要的属性。所以可以引入Data Transfer Object来封装所需要的属性，�q�在客户与服务器端通过传递该对象一�ơ实现对数据的操作。如下图�Q�１�Q?br />
　图１�Q�：通过DTO传递数�?br />　　
DTO为普通的Java Class�Q�通常是服务器端数据的快照。由于网�l�传输的需要，DTO应该实现java.io.Serializable接口�?br />DTO的设计有两种模型�Q�Domain DTO以及Custom DTO�?br />Domain DTO仅仅实现�Ҏ(gu��)��务器数据的拷贝，通常与实体EJB��Z��对一的关�p?也存在�ؓ多个相关联的实体EJB对应一个Domain DTO)。Domain DTO通常除用于读取更改实体EJB属性外也可用于创徏实体EJB时候。实体EJB与Domain DTO对应关系如下图１�Q�：

　图１�Q�：Account EJB 与　Account DomainDTO
Domain DTO的应用除了DTO所��h��的一般优点外�Q�还有别的益处：
�Q�．开发迅速。因��Z��旦实体EJB设计好后�Q�很�Ҏ(gu��)��转换得到Domain DTO�?br />�Q�．可以利用Domain DTO的setXXX()�Ҏ(gu��)��在客��L��q�行属性有效性效验�?br />Domain DTO的缺�Ҏ(gu��)��Q?br />�Q�．客户端绑定了服务器端数据模型�Q�不利于�l�护�?br />�Q�．不够灉|��Q�无法处理客��L��的多样化数据要求。对一个数百个属性的实体EJB��h��一个属性时候却�q�回一个包含所有属性值的Domain DTO明显是笨重的实现�?br />�Q�． ��D��代码的重复�?br />�Q�． Domain DTO中如果嵌套包含了别的Domain DTO�Ӟ��一旦需服务器端数据的更改而需要重定义Domain DTO模型时候异常困难�?/p>

Custom DTO则可以克服上�q�的一些缺炏V��Customer DTO仅仅��装用户感兴��的服务器数据集卛_��以根据客��L��需求创建Customer DTO。这样作的优�Ҏ(gu��)��灉|��高效�Q�缺�Ҏ(gu��)��大项目中可能��D��大量的Customer DTO存在�?br />通常Domain DTO可以用于数据的更��C��创徏�Q�Customer DTO可以用于客户用于表现层的数据��d��。两者可以相辅相成。而且使用DTO一般与DTO Factory同时使用�?/p>

Domain Transfer Hash Map
　　DTO的��用往往�~�Z��通用性。不通的用户案例需要创��Z��同的DTO。当��目很复杂时�Q�从�l�护性考虑需要更好的数据传输的实现方式�?
Domain Transfer Hash Map卛_��用HashMap作�ؓ客户所需数据集的��装。好处是�Q?br />�Q�．良好的维护性�?br />�Q�．较大的通用性。不同的客户端可以��用相同的数据传递方式�?br />�~�点是：
�Q�．需要维护客��L��与服务器端在属性及其对应关键字的映��关�p�R�?br />�Q�．当需要��用基本类型的数据时候，因�ؓHash Map的限制必��d��基本�c�d��先�{换成对象�?br />�Q�．使用得到的数据时�Q�需要进行类型强制�{换�?/p>

Data Transfer RowSet
当需要处理直接的JDBC调用得到的结果集�Ӟ��昄��用DTO/Hash Map已经不合适，因�ؓ需要对大量数据�q�行�c�d��转换�{�额外操作是很费资源和不必要的，而且最�l�用户常需要以表格式样昄��数据�?
所以对二维表式数据�Q�更好的处理方式是利用Data Transfer RowSet。Data Transfer RowSet通过��ResultSet直接转换为RowSet传递给客户端�?br />在Session EJB中��用RowSet的一�D늤�例代码如下图�Q�３�Q?br />
图１�Q�：使用RowSet
使用RowSet的好处很多：
�Q�．接口通用于各��L��数据库查询操作�?br />�Q�．当需要表格式数据昄��Ӟ��因�ؓ直接从ResultSet得到�Q�所以不需要额外的数据�c�d��转换�?br />�~�点是：
�Q�．数据库结构暴露给客户端�?br />�Q�．不符合面向对象设计思想�?br />�Q�．依赖于SQL�?br />Data Transfer RowSet通常用于只读式数据的昄��操作�Q�经常和JDBC for Reading Pattern�q�用�?/p>

四．事务和数据持久机�?/p>

　　JDBC for Reading Pattern

��Z��EJB的J2EE应用中，通过EJB�Ҏ(gu��)��据库的操作可以有两种方式�Q�实体EJB或者Session EJB中直接利用JDBC讉K��?br />客户很多时候取出数据库中数据�ƈ以表格方式显�C�。这�U�情形如果��用实体EJB会导致如下问题：
�Q�．引用服务器端频繁的数据库查询和加载操作。因为加载N个实体EJB总需要进行一�ơfind()操作　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　N�ơ数据加载�?br />�Q�．如果使用Remote接口�Q�引起频�J�的额外�|�络操作�?br />�Q�．对关联关�p�L��较复杂的数据库表�l�构�Q�很隄��接通过Entity EJB表现�?br />因此��在只需�Ҏ(gu��)��据库表数据进行只读访问时候，应该采用JDBC for Reading Pattern�Q�即通过JDBC直接讉K��数据库。除了避免上�q�C��用实体EJB的缺点还带来一下好处：
�Q�．充分利用数据库能力，比如数据库的�~�存机制�?br />�Q�．减少了对事务控制的资源�?br />�Q�．利用自定义SQL可以按需要比较灵�zȝ��d��数据�?br />�Q�．只需要一�ơ数据查询，减少了数据库操作�?br />�~�点是：
�Q�．于J2EE应用的面向对象设计相�q�背�?br />�Q�．因�ؓSession EJB代码中包含了自定义SQL�Q�维护性差�?br />�Q�． Session EJB中不得不包含JDBC的API�Q��ƈ且需要了解数据库�l�构�?/p>

liaojiyong 2006-07-03 09:30 发表评论

liaojiyong — Sun, 02 Jul 2006 16:57:00 GMT

EJB3介绍:Overview

EJB作�ؓ企业�U�的数据讉K��/持久化标准在1999�q�作为J2EE规范的核心规范出玎ͼ�极大的�{变了java企业�U�开发的模式�Q��ؓjava软�g开发提供了一个良好的架构�?EJB�?.0�?.1在J2EE架构中，都是作�ؓ一个服务器端的(Server side)的数据访问中间�g。开发�h员通过EJB标准的API接口来访问操作数据，避免直接用JDBC和Sql操作底层的数据库�?

采用EJB架构的目标在于：

减轻直接操作底层数据库的工作�?
��Z��业��开发引入了面向对象/面向服务的开发架�?
数据对象生命周期的自动管�?
分布式能�?
集成/声明式的安全/事务��理

在旧的EJB模型中（2.1以前�Q?EJB实现了大部分的目标，但一个巨大的�~�陷是原有的模型在试囑և��L��据访问工作量的同时也引入了更多的复杂开发需求�?例如EJB核心的的Entity Bean必须特定的Home,Remote,Business接口�Q�发布前需要预�~�译�Q�只能实现单表映��操作，静态的EJB-QL(EJB查询语言�Q�都不能满��化数据库操作的目标�?EJB 2.1的复杂度�Q�开发成本和性能问题使得EJB在问�?�q�后仍然�{�不到广泛的应用�?

��C��2004�q�_��随着POJO( Plain Old Java Object )模型的出玎ͼ�动态代码操作，IOC模式�{�先�q�，��单实用技术的发展和它们在各种独立产品中的表现�Q�都证明POJO,IOC的技术比原有的EJB 2.1模型更适合作�ؓ数据讉K��中间�Ӟ��开发的隑ֺ�和成本远�q�小于目前的EJB模型�Q�确有更灉|��和可扩展�?2004�q?月J2EE�q�_��规范集众家所长，推出了跨��式的Java EE 5.0规范�Q�最核心的是全面引入新的��Z��POJO和IOC技术的EJB3模型。到此，J2EE 5规范( Java EE 5 )成�ؓ一个集大成者，�U�百家之长，成�ؓjava企业开发统一的标准规范�?

EJB 3中的元数据批�?Annotation

EJB3 规范中引入了元数据批�?Annotation)。Annotation是从J2SE 1.5开始称为java语言的一部分。Annotation�q�不是一个新的事物，在J2SE 1.5以前�Q��h们已�l�自行引入了象著名的XDoclet�{�外挂式的元数据�Ҏ(gu��)��Ҏ(gu��)��。而在.NET中，元数据批注也早已�l�是C#语言的成分了�?

在以往�Q�我们都是采用xml作�ؓ配置�Ҏ(gu��)��Q�但采用文本的xml配置存在一些缺��P��

描述�W�多�Q�不�Ҏ(gu��)��记忆和掌�?
无法做自动的校验�Q�需要�h工排�?
当系�l�变大时�Q�大量的xml配置难以��理
��d��和解析xml配置非常耗时�Q�导致应用启动缓慢，不利于测试和�l�护
做O/R Mapping的时候需要在java文�g和xml配置文�g之间交替�Q�增大了工作�?
�q�行中保存xml配置需要消耗额外的内存

采用元数据可以很好的解决�q�些问题:

描述�W�大量减��。以往在xml配置中往往需要描�q�java属性的�c�d��Q�关�pȝ��{�。而元数据本��n��是java语言�Q�从而省略了大量的描�q�符
�~�译期校验。错误的�Ҏ(gu��)��在编译期间就会报错�?
元数据批注在java代码中，避免了额外的文�g�l�护工作
元数据被�~�译成java bytecode�Q�消耗小的多内存�Q�读取也非常�q�速，往往比xml配置解析快几个数据量�U�，利于��试和维�?

�W�一个Entity Bean:HelloWorld

EJB3中的Entity Bean是如此的��单，��是一个普通的java bean加上一些精炼的元数据批注�?

                
@Entity
@Table( name="helloTable" )
public class HelloEntityBean {

    private int id;
    private String foo;

    /**
     * The entity class must have a no-arg constructor.
     */
    public HelloEntityBean() {
    }

    public HelloEntityBean(int id, String foo) {
        this.id = id;
        this.foo = foo;
    }

    @Id(generate=GeneratorType.NONE)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFoo() {
        return foo;
    }

    public void setFoo(String foo) {
        this.foo = foo;
    }

    public String toString(){
        return "HelloEntityBean: id=" + id + ", foo=" + foo;
    }
}

代码中元数据的说明：

@Entity :EJB3 Entity Bean的批注，表明当前的java bean作�ؓ一个Entity Bean来处理�?/p>

@Table( name="helloTable" ) :��֐�思义�Q�定义当前Entity对应数据库中的表�?/p>

@Id(generate=GeneratorType.NONE) :我们把HelloEntityBean的id属性定义�ؓ主键。主键��生策略�ؓGeneratorType.NONE,意味�q�是一个业务主键�?/p>

��p��么简单！

解说Entity

从EJB3.0开始，Entity Bean持久化规范与EJB的其他规范如Session Bean, Message Driven Bean和EJB3容器规范开始分��，单独作�ؓ一个持久化API。而在��来�Q�该持久化API很可能会从EJB3.0规范中脱��d��来成��Z��个独立的规范Java Persistence API。作为Java�q�_��上的通用数据讉K��标准接口�?��Z��跟规范一��_��我们��在开发手册中��Entity Bean�U�CؓEntity�?/p>

虽然EJB3 Entity可以是很��单的java bean�Q�只要批注了@Entity或者在xml配置中作了说明，��p��做一个可持久化的Entity处理�?但还是需要遵行一定的规则�Q?/p>

Entity�c�d��要有一个无参数的public或者protected的Constructor�?
如果在应用中需要将该Entity�c�d��d��来在分布式环境中作�ؓ参数传递，该Entity Class需要实现java.io.Serialzable接口�?
Entity�c�M��可以是final�Q�也不可有final的方法�?
abstract�c�d��Concrete实体�c�都可以作�ؓEntity�c�R�?
Entity�c�M��的属性变量不可以是public。Entity�cȝ��属性必��通过getter/setter或者其他的商业�Ҏ(gu��)��获得�?

定义对Entity中属性变量的讉K��

在绝大部分的商业应用�Q�开发�h员都可以忽略�q�部分无需兛_��。但如果你需要编写复杂的Entity�cȝ��话，你需要了解这个部分。复杂的Entity�c�L��指在Entity�cȝ��getter/setter和商业方法中包含比较复杂的业务逻辑而不是仅仅返�?�W�值某个属性�?/p>

在大部分的情况下�Q�我们都��使Entity�c�M��setter/getter中的逻辑��可能简单，除了必要的校验符值外�Q�不要包含复杂的业务逻辑�Q�例如对兌��的其他Entity�c�进行操作。但有些情况下，我们�q�是需要在Entity�cȝ��setter/getter�Ҏ(gu��)��中包含商业逻辑。这时候，采用何种属性访问方式就可能会媄响代码的性能甚至是逻辑正确产生影响�?/p>

EJB3持久化规范中,在默认情况下所有的属性都会自动的被持久化�Q�除非属性变量用@Transient元数据进行了标注。针对可持久化属性定义了两种属性访问方�?access): FIELD和PROPERTY�?/p>

如果采用access=FIELD, EJB3 Persistence�q�行环境�Q�EJB3持久化��品，如Liberator EJB3)直接讉K��对象的属性变量，而不是通过getter。这�U�访问方式也不要求每个属性必��L��getter/setter。如果需要在getter中包含商业逻辑�Q�应该采用access=FIELD的方式�?
如果采用access=PROPERTY, EJB3 Persistence�q�行环境?y��u)��通过Entity�c�M��的getter来访问对象的属性变量，�q�就要求每个属性变量要有getter/setter�Ҏ(gu��)��。在EJB3中，默认的属性访问方式是PROPERTY。access=PROPERTY时getter/setter的逻辑应该��量��单�?

规范中access方式�q�有多一层含义。就是采用access=FIELD�Ӟ��元数据应该批注在属性上�?/p>

                
    @Id(generate=GeneratorType.NONE)
    private int id;
    private String foo;

    /**
     * The entity class must have a no-arg constructor.
     */
    public HelloEntityBean() {
    }

    
    public int getId() {
        return id;
    }

采用access=PROPERTY(默认方式)�Ӟ��元数据应该批注在对应属性变量的getter上�?/p>

                     
    private int id;
    private String foo;

    /**
     * The entity class must have a no-arg constructor.
     */
    public HelloEntityBean() {
    }

    @Id(generate=GeneratorType.NONE)
    public int getId() {
        return id;
    }

��Z��方便开发，Liberator EJB3实现对元数据�Ҏ(gu��)��的位�|�比规范规定的宽松，针对属性变量或它的getter�q�行�Ҏ(gu��)��都可以，不受access�c�d��的媄响�?/p>

对Entity�c�M��Q�getter/setter的命名规则遵从java bean规范�?/p>

Entity�c�M��的属性变量可以是以下数据�c�d��Q?/p>

原始数据�c�d��和他们的对象�c�d��
java.lang.String
java.math.BigInteger
java.math.BigDecimal
java.util.Date
java.util.Calendar
java.sql.Date
java.sql.Time
java.sql.Timestamp
byte[]
Byte[]
char[]
Character[]
enums
Entity�c?
嵌入实体�c?embeddable classes)

�q�可以是以下集合�c�d��:

java.util.Collection和它的实体类
java.util.Set和它的实体类
java.util.List和它的实体类
java.util.Map和它的实体类

主键和实体标识（Primary Key and Entity Identity)

每个Entity�c�都必须有一个主键。在EJB3中定义了两种主键�Q?/p>

键单主键
复合主键

��单主键必��d��应Entity中的一个属性变量（Instance Variable)�Q�而该属性对应数据库表中的一列。��用简单主键，我们只需要用@Id元数据对一个属性变量或者她的getter�Ҏ(gu��)��q�行�Ҏ(gu��)��?/p>

当我们需要��用一个或多个属性变量（表中的一列或多列�Q�联合�v来作��Z��键，我们需要��用复合主键。复合主键要求我们编写一个复合主键类( Composite Primary Key Class )。复合主键类需要符合以下一些要求：

复合主键�c�d��L��public和具备一个没有参数的constructor
复合主键�cȝ��每个属性变量必��L��getter/setter�Q�如果没有，每个属性变量则必须是public或者protected
复合主键�c�d��d��现java.io.serializable
复合主键�c�d��d��现equals()和hashcode()�Ҏ(gu��)��
复合主键�c�M��的主键属性变量的名字必须和对应的Entity中主键属性变量的名字相同
一旦主键��D��定后�Q�不要修改主键属性变量的�?

一��L��一个复合主键的例子。Entity�c�Person�Q�它的主键属性变量是firstName和lastName�?

                
    @Id
    private String firstName;
    
    @Id
    private String lastName;

    public Person() {
    }

Person的复合主键类�Q?

                
public class PersonPK implements java.io.Serializable{
    
    private String firstName;
    private String lastName;

    public PersonPK() {
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof PersonPK)) return false;

        final PersonPK personPK = (PersonPK) o;

        if (!firstName.equals(personPK.firstName)) return false;
        if (!lastName.equals(personPK.lastName)) return false;

        return true;
    }

    public int hashCode() {
        int result;
        result = firstName.hashCode();
        result = 29 * result + lastName.hashCode();
        return result;
    }
}

liaojiyong 2006-07-03 00:57 发表评论

EJB3.0之操作Entity

liaojiyong — Sun, 02 Jul 2006 16:57:00 GMT

操作持久化Entity

对Entity�q�行操作的API都设计在javax.persistence.EntityManager接口上。EntityManager�Q�顾名思义是管理所有EJB 3�q�行环境中的所有Entity�?EntityManager�Ҏ(gu��)��q�行的环境不同分为容器管理的EntityManager和应用管理的EntityManager。Liberator EJB3是一个可以运行在J2SE环境中的嵌入式的EJB3 Persistence实现�Q�因此在Liberator EJB3中的 EntityManager都是指应用管理的EntityManager�?/p>

配置和获得EntityManager

在J2SE环境中，EJB3定义了一个javax.persistence.Persistence�cȝ��于启动EJB3�q�行环境。要获得EntityManager,首先需要通过javax.persistence.Persistence获得EntityManagerFactory�Q�然后调用EntityManagerFactory.createEntityManager()�Ҏ(gu��)��获得�?

                
    // 获得默认当前的EntityManagerFactory                
    final EntityManagerFactory emf = Persistence.createEntityManagerFactory();
    final EntityManager entityManager = emf.createEntityManager();

当调用Persistence.createEntityManagerFactory()的时候，Persistence会做以下的步骤：

搜烦当前jar包的META-INFO/persistence.xml配置文�g
如果没有在META-INFO下找到persistence.xml�Q�搜索当前线�E�的ContextClassLoader中的persistence.xml
�Ҏ(gu��)��获得的persistence.xml初始化EntityManagerFactory

每个EntityManagerFactory都必��L��一个persistence.xml配置文�g。下面是一个例子：

                

    myEntityManager
    com.redsoft.ejb3.PersistenceProviderImpl
    com.redsoft.samples.HelloEntityBean

定义一个EntityManagerFactory的名字，�q�样当应用中需要多个EntityManagerFactory的时候可以区别。通常情况下，一个EntityManagerFactory对应一个数据源�?/p>

定义采用的什么EJB3 Persistence�q�行环境�Q�也��是EJB3 Persistence产品)�Q�例子中采用的的是Liberator EJB3的运行环境。正如前面说的，在EJB3规范�? EJB3 Persistence�q�行环境( Runtime )是作��Z��个独立的嵌入式模块，你可以随意的更换不同的EJB3 Persistence�q�行环境而不会媄响你的应用程序�?strong>甚至在J2EE服务器内�q�行你也可以不用服务器本�w�提供的EJB3 Persistence�q�行环境�Q�而采用第三方的EJB3 Persistence�q�行环境�?/p>

定义哪些�c�L��Entity持久化类。如果是��试环境或者你不采用ear/war的方式发布你的应用，而只是把�~�译后的�cȝ��接拷贝到web容器中，在添加一个新的Entity�c�L��Q�需要在�q�里��d��一行。要求这个步骤是因�ؓ在J2EE 5架构中EJB3�q�行环境的嵌入式设计。采用这�U�松耦合设计使EJB3 Persistence�q�行环境不能控制持久化类的加�?由J2EE服务器负责加�?, �q�样EJB3 Persistence�q�行环境?y��u)��无法分辨jvm中哪个类是持久化Entity�c�，哪个不是。因此需要一个额外的信息来让EJB3 Persistence知道那些是持久化Entity�?/p>

定义了了EJB3 Persistence�q�行环境需要的其他参数�Q�这些参��C��是标准的�Q�而是由EJB3 Persistence�q�行环境的厂商自行定义�?/p>详细的配�|�方法参看persistence.xml的语法�?

持久化Entity(Persist)

                
    final EntityManagerFactory emf = Persistence.createEntityManagerFactory();
    final EntityManager entityManager = emf.createEntityManager();

    final HelloEntityBean hello = new HelloEntityBean( 1, "foo" );
    EntityTransaction trans = entityManager.getTransaction();
    trans.begin();
    
    // 持久化hello,在此操作之前hello的状态�ؓnew
    entityManager.persist( hello );
    
    // �q�时hello的状态变为managed
    
    trans.commit();

    entityManager.close();
    
    // �q�时hellow的状态变为detached.

Liberator EJB3支持Persistence by reachability。当保存一个Entity�Ӟ��以该对象为根对象的整个对象图都会自动的被保存。但在EJB3中，我们仍然可以通过关系元数据（比如OneToOne,OneToMany)的cascade属性来�_��定义保存的��联行为�?下面我们来看看不同的cascade属性的区别�?

不配�|�cascade的情况下�Q�EJB3 Persistence�q�行环境默认不会采用Persistence by reachability�?/p>

                
    public class Father{
        @Id
        int id
        
        String name;
        
        // OneToOne没有配置cascade属性，因此默认不会使用Persistence by reachablity
        @OneToOne
        Son mySon
        
        public Father( int id, String name, Son mySon ){
            this.id = id;
            this.name = name;
            this.mySon = mySon;
        }
    }

现在来保存一个Father和Son�?

                
    final EntityManager manager = emf.createEntityManager();
    manager.getTransaction().begin;
    
    Son mySon = new Son();
    Father = new Father( 1, "father" mySon );
    
    // 保存Father
    manager.persist( father );
    
    // �׃��OneToOne关系中没有配�|�casacade属性，father 兌���的mySon不会被自动保存，需要分别保�?
    manager.persist( mySon );
    manager.getTransaction().commit();
    manager.close();

现在我们配置casacde=CascadeType.ALL

                
    public class Father{
        @Id
        int id
        
        String name;
        
        // OneToOne配置cascade=CascadeType.ALL,配置cascade=CascadeType.PERSIT也对persist操作也可以获得同��L��效果�?
        // CascadeType.ALL包含CascadeType.PERSIST�?
        @OneToOne(cascade=CascadeType.ALL)
        Son mySon
        
        public Father( int id, String name, Son mySon ){
            this.id = id;
            this.mySon = mySon;
            this.name = name;
        }
    }

在代码中同样持久化Father和mySon�?

                
    final EntityManager manager = emf.createEntityManager();
    manager.getTransaction().begin;
    
    Son mySon = new Son();
    Father = new Father( 1, mySon );
    
    // 保存Father。由于OneToOne关系中配�|�casacade=CascadeType.ALL属�?兌���的mySon会自动地被持久化
    manager.persist( father );
    manager.getTransaction().commit();
    manager.close();

�׃��Liberator EJB3�q�行环境采用了弱引用POJO��理技术，能很好的支持Persistence by reachablity而不会有其他产品有的潜在内存回收的问题，因此��在应用中��可能��用cascade=CascadeType.ALL来减��持久化操作的复杂性和代码�?/strong>�Q�特别是在有复杂对象关系囄��时候�?

获取Entity
如果知道Entity的唯一标示�W�，我们可以用find()�Ҏ(gu��)��来获得Entity�?
Father father = manager.find( Father.class, new Integer( 1 ) ); // �׃��JDK1.5支持自动转型�Q�也可以如下使用 Father father = manager.find( Father.class, 1 ); /* *　或�?可以用Entity名字作�ؓ查找。但无法利用JDK 1.5的自动�{型功能， * 需要��用对象作为查找主键，�q��要对获得Entity�q�行转型 */ Father father = (Father)manager.find( "com.redsoft.samples.Father", new Integer( 1 ) );

更新Entity
对Entity的更新必��d��事物内完成。和persist中一��P��关系元数据的cascade属性对是否集联删除有媄响�?
transaction.begin(); Father father = manager.find( Father.class, 1 ); // 更新原始数据�c�d�� father.setName( "newName" ); // 更新对象引用 Son newSon = new Son(); father.setSon( newSon ); // 提交事务�Q�刚才的更新同步到数据库 transaction.commit();

删除Entity
对Entity的删除必��d��事物内完成�?
transaction.begin(); Father father = manager.find( Father.class, 1 ); // 如果father/son的@OneToOne的cascade=CascadeType.ALL�Q�在删除father时候，也会把son删除�? // 把cascade属性设为cascade=CascadeType.REMOVE有同��L��效果�? manager.remove( father ); // 提交事务�Q�刚才的更新同步到数据库 transaction.commit();

��q��/附合(Detach/Merge)

在三层或者分布式应用中，我们很多时候需要Entity能脱��EntityManager�Q�避免长旉��保持EntityManager打开占用资源和可以在不同的JVM之间传递Entity�?/p>
在脱��EJB3 Persistence Runtime(EntityManager)的管理后,我们仍然可以��d��或者修改Entity中的内容。而在�E�后的时��_��我们又可以将Entity重新和原有或者新的EntityManager附合�Q�如果附合前Entity被改动过�Q�更改的数据可以自动的被发现�q�和数据库同步�?/p>

EntityManager entityManager = emf.createEntityManager(); // �q�时Father�q�是被EntityManager��理�? Father father = manager.find( Father.class, 1 ); // 当entityManger关闭的时候，当前被entityManager��理的Entity都会自动的脱��EntityManager�Q�状态�{变�ؓdetached entityManager.close(); // ��q��EntityManager后，我们仍然可以修改Father的属�? father.setName( "newName" ); // 在稍后的�Q�我们可以将father重新附和��C��个新的或者原来的EntityManager�? EntityManager newEntityManager = emf.createEntityManager(); // 附合( merge )需要在事务中进�? newEntityManager.getTransaction().begin(); newEntityManager.merge( father ); // commit后father中的被修改的内容会同步到数据库�? newEntityManager.getTransaction().commit();

Liberator EJB3 Persistnece�q�行环境�׃��支持Persistence-by-reachablity。我们徏议采用cascade=CascadeType.ALL�Q�这样当需要附合的是一个对象图的时候，我们只需要merge根对象即可，整个对象图，对象图中被修改过的对象都会被自动识别和同步�?/p>
需要注意的是在��q��EJB3 Persistence Runtime的管理后�Q�如果对象中有定义�ؓlazy-load的属性将无法讉K��?/p>

liaojiyong 2006-07-03 00:57 发表评论

liaojiyong — Sun, 02 Jul 2006 16:53:00 GMT

Table

Table用来定义entity主表的name�Q�catalog�Q�schema�{�属性�?/p>
元数据属性说明：

name: 表名

catalog: 对应关系数据库中的catalog

schema�Q�对应关�p�L��据库中的schema

UniqueConstraints:定义一个UniqueConstraint数组�Q�指定需要徏唯一�U�束的列�Q�具体参�?a >UniqueConstraint�Q?

@Entity @Table(name="CUST") public class Customer { ... }

　　

SecondaryTable

一个entity class可以映射到多表，SecondaryTable用来定义单个从表的名字，主键名字�{�属性�?/p>
元数据属性说明：

name: 表名

catalog: 对应关系数据库中的catalog

schema�Q�对应关�p�L��据库中的schema

pkJoin: 定义一个PrimaryKeyJoinColumn数组�Q�指定从表的主键列（具体参看PrimaryKeyJoinColumn�Q?

UniqueConstraints:定义一个UniqueConstraint数组�Q�指定需要徏唯一�U�束的列�Q�具体参�?a >UniqueConstraint�Q?

下面的代码说明Customer�c�L��到两个表，主表名是CUSTOMER�Q�从表名是CUST_DETAIL�Q�从表的主键列和主表的主键列�c�d��相同�Q�列名�ؓCUST_ID�?/p>

@Entity @Table(name="CUSTOMER") @SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID")) public class Customer { ... }

SecondaryTables

当一个entity class映射��C��个主表和多个从表�Ӟ��用SecondaryTables来定义各个从表的属性�?/p>
元数据属性说明：

value�Q?定义一个SecondaryTable数组�Q�指定每个从表的属性�?

@Table(name = "CUSTOMER") @SecondaryTables( value = { @SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }), @SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) }) public class Customer {}

UniqueConstraint

UniqueConstraint定义在Table或SecondaryTable元数据里�Q�用来指定徏表时需要徏唯一�U�束的列�?/p>
元数据属性说明：

columnNames:定义一个字�W�串数组�Q�指定要建唯一�U�束的列名�?

@Entity @Table(name="EMPLOYEE", uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})} ) public class Employee { ... }

Column

Column元数据定义了映射到数据库的列的所有属性：列名�Q�是否唯一�Q�是否允��ؓ�I�，是否允许更新�{��?/p>
元数据属性说明：

name:列名�?

unique: 是否唯一

nullable: 是否允许为空

insertable: 是否允许插入

updatable: 是否允许更新

columnDefinition: 定义��时创建此列的DDL

secondaryTable: 从表名。如果此列不建在主表上（默认建在主表�Q�，该属性定义该列所在从表的名字�?

public class Person { @Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true) private String name; @Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO") private byte[] picture;

JoinColumn

如果在entity class的field上定义了关系�Q�one2one或one2many�{�）�Q�我们通过JoinColumn来定义关�pȝ��属性。JoinColumn的大部分属性和Column�c�M��?/p>
元数据属性说明：

name:列名�?

referencedColumnName:该列指向列的列名�Q�徏表时该列作�ؓ外键列指向关�p�d��一端的指定列）

unique: 是否唯一

nullable: 是否允许为空

insertable: 是否允许插入

updatable: 是否允许更新

columnDefinition: 定义��时创建此列的DDL

secondaryTable: 从表名。如果此列不建在主表上（默认建在主表�Q�，该属性定义该列所在从表的名字�?

下面的代码说明Custom和Order是一对一关系。在Order对应的映��表��Z��个名为CUST_ID的列�Q�该列作为外键指向Custom对应表中名�ؓID的列�?/p>

public class Custom { @OneToOne @JoinColumn( name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true) public Order getOrder() { return order; }

JoinColumns

如果在entity class的field上定义了关系�Q�one2one或one2many�{�）�Q��ƈ且关�p�d��在多个JoinColumn�Q�用JoinColumns定义多个JoinColumn的属性�?/p>
元数据属性说明：

value: 定义JoinColumn数组�Q�指定每个JoinColumn的属性�?

下面的代码说明Custom和Order是一对一关系。在Order对应的映��表��Z��列，一列名为CUST_ID�Q�该列作为外键指向Custom对应表中名�ؓID的列,另一列名为CUST_NAME�Q�该列作为外键指向Custom对应表中名�ؓNAME的列�?/p>

public class Custom { @OneToOne @JoinColumns({ @JoinColumn(name="CUST_ID", referencedColumnName="ID"), @JoinColumn(name="CUST_NAME", referencedColumnName="NAME") }) public Order getOrder() { return order; }

Id

声明当前field为映��表中的主键列。id值的获取方式有五�U�：TABLE, SEQUENCE, IDENTITY, AUTO, NONE。Oracle和DB2支持SEQUENCE�Q�SQL Server和Sybase支持IDENTITY,mysql支持AUTO。所有的数据库都可以指定为AUTO�Q�我们会�Ҏ(gu��)��不同数据库做转换。NONE(默认)需要用戯��己指定Id的倹{��Table�c�d��详见TableGenerator的介�l��?/p>
元数据属性说明：

generate():主键值的获取�c�d��

generator():TableGenerator的名字（当generate=GeneratorType.TABLE才需要指定该属性）

下面的代码声明Task的主键列id是自动增长的�?Oracle和DB2从默认的SEQUENCE取��|��SQL Server和Sybase该列建成IDENTITY�Q�mysql该列建成auto increment�?

@Entity @Table(name = "OTASK") public class Task { @Id(generate = GeneratorType.AUTO) public Integer getId() { return id; } }

IdClass

当entity class使用复合主键�Ӟ��需要定义一个类作�ؓid class。id class必须�W�合以下要求:�c�d��d��明�ؓpublic�Q��ƈ提供一个声明�ؓpublic的空构造函数。必��d��现Serializable接，覆写equals()和hashCode�Q�）�Ҏ(gu��)��。entity class的所有id field在id class都要定义�Q�且�c�d��一栗��?/p>
元数据属性说明：

value: id class的类�?

public class EmployeePK implements java.io.Serializable{ String empName; Integer empAge; public EmployeePK(){} public boolean equals(Object obj){ ......} public int hashCode(){......} } @IdClass(value=com.acme.EmployeePK.class) @Entity(access=FIELD) public class Employee { @Id String empName; @Id Integer empAge; }

MapKey

在一对多�Q�多对多关系中，我们可以用Map来保存集合对象。默认用主键值做key�Q�如果��用复合主键，则用id class的实例做key�Q�如果指定了name属性，��q��指定的field的值做key�?/p>
元数据属性说明：

name: 用来做key的field名字

下面的代码说明Person和Book之间是一对多关系。Person的books字段是Map�c�d��Q�用Book的isbn字段的��g��为Map的key�?/p>

@Table(name = "PERSON") public class Person { @OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person") @MapKey(name = "isbn") private Map books = new HashMap(); }

OrderBy

在一对多�Q�多对多关系中，有时我们希望从数据库加蝲出来的集合对象是按一定方式排序的�Q�这可以通过OrderBy来实玎ͼ�默认是按对象的主键升序排列�?/p>
元数据属性说明：

value: 字符串类型，指定排序方式。格式�ؓ"fieldName1 [ASC|DESC],fieldName2 [ASC|DESC],......",排序�c�d��可以不指定，默认是ASC�?

下面的代码说明Person和Book之间是一对多关系。集合books按照Book的isbn升序�Q�name降序排列�?/p>

@Table(name = "MAPKEY_PERSON") public class Person { @OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person") @OrderBy(name = "isbn ASC, name DESC") private List books = new ArrayList(); }

PrimaryKeyJoinColumn

在三�U�情况下会用到PrimaryKeyJoinColumn�?

�l�承(详见Inheritance)�?

entity class映射��C��个或多个从表。从表根据主表的主键列（列名为referencedColumnName值的列）�Q�徏立一个类型一��L��主键列，列名由name属性定义�?

one2one关系�Q�关�pȝ��护端的主键作为外键指向关�p�被�l�护端的主键�Q�不再新��Z��个外键列(�?a >JoinColumn不同)�?

元数据属性说明：

name:列名�?

referencedColumnName:该列引用列的列名

columnDefinition: 定义��时创建此列的DDL

下面的代码说明Customer映射��C��个表�Q�主表CUSTOMER,从表CUST_DETAIL�Q�从表需要徏立主键列CUST_ID�Q�该列和主表的主键列id除了列名不同�Q�其他定义一栗��?

@Entity @Table(name="CUSTOMER") @SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"�Q�referencedColumnName="id")) public class Customer { @Id(generate = GeneratorType.AUTO) public Integer getId() { return id; } }

下面的代码说明Employee和EmployeeInfo是一对一关系�Q�Employee的主键列id作�ؓ外键指向EmployeeInfo的主键列INFO_ID�?

@Table(name = "Employee") public class Employee { @OneToOne @PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID") EmployeeInfo info; }

PrimaryKeyJoinColumns

如果entity class使用了复合主键，指定单个PrimaryKeyJoinColumn不能满��要求�Ӟ��可以用PrimaryKeyJoinColumns来定义多个PrimaryKeyJoinColumn�?

元数据属性说明：

value: 一个PrimaryKeyJoinColumn数组�Q�包含所有PrimaryKeyJoinColumn�?

下面的代码说明了Employee和EmployeeInfo是一对一关系。他们都使用复合主键�Q�徏表时需要在Employee表徏立一个外键，从Employee的主键列id,name指向EmployeeInfo的主键列INFO_ID和INFO_NAME.

@Entity @IdClass(EmpPK.class) @Table(name = "EMPLOYEE") public class Employee { private int id; private String name; private String address; @OneToOne(cascade = CascadeType.ALL) @PrimaryKeyJoinColumns({ @PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"), @PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")}) EmployeeInfo info; } @Entity @IdClass(EmpPK.class) @Table(name = "EMPLOYEE_INFO") public class EmployeeInfo { @Id @Column(name = "INFO_ID") private int id; @Id @Column(name = "INFO_NAME") private String name; }

Transient

Transient用来注释entity的属性，指定的这些属性不会被持久化，也不会�ؓ�q�些属性徏表�?/p>

@Transient private String name;

　　

Version

Version指定实体�c�d��乐观事务中的version属性。在实体�c�重新由EntityManager��理�q�且加入��C��观事务中�Ӟ��保证完整性。每一个类只能有一个属性被指定为version�Q�version属性应该映��到实体�cȝ��主表上�?/p>
下面的代码说明versionNum属性作��个类的version�Q�映��到数据库中主表的列名是OPTLOCK�?/p>

@Version @Column("OPTLOCK") protected int getVersionNum() { return versionNum; }

Lob

Lob指定一个属性作为数据库支持的大对象�c�d��在数据库中存储。��用LobType�q�个枚�D来定义Lob是二�q�制�c�d��q�是字符�c�d��?/p>
LobType枚�D�c�d��说明�Q?/p>

BLOB 二进制大对象�Q�Byte[]或者Serializable的类型可以指定�ؓBLOB�?

CLOB 字符型大对象�Q�char[]、Character[]或String�c�d��可以指定为CLOB�?

元数据属性说明：

fetch�Q?定义�q�个字段是lazy loaded�q�是eagerly fetched。数据类型是FetchType枚�D�Q�默认�ؓLAZY,即lazy loaded.

type�Q?定义�q�个字段在数据库中的JDBC数据�c�d��。数据类型是LobType枚�D�Q�默认�ؓBLOB�?

下面的代码定义了一个BLOB�c�d��的属性和一个CLOB�c�d��的属性�?/p>

@Lob @Column(name="PHOTO" columnDefinition="BLOB NOT NULL") protected JPEGImage picture; @Lob(fetch=EAGER, type=CLOB) @Column(name="REPORT") protected String report;

JoinTable

JoinTable在many-to-many关系的所有者一边定义。如果没有定义JoinTable�Q��用JoinTable的默认倹{�?/p>
元数据属性说明：

table:�q�个join table�?a >Table定义�?

joinColumns:定义指向所有者主表的外键列，数据�c�d��?a >JoinColumn数组�?

inverseJoinColumns:定义指向非所有者主表的外键列，数据�c�d��?a >JoinColumn数组�?

下面的代码定义了一个连接表CUST和PHONE的join table。join table的表名是CUST_PHONE�Q�包含两个外键，一个外键是CUST_ID�Q�指向表CUST的主键ID�Q�另一个外键是PHONE_ID�Q�指向表PHONE的主键ID�?/p>

@JoinTable( table=@Table(name=CUST_PHONE), joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"), inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID") )

TableGenerator

TableGenerator定义一个主键值生成器�Q�在Id�q�个元数据的generate�Q�TABLE�Ӟ��generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义�?/p>
生成器是为多个实体类提供�q�箋的ID值的表，每一行�ؓ一个类提供ID��|��ID值通常是整数�?/p>
元数据属性说明：

name:生成器的唯一名字�Q�可以被Id元数据��用�?

table:生成器用来存储id值的Table定义�?

pkColumnName:生成器表的主键名�U��?

valueColumnName:生成器表的ID值的列名�U��?

pkColumnValue:生成器表中的一行数据的主键倹{�?

initialValue:id值的初始倹{�?

allocationSize:id值的增量�?

下面的代码定义了两个生成器empGen和addressGen�Q�生成器的表是ID_GEN�?/p>

@Entity public class Employee { ... @TableGenerator(name="empGen", table=@Table(name="ID_GEN"), pkColumnName="GEN_KEY", valueColumnName="GEN_VALUE", pkColumnValue="EMP_ID", allocationSize=1) @Id(generate=TABLE, generator="empGen") public int id; ... } @Entity public class Address { ... @TableGenerator(name="addressGen", table=@Table(name="ID_GEN"), pkColumnValue="ADDR_ID") @Id(generate=TABLE, generator="addressGen") public int id; ... }

SequenceGenerator

SequenceGenerator定义一个主键值生成器�Q�在Id�q�个元数据的generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。生成器是数据库支持的sequence对象�?/p>
元数据属性说明：

name:生成器的唯一名字�Q�可以被Id元数据��用�?

sequenceName:数据库中�Q�sequence对象的名�U�。如果不指定�Q�会使用提供商指定的默认名称�?

initialValue:id值的初始倹{�?

allocationSize:id值的增量�?

下面的代码定义了一个��用提供商默认名称的sequence生成器�?/p>

@SequenceGenerator(name="EMP_SEQ", allocationSize=25)

DiscriminatorColumn

DiscriminatorColumn定义在��用SINGLE_TABLE或JOINED�l�承�{�略的表中区别不�l�承层次的列�?/p>
元数据属性说明：

name:column的名字。默认��gؓTYPE�?

columnDefinition:生成DDL的sql片断�?

length:String�c�d��的column的长度，其他�c�d��使用默认�?0�?

下面的代码定义了一个列名�ؓDISC�Q�长度�ؓ20的String�c�d��的区别列�?/p>

@Entity @Table(name="CUST") @Inheritance(strategy=SINGLE_TABLE, discriminatorType=STRING, discriminatorValue="CUSTOMER") @DiscriminatorColumn(name="DISC", length=20) public class Customer { ... }

liaojiyong 2006-07-03 00:53 发表评论

EJB3.0之映��（转）

liaojiyong — Sun, 02 Jul 2006 16:52:00 GMT

一对一映射

双向一对一关系需要在关系�l�护端（owner side�Q�的one2one Annotition定义mappedBy属性。徏表时在关�p�被�l�护端（inverse side�Q�徏立外键列指向关系�l�护端的主键列�?/p>
假设Country �?Capital 是双向一对一的关�p�，具体元数据声明如�?

public class Country { @OneToOne(optional = true,cascade = CascadeType.ALL, mappedBy = "country") private Capital capital; } public class Capital { @OneToOne(optional = false, cascade = CascadeType.ALL) @JoinColumn(name = "COUNTRY_ID", referencedColumnName = "id") private Country country;

代码中元数据的说明：

元数据描�q?

@OneToOne(optional = true,cascade = CascadeType.ALL, mappedBy = "country")

optional声明关系是否是必��d��在的�Q�即是否允许其中一端�ؓnull�?/p>
cascade声明�U�联操作�?/p>
@JoinColumn(name = "COUNTRY_ID", referencedColumnName = "id")

name声明外键列的名字�Q�referencedColumnName声明外键指向列的列名�?br />

一对多映射

双向一对多关系�Q�一是关�pȝ��护端�Q�owner side�Q�，多是关系被维护端�Q�inverse side�Q��?��时在关系被维护端建立外键列指向关�pȝ��护端的主键列�?/p>
假设Father �?Child 是双向一对多的关�p�，具体元数据声明如�?

public class Father { @OneToMany(targetEntity = Child.class, cascade = CascadeType.ALL, mappedBy = "father") public List getChildren() { return children; } } public class Child { @ManyToOne @JoinColumn(name = "FATHER_ID", referencedColumnName = "id") public Father getFather() { return father; } }

代码中元数据的说明：

元数据描�q?

@OneToMany(targetEntity = Child.class, cascade = CascadeType.ALL, mappedBy = "father")

targetEntity = Child.class表明关系另一端的实体�c�d��

cascade声明�U�联操作�?/p>
mappedBy声明关系�l�护端的字段�Q�field�Q�名�?/p>
@ManyToOne

@JoinColumn(name = "FATHER_ID", referencedColumnName = "id")

name声明外键列的名字�Q�referencedColumnName声明外键指向列的列名�?br />

多对多映��?/h2>
多对多映��采取中间表�q�接的映��策略，建立的中间表��分别引入两边的主键作�ؓ外键�?/p>
EJB3对于中间表的元数据提供了可配�|�的方式�Q�用户可以自定义中间表的表名�Q�列名�?/p>
假设Teacher �?Student是多对多的关�p�，具体元数据声明如�?

pubic class Teacher{ @ManyToMany(targetEntity = Student.class, cascade = CascadeType.PERSIST) @JoinTable(table = @Table(name = "M2M_TEACHER_STUDENT"), joinColumns = @JoinColumn(name = "TEACHER_ID", referencedColumnName = "ID"), inverseJoinColumns = @JoinColumn(name = "STUDENT_ID", referencedColumnName = "ID")) public List getStudents() {return students;} } public class Student{ @ManyToMany(targetEntity = Teacher.class, mappedBy = "students") public List getTeachers() { return teachers; } }

代码中元数据的说明：

元数据描�q?

@ManyToMany(targetEntity = Student.class, cascade = CascadeType.PERSIST)

targetEntity = Student.class表明关系另一端的实体�c�d��。cascade声明�U�联操作�?/p>
@JoinTable(table = @Table(name = "M2M_TEACHER_STUDENT"),

joinColumns = @JoinColumn(name = "TEACHER_ID", referencedColumnName = "ID"),

inverseJoinColumns = @JoinColumn(name = "STUDENT_ID", referencedColumnName = "ID"))

JoinTable配置中间表信息，它由3个部分组�?

1) table = @Table(name = "M2M_TEACHER_STUDENT") ,声明中间表的名字

2�Q?joinColumns �Q�定义中间表与关�pȝ��护端的外键关�p�R�?/p>
3�Q?inverseJoinColumns�Q�定义中间表与inverse端的外键关系.

Inheritance strategy

EJB3规定了三�U�基本的�l�承映射�{�略�Q?/p>
.每个�c�d��层结构一张表(table per class hierarchy)

.每个子类一张表(table per subclass)

.每个具体�c�M��张表(table per concrete class)

在我们提供的Alpha版本中仅支持�W�一�U�映��策略，��x��个类层次一个表。我们将在下一个版本中提供每个具体�c�M��张表的支持，考虑到性能�Q�这两个映射�{�略也是推荐的映��策�?

每个�c�d��层结构一张表(Table per class hierarchy)
假设有这么一个��承类层次:Employee,两个子类FullTimeEmployee,PartTimeEmployee 源代码如下所�C?
@Entity @Table( name="inheritance_Employee" ) @Inheritance(strategy=InheritanceType.SINGLE_TABLE, discriminatorType=DiscriminatorType.STRING, discriminatorValue="employee") public class Employee {...} @Entity @Inheritance(discriminatorValue="fullTimeEmp") public class FullTimeEmployee extends Employee {...} @Entity @Inheritance(discriminatorValue="partTimeEmp") public class PartTimeEmployee extends Employee {...}
代码中元数据的说明：
基类中元数据描述:
@Inheritance(strategy=InheritanceType.SINGLE_TABLE,
discriminatorType=DiscriminatorType.STRING,discriminatorValue="employee")
strategy=InheritanceType.SINGLE_TABLE表示�l�承映射采用�W�一�U�映��策略�?/p>
discriminatorType=DiscriminatorType.STRING表示�l�承层次中类型识别列�c�d��为String.
discriminatorValue="employee" 表示此类对应的类型识别码为employee.

liaojiyong 2006-07-03 00:52 发表评论

EJB3 QL查询(�?

liaojiyong — Sun, 02 Jul 2006 15:35:00 GMT

EJB3 QL查询

EJB3的查询语�a�是一�U�和SQL非常�c�M��的中间性和对象化查询语�a�。它可以被编译成不同的底层数据库能接受的SQL�Q�从而屏蔽不同数据库的差异，��保用EJB3 QL查询语言�~�写的代码可在不同的数据库上�q�行。比起EJB 2.1的查询语�a��Q�EJB3可以�q�行期构造，支持多态，�q�远比EJB 2.1的查询更灉|��和功能强大。在�E�序中��用EJB3 QL可以使用大写(SELECT)或者小�?select)�Q�但不要大小�?比如:Select)混合使用�?/p>　　　

Query接口

javax.persistence.Query是EJB3查询操作的接口。进行查询，首先要通过EntityManager 获得Query对象�?/p>

public Query createQuery(String ejbqlString);

下面我们做一个最��单的查询�Q�查询所有的com.redsoft.samples.Order�c�R�?/p>

final Query query = entityManager.createQuery( "select o from Order o"); final List result = query.getResultList(); final Iterator iterator = result.iterator(); while( iterator.hasNext() ){ //　处理Order }

注意"from Order"�?Order"在EJB3查询中称为com.redsoft.samples.Order�cȝ��abstract schema Type。查询Entity在EJB3 QL中都是针对Entity的Abstract Schema Type�q�行查询�?在同一个EntityManagerFactory中，不允许同时有两个Abstract Schema Type相同的Entity�c�R��比如不允许同时有com.redsoft.samples.Order和com.redsoft.foo.Order。　　

Query�q�回一个List的集合结果，我们可以用Iterator或者List.get( int )的方法来获得每个�W�合条�g的Entity。Liberator EJB3 Persistence�q�行环境的Query查询在构造Query的时候的只是把EJB3 QL�~�译成相应的SQL�Q�但�q�不执行。只有当应用代码�W�一�ơ调用Iterator.next(),Iterator.hasNext()或者List.get( int )�Ҏ(gu��)��的时�?�~�译后的SQL才会被真正的执行�?

在Liberator EJB3 Persistence�q�行环境�q�回的结果集合中�Q��ƈ不保存所有的�l�果�Q�而只是保持一个指向JDBC ResultSet或者缓存ResultSet的一个行(row)指针。只有当用户��实需要获得Entity实例的时候，才会从ResultSet中获取数据�ƈ填充到Entity实例中返回给应用�?

如果查询�l�果�l�合中包含所有符合条件的Entity, Liberator EJB3 Persistence�q�行环境默认会自动缓存每�ơ查询的�l�果。这样下�ơ同��L��查询操作��无需讉K��数据库，而直接从�~�存中返回结果集合。但如果在下�ơ查询操作之前，有针对被�~�存的Entity�c�进行update/insert/delete操作�Q�则�~�存的结果集合会自动被清�I�，�q�样下次查询��׃��从数据库获得数据�Q?��保查询��L��获得正确的结果，避免�~�存脏数据�?/p>
有时候查询会�q�回��量的数据。Liberator EJB3�q�行环境采用了自适应的弱引用POJO��理机制�Q�可以处理�v量的数据。在我们的测试中和客��L��环境可以处千万��别的数据量。但在处理大数据量的时候，注意关闭寚w��合结果的�~�存�?/p>

// 假设�q�回的结果数量巨�? final Query query = entityManager.createQuery( "select o from Order o"); // 关闭�Ҏ(gu��)��询结果的�~�存 query.setHint( Constants.QUERY_RESULT_CACHE, "false"); final List result = query.getResultList(); final Iterator iterator = result.iterator(); // �q�里我们可以处理��量的数�? while( iterator.hasNext() ){ //　处理Order }

　　

final Query query = entityManager.createQuery( "select o from Order o where o.id = 1"); final Query query = entityManager.createQuery( "select o from Order o where o.id = 1 and o.confirm = 'true' "); final Query query = entityManager.createQuery( "select o from Order o where o.id = 1 or o.customer = 'foo' "); // address是Order�c�M��的一个对象变量属性，Address有一个streetNumber的属�? final Query query = entityManager.createQuery( "select o from Order o where o.address.streetNumber >= 123" );
注意条�g语句中查询的是Entity的属性，属性的名字需要和Entity中的属性变量名字一致�?

使用参数查询

参数查询也和SQL中的参数查询�c�M��。EJB3 QL支持两种方式的参数定义方�? 命名参数和位�|�参数。在同一个查询中只允�怋�用一�U�参数定义方式�?/p>命名参数:
final Query query = entityManager.createQuery( "select o from Order o where o.id = :myId"); // 讄��查询中的参数 query.setParameter( "myId", 2 ); // 可以使用多个参数 final Query query = entityManager.createQuery( "select o from Order o where o.id = :myId and o.customer = :customerName" ); // 讄��查询中的参数 query.setParameter( "myId", 2 ); query.setParameter( "customerName", "foo" );
注意不允许在同一个查询中使用两个相同名字的命名参数�?
位置参数�Q?
final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1"); // 讄��查询中的参数 query.setParameter( 1, 2 );// 1表示�W�一个参敎ͼ�2是参数的�? //或�? final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1").setParameter( 1, 2 ); // 可以使用多个参数 final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1 and o.customer = ?2" ); // 讄��查询中的参数 query.setParameter( 1, 2 ); query.setParameter( 2, "foo" );
如果在未来需要在不同的EJB3 �q�行环境中运行，请��用位�|�参敎ͼ�保证应用是可�U�L��的�?

排序(order by)
下面是一个简单查询的例子�Q�可以看到和SQL的��用方法很�c�M��?ASC"�?DESC"分别为升序和降序�Q�如果不昑ּ�注明�Q�EJB3 QL中默认�ؓasc升序�?
// 不注明的话，默认为asc为升�? final Query query = entityManager.createQuery( "select o from Order o order by o.id"); final Query query = entityManager.createQuery( "select o from Order o order by o.address.streetNumber desc");// desc为降�? final Query query = entityManager.createQuery( "select o from Order o order by o.id, o.address.streetNumber");

// 直接查询我们感兴��的属�?列） final Query query = entityManager.createQuery( "select o.id, o.customerName, o.address.streetNumber from Order o order by o.id"); // 集合中的不再是Order,而是一个Object[]对象数组 final List result = query.getResultList(); // �W�一个行 Object[] row = result.get( 0 ); // 数组中的�W�一个值是id int id = Integer.parseInt( row[0].toString() ); String customerName = row[1].toString(); String streetNumber = Integer.parseInt( row[2].toString() );

查询中��用构造器(Constructor)
EJB3 QL支持��查询的属性结果直接作��Z��个java class的构造器参数�Q��ƈ产生实体作�ؓ�l�果�q�回�?
// 我们把需要的三个属性作��Z��个class( OrderHolder )的构造器参数�Q��ƈ使用new函数�? Query query = entityManager.createQuery("select new com.redsoft.ejb3.dummy.OrderHolder ( o.id, o.vender, o.partNumber ) FROM Order AS o"); // 集合中的�l�果是OrderHolder List result = query.getResultList();
该java class不需要是Entity Class�?strong>NEW要求java class使用全名�?

聚合查询(Aggregation)

象大部分的SQL一�?EJB3 QL也支持查询中的聚合函数。目前EJB QL支持的聚合函数包括：

AVG
SUM
COUNT
MAX
MIN

                    
                    
    final Query query = entityManager.createQuery( "select MAX( o.id ) from Order where o.customerName='foo'");
        
    // 如果我们知道�l�果是单个，我们可以用getSingleResult()获得�l�果
    final Object result = query.getSingleResult();
        
    // �׃��Order中id的类型�ؓlong,
    final Long max = (Long)result;
        
        
    // 在一些数据库中max函数�q�回的结果的�c�d��不一定于id对应的列的类型相�W�，更安全的方式可以采用string来�{�?
    fina long max = Long.parseLong( result.toString() );

聚合函数也可以作��查询的一个属性返回�?

                    
    
    // �q�回所有的订单的生产厂商和他们的订单�h(hu��n)值总额
    final Query query 
        = entityManager.createQuery( "select o.vender, sum(o.amount) FROM Order o　group by o.vender");");

和SQL一��P��如果聚合函数不是select...from的唯一一个返回列�Q�需要��?GROUP BY"语句�?GROUP BY"应该包含select语句中除了聚合函数外的所有属性�?/p>

                    
    
    // �q�回所有的订单的生产厂商的的名字，货物��L��和每�U�货物的订单价值总额
    // 注意group by后面必须包含o.vender和o.partNumber
    final Query query 
        = entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　group by o.vender�Q�o.partNumber");

如果�q�需要加上查询条�Ӟ��需要��?HAVING"条�g语句而不�?WHERE"语句�?/p>

                    
    
    // �q�回所有的订单的生产厂商是"foo"的货物号码和每种货物的订单�h(hu��n)值总额
    // �q�里"having o.vender = 'foo'为条�?
    final Query query 
        = entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　
            group by o.vender�Q�o.partNumber having o.vender='foo'");

�?HAVING"语句里可以跟"WHERE"语句一样��用参数�?/p>

                    
    
    // �q�回所有的订单的生产厂商是"foo"的货物号码和每种货物的订单�h(hu��n)值总额
    // �q�里"having o.vender = 'foo'为条�?
    final Query query 
        = entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　
            group by o.vender�Q�o.partNumber having o.vender=?1");
    query.setParameter( 1, "foo" );
    final List result = query.getResultList();

兌��(join)

在EJB3 QL中，大部分的情况下，使用对象属性都隐含了关�?join)。例如在以下查询中：

                
    final Query query = entityManager.createQuery( "select o from Order o
         where o.address.streetNumber=2000 order by o.id");

当这个句EJB3 QL�~�译成以下的SQL时就会自动包含了兌��,EJB3 QL�~�译成SQL时关联默认取左关�?left join)�?

    
    select o.id, o.vender, o.partNumber, o.amount, addressTable.id, addressTable.streetNumber 
        from orderTable as o left join addressTable where addressTable.streetNumber = 2000

但在一些情况下�Q�我们仍焉��要对兌��做精��的控制。因此EJB3 QL仍然支持和SQL中类似的兌��语法�Q?/p>

left out join/left join
inner join
left join/inner join fetch

left join, left out join�{�义�Q�都是允许符合条件的双��表达式中的Entiies为空�?/p>

                
    // �q�回所有地址�?000的Order�U�录�Q�不���Order中是否有OrderItem                
    final Query query = entityManager.createQuery( "select o from Order o
         left join o.orderItems where o.address.streetNumber=2000 order by o.id");

�׃��EJB3 QL默认采用left join。这��L��查询和以下的EJB3 QL其实是等��L��?/p>

                
    // �q�回所有地址�?000的Order�U�录�Q�不���Order中是否有OrderItem                
    final Query query = entityManager.createQuery( "select o from Order o
          where o.address.streetNumber=2000 order by o.id");

需要显式��用left join/left outer join的情况会比较?y��u)��?/p>

inner join要求双��的表辑ּ�必须�q�回Entities�?/p>

                
    // �q�回所有地址�?000的Order�U�录�Q�Order中必���L��OrderItem                
    final Query query = entityManager.createQuery( "select o from Order o
         inner join o.orderItems where o.address.streetNumber=2000 order by o.id");

left/left out/inner join fetch提供了一�U�灵�zȝ��查询加蝲方式来提高查询的性能。在默认的查询中�Q�Entity中的集合属性默认不会被兌��Q�集合属性默认是�~�加�? lazy-load )�?/p>

                
                
``` // 默认EJB3 QL�~�译后不兌���集合属性变�?orderItems)对应的表                
    final Query query = entityManager.createQuery( "select o from Order o
         inner join o.orderItems where o.address.streetNumber=2000 order by o.id");
    final List result = query.getResultList();
    
    // �q�时获得Order实体中orderItems( 集合属性变�?)为空
    final Order order = (Order)result.get( 0 )
    
    // 当应用需要时�Q�EJB3 Runtime才会执行一条SQL语句来加载属于当前Order的OrderItems
    Collection orderItems = order.getOrderItems();

�q�样的查询性能上有不��的地斏V��ؓ了查询N个Order�Q�我们需要一条SQL语句获得所有的Order的原�?对象属性，但需要另外N条语句获得每个Order的orderItems集合属性。�ؓ了避免N+1的性能问题�Q�我们可以利用join fetch一�ơ过用一条SQL语句把Order的所有信息查询出来�?/p>

                
    // �q�回所有地址�?000的Order�U�录�Q�Order中必���L��OrderItem                
    final Query query = entityManager.createQuery( "select o from Order o
         inner join fetch o.orderItems where o.address.streetNumber=2000 order by o.id");

�׃��使用了fetch,�q�个查询只会产生一条SQL语句�Q�比原来需要N+1条SQL语句在性能上有了极大的提升�?/p>

比较Entity

在查询中使用参数查询�Ӟ��参数�c�d��除了String, 原始数据�c�d��( int, double�{?和它们的对象�c�d��( Integer, Double�{?,也可以是Entity的实例�?/p>

                
    final Query query = entityManager.createQuery( "select o from Order o where o.address = ?1 order by o.id");
    
    final Address address = new Address( 2001, "foo street", "foo city", "foo province" );
    
    // 直接把address对象作�ؓ参数�?
    query.setParameter( 1, address );

扚w��更新(Batch Update)

EJB3 QL支持扚w��更新�?/p>

                
   Query query = managerNew.createQuery("update Order as o set o.vender=:newvender,  o.partNumber='fooPart' where o.vender = 'foo'");
   query.setParameter("newvender", "barVender");
   
   // update的记录数
   int result = query.executeUpdate();

扚w��删除(Batch Remove)

EJB3 QL支持扚w��删除�?/p>

                
    Query query = managerNew.createQuery("DELETE FROM Order");
    int result = query.executeUpdate();
                
    Query query = managerNew.createQuery("DELETE FROM Order AS o WHERE o.vender='redsoft'");
    int result = query.executeUpdate();

使用操作�W�NOT

                
                
    // 查询所有vender不等�?foo"的Order                
    Query query = managerNew.createQuery("SELECT FROM Order AS o WHERE not(o.vender='foo')");
    List result = query.getResultList();
                
    // 删除所有vender不等�?foo"的Order
    Query query = managerNew.createQuery("DELETE FROM Order AS o WHERE not(o.vender='foo')");
    int result = query.executeUpdate();

使用操作�W�BETWEEN

                
                
    // 查询所有�h(hu��n)值amount在５�?0之间�?包含5,10)的Order               
    Query query = managerNew.createQuery("select o FROM Order AS o left join o.orderItems ot where o.amount BETWEEN 5 AND 10 order by o.vender desc");
    List result = query.getResultList();

使用操作�W�IN

                
    // 查询所有vender�?foo1", "foo2"或�?foo3"的Order                
    Query query = managerNew.createQuery("select o FROM Order AS o left join o.orderItems ot where o.vender in ( 'foo1', 'foo2', 'foo3' ) order by o.vender desc");
    List result = query.getResultList();

使用操作�W�LIKE

                
    // 查询所有vender以字�W�串"foo"开头的Order                
    Query query = managerNew.createQuery("select o FROM Order as o where o.vender like 'foo%' order by o.vender desc");
    List result = query.getResultList();
    
    
    // 查询所有vender以字�W�串"foo"�l�尾的Order                
    Query query = managerNew.createQuery("select o FROM Order as o where o.vender like '%foo' order by o.vender desc");
    List result = query.getResultList();
    
    
    // 可以�l�合NOT一起��用，比如查询所有vender不以以字�W�串"foo"�l�尾的Order                
    Query query = managerNew.createQuery("select o FROM Order as o where o.vender not like '%foo' order by o.vender desc");
    List result = query.getResultList();
    
    // 可以�l�合escape使用�Q�比如查询所有vender�?foo"开始的Order�q�忽�?3'字符�?
    // 如果vender�?foo1", "foo2", "foo3"�W�合�q�个条�g, 另外"3foo1", "f3oo4"也符合条件�?
    Query query = managerNew.createQuery("select o FROM Order as o where o.vender like '%foo' escape '3' order by o.vender desc");
    List result = query.getResultList();

使用操作�W�IS NULL

                
    // 查询所有没有地址的Order                
    Query query = managerNew.createQuery("select o FROM Order as o where o.address is null");
    List result = query.getResultList();
    
    // 查询所有地址非空的Order 
    Query query = managerNew.createQuery("select o FROM Order as o where o.address is not null");
    List result = query.getResultList();

使用操作�W�IS EMPTY

IS EMPTY是针寚w��合属�?Collection)的操作符。可以和NOT一起��用�?/p>

                
    // 查询orderItems集合为空的Order                
    Query query = managerNew.createQuery("select o FROM Order o where o.orderItems is empty by o.vender desc");
    List result = query.getResultList();
    
   // 查询orderItems集合非空的Order                
    Query query = managerNew.createQuery("select o FROM Order o where o.orderItems is not empty by o.vender desc");
    List result = query.getResultList();

使用操作�W�EXISTS

[NOT]EXISTS需要和子查询配合��用�?/p>

                
    Query query = manager.createQuery("select o FROM Order o where exists (select o from Order o where o.partNumber=?1) order by o.vender desc");
    query.setParameter(1, "partNumber");
    
    
    Query query = manager.createQuery("select o FROM Order o where o.vender='partNumber' and not exists (select o from Order o where o.partNumber=?1) order by o.vender desc");
    query.setParameter(1, "partNumber");

使用操作�W�ALL/SOME/ANY

                
    Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > all ( select m.salary from Manager m where m.department = emp.department)");
    List result = query.getResultList();
    
    Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > any ( select m.salary from Manager m where m.department = emp.department)");
    List result = query.getResultList();
    
    Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > some ( select m.salary from Manager m where m.department = emp.department)");
    List result = query.getResultList();

       
    // concat���参��C��的两个字�W�串�q�结成一个字�W�串,�q�里firstName�?foo", lastName�?bar"
    Query query = entityManager.createQuery("select concat( o.owner.firstName, o.owner.lastName ) FROM Order AS o left outer join o.orderItems as oi where o.owner.firstName='foo'");
    List result = query.getResultList();
    assertEquals("foobar", result.get(0).toString()); 
        
    // firstName�?fooBar",�l�果应该�q�回"oo"
    Query query = entityManager.createQuery("select o.vender,substring( o.owner.firstName, 1, 3 ), o.owner.info.age FROM Order AS o left outer join o.orderItems as oi where o.owner.firstName='charles'");
    List result = query.getResultList();
    Object[] row1 = (Object[]) result.get(0);
    assertEquals("oo", row1[1].toString());
    
    // 获得"ar"在firstName中地起始位置
    Query query = managerNew.createQuery("SELECT emp.firstName , emp.salary , locate( emp.firstName, 'ar') FROM EmployeeA as emp where emp.firstName='charles1111'");
    List result = query.getResultList();

计算函数

EJB3 QL中定义的计算函数包括�Q?/p>

ABS　�l�对�?
SQRT �q�x��?
MOD 取余�?
SIZE 取集合的数量

       
    Query query = entityManager.createQuery("select o.vender, size( o.orderItems ) FROM Order o  where o.owner.firstName = 'charles' group by o.vender order by o.vender desc");
    List result = query.getResultList();
    
    // 函数也可以用在条件中
    Query query = managerNew.createQuery("select o.vender, sum(o.amount) FROM Order AS o left join o.orderItems ot group by o.vender having size(o.orderItems) = 0 or lower( o.vender ) = 'foo' order by o.vender desc");
    List result = query.getResultList();

    
    // 取余�?
    Query query = managerNew.createQuery("select mod( o.owner.info.age, 10 ) FROM Order o where exists ( select o from Order o where o.partNumber= :name ) and o.vender='order1' and exists ( select o from Order o where o.amount= :name1 ) order by o.vender desc");

       
    Query query = managerNew.createQuery("select emp from EmployeeA as emp where ( select count(m) from Manager as m where m.department = emp.department) > 0 ");
    List result = query.getResultList();

liaojiyong 2006-07-02 23:35 发表评论

liaojiyong — Fri, 30 Jun 2006 03:49:00 GMT

摘要: 使用EJB3.O��化EJB开发 �?原著�Q�Debu Panda 我们引入EJB来构造分布式的组件。它诞生之时是�ؓ了解��x��有CORBA的问题和复杂性。经历过几次重要的版本更新和增加许多�Ҏ(gu��)��之后，EJB已经成�ؓ了J2EE的核心。在早期�Q�很多开发�h员沉�q�于EJB甚至在没有�Q何意义的情况下在他们的工�E�中使用EJB。而当他们发现所使用的工�E��ƈ没有质的变化后，谴责EJB成了一�U�趋�?.. 阅读全文

liaojiyong 2006-06-30 11:49 发表评论

使用EJB3.O��化EJB开发（转）

liaojiyong — Fri, 30 Jun 2006 03:46:00 GMT

摘要: Simplifying EJB Development with EJB3.0 使用EJB3.O��化EJB开发October 2004 Discussion 讨论 Enterp... 阅读全文

liaojiyong 2006-06-30 11:46 发表评论

liaojiyong — Fri, 30 Jun 2006 03:38:00 GMT

摘要: 2004 �q? 7 月， EJB 专家委员会公布了新的 EJB3.0 规范草本�? 2004 �q? 10 �? 7 ��P�� JBoss 发布了支�? EJB3.0 的第一个预览版�? jboss-EJB-3.0_Preview_1 ... 阅读全文

liaojiyong 2006-06-30 11:38 发表评论

JBoss4中对EJB3.0支持的Hibernate3和数据源的配�|�（转）

liaojiyong — Fri, 30 Jun 2006 03:35:00 GMT

JBoss4中对EJB3.0支持的Hibernate3和数据源的配�|?/strong>

    JBoss EJB3.0 建立�?span lang="EN-US">Hibernate 3.0之上。配�|�数据源你的实体bean需要创�?span lang="EN-US">hibernate. Properties配置文�g。在EJB 3.0部��v包下有一个默认的hibernate配置文�gejb3.deployer/META-INF/hibernate.properties�?br />

    请参考我们附带的Hibernate 3.0的文档来了解如何配置hibernate.properties文�g中的各个倹{��这里只做一些说明�?br />

hibernate.transaction.manager_lookup_class=org.hibernate.transaction.JBossTransactionManagerLookup

hibernate.hbm2ddl.auto=create-drop

hibernate.cache.provider_class=org.hibernate.cache.HashtableCacheProvider

hibernate.connection.datasource=java:/DefaultDS

hibernate.dialect=org.hibernate.dialect.HSQLDialect

    上面�?span lang="EN-US">EJB3.0应用�E�序�?span lang="EN-US">ejb3.deployer/META-INF/hibernate.properties默认的配�|�文�?br />

hibernate.connection.datasource 指向JBoss数据源的JNDI�?span lang="EN-US">

hibernate.dialect 默认�?span lang="EN-US">Hypersonic SQL�Q�但是你可以改变为其他数据库方言�?span lang="EN-US">Oracle。可以参�?span lang="EN-US">Hibernate 3.0的文档�?span lang="EN-US">

hibernate.hbm2ddl.auto=create-drop 建立部��v中的数据库图表，�q�在取消部��v的时候删除他们�?span lang="EN-US">

hibernate.transaction.manager_lookup_class 定义�?span lang="EN-US">Hibernates的事务管理。它一般不能改变�?span lang="EN-US">

hibernate.cache.provider_class 定义�?span lang="EN-US">Hibernate��要使用的缓存结构。如果你在集��中使用你也许要考虑JBoss的缓存�?br />

每个部��v�?span lang="EN-US">Hibernate.properties文�g

    你或讔R��要替换默认的hibernate.properties文�g。那么��用上面提到的变量定义一个最��配�|�来建立一个你自己�?span lang="EN-US">hibernate.properties文�g。然后将文�g攑֜�你得.ejb3 jar 目录下的META-INF/下或打入JAR包�?/span>

liaojiyong 2006-06-30 11:35 发表评论

liaojiyong — Fri, 30 Jun 2006 03:30:00 GMT

默认的会�?span lang="EN-US">bean会以路径或远�E�接口的全名�l�定�?span lang="EN-US">JNDI。你可以通过定义你自��q��@org.jboss.ejb3.LocalBinding�?span lang="EN-US">@org.jboss.ejb3.remoting.RemoteBinding来修�?span lang="EN-US">

本地接口�?span lang="EN-US">JNDI�l�定

使用org.jboss.ejb3.LocalBinding annotation来改变你本地接口�?span lang="EN-US">JNDI名字�?span lang="EN-US">

@Stateless

@LocalBinding(jndiBinding="custom/MySession")

public class MySessionBean implements MySession

{

}

�q�程接口�?span lang="EN-US">JNDI�l�定

使用org.jboss.ejb3.RemoteBindings annotation来改变你�q�程接口�?span lang="EN-US">JNDI名字�?span lang="EN-US">

@Stateless

@RemoteBindings({@RemoteBinding(jndiName="custom/remote/MySession")})

public class MySessionBean implements MySession

{

}

多通�\传输和客��L��拦截�Q?span lang="EN-US">Multiple transports and Client Interceptors

�Q?span lang="EN-US">

你可以通过JBoss Remoting架构来展��C��个会�?span lang="EN-US">bean通过多通�\传输的远�E�调用。现在仅仅一些插件支持。可以查�?span lang="EN-US">JBoss文档中怎样定义传�?span lang="EN-US">MBean。要展现一个会�?span lang="EN-US">bean通过多通�\传输你需要��用远�E�绑定注解�?span lang="EN-US">

public @interface RemoteBinding

{

   String jndiBinding() default "";

   String interceptorStack() default "SessionBeanClientInterceptors";

   String clientBindUrl();

   Class factory() default org.jboss.ejb3.remoting.RemoteProxyFactory.class;

}

JNDI �l�定指定了代理将捆绑�?span lang="EN-US">JNDI名字�?span lang="EN-US">

拦截堆栈�Q?span lang="EN-US">interceptorStack�Q�允�怽�插入数据��C��?span lang="EN-US">JBoss AOP�Q�栈�l�构�Q�。会�?span lang="EN-US">bean客户端拦截器�Q?span lang="EN-US">SessionBeanClientInterceptors�Q�栈可以在你部��v得文件夹下的ejb3-interceptors-aop.xml配置文�g中找到�?span lang="EN-US">

clientBindUrl 定义了客��L��用来�l�定服务器的JBoss�q�程URL�?span lang="EN-US">

Factory 允许你�ؓ你自�׃��理的bean插入拦截。你通常不需要接触这些设�|��?span lang="EN-US">

�q�里是一个例子：

@Stateless

@RemoteBindings({

                 @RemoteBinding(jndiName="custom/remote/MySession",

                                interceptorStack="MyInterceptorStack",

                                clientBindUrl="socket://foo.jboss.org:2222")

                })

public class MySessionBean implements MySession

{

}

liaojiyong 2006-06-30 11:30 发表评论

liaojiyong — Fri, 30 Jun 2006 03:21:00 GMT

参�?Enterprise JavaBeans 4

�q�篇文章讲述了何时��用EJB�Q�何时不用EJB�Q�以及用哪些可以替代EJB�Q?/p>

1 When to Use EJBs
Here's a list of situations where EJBs are strong; we haven't distinguished between

different types of EJBs.

Single and multisystem business transactions

The ability to maintain transactional integrity for complex business entities is one of

an EJB's key strengths. EJBs aren't alone in providing straightforward transactional

control over a single data repository. However, EJBs shine where multiple resources

(relational databases, messaging systems, etc.) are involved because they allow

transactions to spread across as many different resources as you like, so long as the

resources support distributed transactions.

Distributed functionality

Business services often live on a remote server. For example, a business enterprise will

have many different systems, ranging in degrees of inflexibility and entrenchment. One of

these systems may need to access another; EJBs, which are inherently distributed, are

often the simplest way to distribute remote services. EJB also allows you to provide

business services to remote clients more easily than some alternatives. Remote access

through components is easier to maintain than direct database access, because the

component code can shield the client from database schema changes.

Portable components (not classes)

Until recently, if you wanted to share your business services with another application

developer, you were forced to share classes or at least packages. Java did not allow for

the easy creation of enterprise components, reusable software building blocks that can be

assembled with other components to form an application. EJBs allow you to package your

business logic into a tidy, distributable unit that can be shared in a loosely coupled

fashion. The user of your component need only tweak a descriptor file for her

environment.

Applications relying on asynchronous messaging

EJBs (specifically MDBs) provide a strong technology for handling asynchronous

communication such as JMS-based messaging or web services.

Security roles

If your application's business operations can be mapped to specific business roles in

your enterprise, then EJBs may be a good choice. So much is made of the transaction

management capability of EJBs that their deployment-descriptor-based security management

features are overlooked. This capability is very powerful; if your application's users

fit into distinct roles and the rules for those roles dictate which users can write what

data, EJBs are a good choice.

2 When Not to Use EJBs
There are several situations in building a software application—even an "enterprise"

software application—in which using EJBs may actually be a barrier to meeting your

business goals. The following list represents places where you might not want to use

EJBs:

Read-mostly applications

If your application requires only (or even mostly) database reads (as opposed to writes),

then the added complexity and performance overhead of EJBs may be unwarranted. If your

application is only reading and presenting data, you should go with straight JDBC (see

below) or another persistence mechanism. That said, if your application's writes

(database update and inserts) require transactional support (especially if those

transactions go over multiple systems), then EJBs may be the way to go—at least for the

write portion of the application.

Applications requiring thread control

If your application design requires extensive use of threads, then the EJB spec actually

prevents you from using EJBs (although some EJB container vendors may provide nonportable

ways around this restriction). Container systems manage resources, transactions,

security, and other qualities of service using threads; threads you create are outside of

the container's control and can potentially cause system failures. Also, EJB containers

may distribute EJBs across multiple JVMs, preventing the synchronization of threads.

Performance

Because EJBs do so much more than plain Java classes, they are slower than plain Java

classes. The EJB container has to do a lot: maintain transactional integrity, manage bean

instances and the bean pools, enforce security roles, manage resources and resource

pools, coordinate distributed operations, synchronize shared services (if the vendor

offers clustering capabilities), and so on. The security and transactional management

operations can have a significant impact on the performance of method calls (on both

local and remote interfaces). If you require real-time or near-real-time performance

characteristics, EJB may not be your best choice.

3 Alternatives to EJB
There are several alternatives to EJB; some of them are growing in popularity and

maturity. EJBs still rank as the de facto standard for enterprise transactional needs,

but some of the alternatives, like JDO, are also available.

3.1 JDBC

3.2 Java Data Objects

3.3 Others

Castor JDO (http://www.exolab.org)

Hibernate (http://www.hibernate.org)

Prevayler (http://www.prevayler.org)

As you can see, there are several alternatives to EJB. If your application doesn't need

the complexity or some of the features of EJB, take a look around. Data persistence with

Java has been around for some time and there is a wide assortment of approaches.

liaojiyong 2006-06-30 11:21 发表评论

EJB3.0开发指南之无状态会话Bean

liaojiyong — Fri, 30 Jun 2006 00:31:00 GMT
     摘要: 在所有的 EJB3.0 规范中定义的 EJB �Q�都不必实现 Home 接口�? 　　一个会�? Bean 必须有一个业务接口，�q�个接口�׃��? Bean 来实玎ͼ�或者也可以�׃��? Bean 来��?..  阅读全文

liaojiyong 2006-06-30 08:31 发表评论

liaojiyong — Wed, 28 Jun 2006 04:23:00 GMT

EJB3 Persistence API介绍

��Z��么要引入EJB3

Entity的生命周期和状�?/a>

持久化Entity

获取Entity

更新Entity

删除Entity

分离/附合(Detach/Merge)

EJB3 QL查询

Query接口

查询部分属�?/a>

查询中��用构造器(Constructor)

聚合查询(Aggregation)

兌��(join)

left join/left out join

inner join

left/inner join fetch

比较Entity

扚w��更新(Batch Update)

扚w��删除(Batch Remove)

使用操作�W�NOT

使用操作�W�BETWEEN

使用操作�W�IN

使用操作�W�LIKE

使用操作�W�IS NULL

使用操作�W�IS EMPTY

使用操作�W�EXISTS

使用操作�W�ALL/SOME/ANY

子查�?/a>

原生SQL查询(Native SQL)

关系�Q�对象映��?
一对一映射
一对多映射
多对多映��?/a>
�l�承

关系对象映射元数�?/a>

Table

SecondaryTable

SecondaryTables

UniqueConstraint

Column

JoinColumn

JoinColumns

Id

IdClass

MapKey

OrderBy

PrimaryKeyJoinColumn

PrimaryKeyJoinColumns

Transient

Version

Lob

JoinTable

TableGenerator

SequenceGenerator

DiscriminatorColumn

DiscriminatorColumn

liaojiyong 2006-06-28 12:23 发表评论

EJB3 Demo(�?

liaojiyong — Tue, 27 Jun 2006 09:14:00 GMT

描述

EJB3 Demo

The goal of this project is to try out various features of Java EE 5.0, such as EJB 3.0, JAX-WS, JAXB, etc., and identify design/code patterns that result in:

Improved portability and re-usability of code, in particular, allow Business Logic and Data Access logic to be deployed inside and outside J2EE containers. The two main features of EJB 3.0 that should enable this are a) the new Persistence framework, and b) the promise of building Business Logic components as POJOs.

Establish design and coding patterns that result in simplicity, and promote a rapid development approach, without sacrificing good design principles.

Current status

A few experimental projects are available from the download area. These are:

tpcc-persist - contains EJB 3.0 Entity classes for Apache Derby. The entity model is a mapping of the tables defined by the well known TPC-C Benchmark, however, due to limitations in Glassfish, the schema has been modified to use surrogate primary keys instead of composite primary keys.

tpcc-persist-oracle - this packages the same entity classes for Oracle.

tpcc-session - contains EJB 3.0 Session beans that implement the Data Access layer. An important objective of this component is to preserve the Interface/Implementation separation so that it is possible to replace the EJB 3.0 persistence logic with pure JDBC logic at the implementation level without impacting clients.

tpcc-client - contains sample J2EE application client programs that show how to access EJBs from a client. Makes use of JNDI lookups and dependency injection.

tpcc-j2se - Contains sample programs that run under J2SE. These program also access the Session beans, but treat them as plain old Java objects (POJOs) and use a factory class to instantiate the beans. An EntityManager instance is injected manually into the Beans by the factory.

tpcc-web - Contains very simple web interfaces that allow experimentation with EJBs.

tpcc-ea - Builds and deploys EAR file to the J2EE server. The objective here is to explore packaging options.

How you can help

I require help to create the user interface programs that will exercise the EJBs. I would like to have a complete Web application implemented in tpcc-web project, and also an alternative J2SE GUI application implemented in tpcc-client and tpcc-j2se projects. The aim is to share the same Business Logic/Data Access Layer and Entities across these projects, thus demonstrating the benefits of the new EJB 3.0 technolgies.

I would also welcome essays and articles that describe design patterns that will lead to portability, simplicity, and reusability of code.

It would be nice if someone could take these projects and make them work under JBOSS.

A test of the EJB 3.0 technology will be to deploy the Business Logic and DAO layer as Beans using the Spring Framework.

If you would like to participate in this project, please request an appropriate role and email me describing what you would like to work on.

News

09-Mar-06 - Ported the entities to Oracle.

23-Feb-06 - Refreshed the project code.

14-Feb-06 - Uploaded an initial set of projects.

Downloads

The latest code can be obtained here. Note that this is work in progress, and therefore changing frequently.

Articles

Todo.

Links

Blog about EJB 3.0 and Java programming in general.

Glassfish - Sun's OpenSource Java EE 5.0 Application Server.

liaojiyong 2006-06-27 17:14 发表评论

欧美精品久久久久久,国模极品一区二区三区,亚洲高清在线观看

��Z��么要使用EJB�Q?�?

Web+EJB能组成真正的多层�l�构

EJB提供性能优化支持

���结

EJB 3.0开发指南之�l�合主键

EJB3.0开发指南之多对多和一对一

EJB 3.0开发指南之多表映射

EJB 3.0开发指南之使用实体Bean

EJB 3.0 开发指南之定时服务

EJB 3.0开发指南之依赖注入

EJB 3.0开发指南之消息驱动Bean

EJB3.0开发指南之有状态会话Bean(�?

EJB3介绍:Overview

EJB 3中的元数据批�?Annotation

�W�一个Entity Bean:HelloWorld

解说Entity

定义对Entity中属性变量的讉K��

主键和实体标识（Primary Key and Entity Identity)

EJB3.0之操作Entity

操作持久化Entity

配置和获得EntityManager

持久化Entity(Persist)

获取Entity

更新Entity

删除Entity

��q��/附合(Detach/Merge)

Table

SecondaryTable

SecondaryTables

UniqueConstraint

Column

JoinColumn

JoinColumns

Id

IdClass

MapKey

OrderBy

PrimaryKeyJoinColumn

PrimaryKeyJoinColumns

Transient

Version

Lob

JoinTable

TableGenerator

SequenceGenerator

DiscriminatorColumn

EJB3.0之映���（转）

一对一映射

一对多映射

Inheritance strategy

每个�c�d��层结构一张表(Table per class hierarchy)

EJB3 QL查询(�?

EJB3 QL查询

Query接口

使用参数查询

排序(order by)

查询中��用构造器(Constructor)

聚合查询(Aggregation)

兌���(join)

比较Entity

扚w��更新(Batch Update)

扚w��删除(Batch Remove)

使用操作�W�NOT

使用操作�W�BETWEEN

使用操作�W�IN

使用操作�W�LIKE

使用操作�W�IS NULL

使用操作�W�IS EMPTY

使用操作�W�EXISTS

使用操作�W�ALL/SOME/ANY

计算函数

使用EJB3.O���化EJB开发（转）

JBoss4中对EJB3.0支持的Hibernate3和数据源的配�|�（转）

EJB3.0开发指南之无状态会话Bean

EJB3 Demo(�?

描述

EJB3 Demo

Current status

How you can help

��结

EJB3.0之映��（转）

兌��(join)

使用EJB3.O��化EJB开发（转）