BlogJava-中國男人大鹏一曰同风起，扶摇直上九万里-随笔分类-EJB

为什么要使用EJB？(转)

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

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

　　首先，我们必须明确，为什么要使用J2EE？J2EE优点是什么？使用J2EE的主要原因是多层结构，传统的两层C/S结构难于维护，稳定性极差，界面代码和数据库代码混淆在一起，牵一动百，多层结构使得界面和数据库完全分离，并且诞生了中间件这样的技术，如下图：

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

　　为什么使用EJB我原先认为这不是一个讨论的话题，因为EJB是J2EE重要的组成部分，可以说没有EJB的J2EE只是一种Web系统，这样的系统非常容易丧失了多层结构的大部分优点（仔细想想那些混合多种层次功能JavaBeans和传统两层结构有什么区别？）。

　　当然，可以人为地在Javabeans之间进行层次划分，例如Hibernate算数据持久层，某些JavaBeans是业务核心层，但是因为都是普通 JavaBeans，这种划分没有一种强制性和明显标志性，这样的系统更换了主创人员或设计师，可能就会被新的程序员修改得非常混乱。

　　我们先看看一个包含EJB的J2EE系统是如何清晰地表达层次。如下图：

　　Web完全只是一个MVC模式的实现，关键业务核心是在EJB的服务层实现，这样做的优点是，Web只负责界面相关部分，因为，如果是一个智能客户端，如Swing或J2ME，在不需要修改任何业务核心的情况下能够方便地更换。同样，提供Web Services功能，也只是在 Web层修改，不会涉及EJB方面的修改，同样保证了系统的稳定性，保证了系统升级和未来的扩展性。

　　如果不使用EJB，在EJB服务层实现的业务核心将由普通JavaBeans实现，使用何种架构或设计能够保证负责MVC的JavaBeans和负责业务核心的JavaBeans清晰地分开，又如何保证在新的程序员不会破坏和打乱你精心布局的JavaBeans架构？

EJB提供性能优化支持

　　最主要的是性能问题，由于以前国内中文Java网站有些人弯曲EJB，认为EJB性能低，其实这是一种非常肤浅错误的认识，我们首先看看在一般Java环境中是如何提高性能。

　　假定一个JavaBeans为A，那么一般使用这个JavaBeans命令如下：

　　A a = new A();

　　但是，在高访问量的环境中，new A()其实是很费时消耗系统性能的，因此，能不能在软件系统启动时候就预先建立一些对象，这样，系统运行时，从这些已经生成的对象池中借用一个，这样，就无需在使用时进行New，节约了开销，提高了性能，因此，真正成熟性能解决方案都是需要对象池等支持。

　　在一个纯Web结构的系统（也就是只能运行在Tomat环境中），例如Struts + Hibernate等这样的系统，除非自己动手做，一般是没有对象池技术支持的，因此他们的性能只能算是Demo演示版本的性能，根本无法承受大容量并发访问，也无法称为一个成熟的系统，所以，我们研究成熟的开源Web系统，如Jive、OFBize，LifeRay等，他们都在Web层拥有自己的对象池和缓存池。

　　对象池和缓存机制是J2EE必须的吗？当然，是所有成熟系统必须的，Windows系统如果去掉缓存将会变得怎样？

　　自己动手开发对象池和缓存机制并不是一件简单的事情，需要对多线程以及同步锁等底层原理有深层次的把握，这其实也是一门非常深入的Java研究分支，所以，你可以抛开你的客户焦急的催促，精心研究开发自己的对象池和缓存池。

　　但是，EJB容器（如JBoss）已经提供了对象池和缓存机制，所以，没有事务机制的无状态Session Bean的性能肯定要强于普通JavaBeans。EJB容器不但在单机中提供了对象池和缓存，而且可以跨服务器实现动态负载平衡，这些都无需开发者自己开发任何软件代码，结构如下：

EJB组件能提供真正的可重用框架

　　每一个jar包代表一个EJB组件，一个系统可以由多个可重用的EJB组件构成，例如：树形结构EJB组件；自增序号EJB组件；用户资料EJB组件等，这样的EJB组件可以象积木一样搭配在大部分应用系统中，提高了系统的开发效率，保证了开发质量。

　　下图是某个新的具体系统时应用到的EJB组件图，在这个新的应用中，由于使用了以前大量可重用的EJB组件，新的开发工作基本集中在界面设计和流程安排上：

EJB提供了事务机制

　　事务机制对于一些关键事务是很重要的，例如ATM机提款，提款有多个动作：修改数据库以及数钱等，如果这其中有任何一个环节出错，那么其它已经实现的操作必须还原，否则，就会出现，提款人没有拿到钱，但是卡上已经扣款等不可思议的事情发生。

　　EJB提供的事务机制非常周全，但事务机制带来的缺点是性能的降低，因此，有些人认为EJB很重，因为在实际应用中，有的用户系统可能不需要事务机制，只是需要EJB提供的性能优化机制，这样，如果使用EJB，就象叫一个人来背东西，他除了背着我要的东西外，还背着我不要的东西。

　　除非你是一个完美主义，在一般企业应用或数据库系统应用中，EJB不会对你构成很重的包袱。

CMP独特的优点

　　开源以及一些数据库持久层技术崇拜者，一直抨击CMP，认为CMP慢无用，实际最大的问题是他们的设计和使用问题。

　　由于EJB容器（如JBoss）对CMP实现有事务机制的缓存优化，因此，CMP特别适合多个用户同时更新同一个数据源的情况，CMP这种严格的事务完整性保证多个用户同时操作一个数据记录时，能够保证性能优化和数据的完整性，如果这个数据记录是是软件系统的状态标志，它的状态会影响系统中很多的环节，那么状态更改的重要性不言而喻。

　　如果没有事务完整性支持，你的软件系统在用户访问量变大，就会变得发生各种不可能发生的逻辑错误，查看程序逻辑是正确的，那么问题出在哪里？出在数据完整性上。

　　由于每个CMP在内存中都有一个缓存，在实际应用中，如果使用CMP批量读数据库数据，几万条查询完毕，内存中充满了几万条CMP缓存，如果这时你的 EJB容器设置不当（如使用JBoss缺省配置），那么JVM的垃圾回收机制就会频繁启动，导致你的系统变慢甚至死机，这也是一些人抨击CMP慢的原因所在，其实他们使用方法不当，或者没有正确配置EJB容器CMP缓存。

　　对于这种情况，根据J2EE核心模式，推荐使用DAO+JDBC方式。

小结

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

　　不要再被TSS那些狂热的开源先生误导，他们有时间有保障可以做他们喜欢的事情，作为专业的J2EE程序员，按照J2EE标准去学习去行动，也不要认为，只要使用了J2EE其中某个技术如Jsp或JavaBeans就心安理得认为自己的系统是J2EE了。

　　当然，我并不是说纯Web系统不能实现多层结构，但是至少在很多方面没有Web+EJB结构完善和清晰，所以，EJB不是J2EE可以忽视的部分，而是主要的重要的部分，重要业务功能核心都封装在EJB中，相反Web层是一种次要的、和界面相关的层次。

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

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

EJB 3.0 学习笔记——Entity Bean（转）

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

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

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

我想先试验一下Entity Bean。

一、在JBoss中配置好Data Source
我使用的是MySQL数据库，所以首先将MySQL的JDBC驱动复制到
jboss-4.0.3SP1\server\all\lib目录，然后将jboss-4.0.3SP1\docs\examples\jca

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

下，这是我修改后的mysql-ds.xml文件：

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

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

on-sorter-class-name>

       mySQL


这样之后，JBoss下的MySQL Data Source配置完成。

二、创建数据库并编写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，导入User Library：EJB3_JBoss，以下是类代码。

//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 并进行测试

//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! ");

}
}

三、其他文件
将jboss-EJB-3.0_RC5-PFD\docs\tutorial中的找到的jndi.properties、log4j.xml

、builder.xml等复制到当前工程中，其中builder.xml需要修改。
//builder.xml

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

dir=".">

fork="yes" dir=".">

最后，在工程目录下新建目录META-INF，在目录META-INF新建persistence.xml文件

，以下是文件内容：


      java:/MySqlDS

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

四、运行测试
run as->ant build后，选择运行目标为run.entity->run。
运行结果：
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
已经成功写入。

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

EJB 3.0开发指南之组合主键

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

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

　　如:

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

　　事实上,主键可以是任意的java基本类型、或者是基本类型的包装类，如Integer、String类型、或者是带字段或属性的主键类。注意，如果这样使用主键,你需要将主键的注释中的生成规则改为NONE。就是由程序生成主键值。

　　主键类必须实现hashCode和equals方法。

　　这个例子前面举例过，就是一个存储学生信息的实体bean，在那个例子中，使用Name类作为属性，并且以Id作为主键，在这个例子中，我们将使用name作为主键，注意name的类型一个java类。和前面的例子一样，我们还是使用Client测试。

　　Name.java：主键。

　　Student.java：实体Bean类。

　　StudentDAO.java：会话Bean的业务接口

　　StudentDAOBean.java：会话Bean的实现类

　　Client.java：测试EJB的客户端类。

　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

　　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("晁","岳攀","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());
　　　}
　　*/
　}
}

　　这个客户端用来测试。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB，然后调用startDatabaseManager()方法，打开HSQL管理工具管理数据库。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

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

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

在前面的例子中，我们演示了一对多和多对一的例子，在本章将演示多对多和一对一的关系。

　　学生和老师就是多对多的关系。一个学生有多个老师，一个老师教多个学生。

　　学生和档案就是一对一的关系（不知道国外的学生有没有档案？）。

　　为了实现多对多的关系，数据库中需要关联表，用以在两个实体间建立关联。JBoss可以自动生成关联表，你也可以@AssociationTable来指定关联表的信息。

　　如:

@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 {};
}

　　关联表注释指定了关联表的名称、主表的列和从表的列。

　　为了实现一对一的关系，需要用@OneToOne来注释。

　　如:

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

public Dossier getDossier()
{
　return dossier;
}

　　这定义了一个单向的一对一的关系。如果在Dossier也定义了相关的关联，那么它就是双向的。双向的意思就是通过一个Student实体就可以查找到一个Dossier，通过一个Dossier就可以查找到一个Student。

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

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

　　这个例子主要有以下几个文件，这个例子主要实现了学生和老师、学生和档案之间的关系。Student、Teacher、Dossier都是实体Bean。Student和Dossier是一个双向的OneToOne之间的关系，Student和Teacher是ManyToMany的关系，也是双向的。和前面的例子一样，我们还是使用Client测试。

　　Student.java：实体Bean。

　　Dossier.java：实体Bean所依赖的类。

　　Teacher.java：实体Bean所依赖的类。

　　EntityTest.java：会话Bean的业务接口

　　EntityTest Bean.java：会话Bean的实现类

　　Client.java：测试EJB的客户端类。

　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

　　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("岳攀");
　　dossier1.setResume("这是晁岳攀的档案");
　　student1.setDossier(dossier1);
　　students1.add(student1);

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

　　student3.setFirst("田");
　　student3.setLast("明");

　　dossier3.setResume("这是田明的档案");
　　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的方法，并提供了查找老师的方法。

　　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("晁","岳攀","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);
　　}
　}
}

　　这个客户端用来测试。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

　　http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB，然后调用startDatabaseManager()方法，打开HSQL管理工具管理数据库。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

EJB 3.0开发指南之多表映射

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

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

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

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

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

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

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

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

　　这个例子主要有以下几个文件，这个例子主要实现了管理学生的功能。Student是一个实体Bean，这个Bean的name属性是一个类，也就是Name类，这个Name类就是一个依赖值对象。学生的性别映射到第二张表中。StudentDAOBean是一个无状态的会话Bean，用来调用实体Bean。和前面的例子一样，我们还是使用Client测试。

　　这个例子和上一个例子基本相同，只是Student.java和Client有所不同。

　　　Student.java：实体Bean。

　　　Name.java：实体Bean所依赖的类。

　　　StudentDAO.java：会话Bean的业务接口

　　　StudentDAOBean.java：会话Bean的实现类

　　　Client.java：测试EJB的客户端类。

　　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

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，它提供学生的基本情况。在类上声明上加上了第二张表的注释：

@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("晁","岳攀","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);

}

　　这个客户端增加学生的分数，并且测试显示这个学生的email。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB，

　　然后调用startDatabaseManager()方法，打开HSQL管理工具管理数据库。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

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

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

　在上面一个例子中，实体Bean的属性对应到数据表中的列，都是采用默认的设置。通过Column，你可以为属性指定数据表中的列名。
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，通过主键查找实体bean，通过查询语言来查询实体Bean。

　　下面是EntityManager接口的声明：

package javax.ejb;

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

public interface EntityManager {

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

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

　public T merge(T entity);

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

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

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

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

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

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

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

　public Query createNativeQuery(String sqlString);
　/**
　* 更新到数据库中
　* @param entity
　*/

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

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

　public boolean contains(Object entity);
}

　　@JoinColumns

　　用来指示符合主键，在后面的章节中介绍。

　　这个例子主要有以下几个文件，这个例子主要实现了管理学生分数的功能。Student是一个实体Bean，管理学生的基本信息（姓名和各课分数），其中学生的分数又是一个实体Bean。TacherBean是一个无状态的会话Bean，用来调用实体Bean。和前面的例子一样，我们还是使用Client测试。

　　·Student.java：实体Bean。

　　·Score.java：实体Bean。

　　·Teacher.java：会话Bean的业务接口

　　·TeacherBean.java：会话Bean的实现类

　　·Client.java：测试EJB的客户端类。

　　·jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　·Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

　　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;
　//学生名
　private String name;
　//学生的分数
　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，它提供学生的基本情况以及学生的得分情况，得分是另外一个实体Bean。Student实体Bean和Score实体Bean是一对多的关系，站在Score的角度看是多对一的关系。

　　实体Bean需要使用@Entity做注释，另外它指定这个实体Bean与表STUDENT对应（通过注释@Table(name = "STUDENT")），你可以在JBOSS的数据库中看到这个表。

　　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;
　}

}

　　这个实体Bean存放学生的分数。

　　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();

}

　　这个会话Bean接口提供增加分数和得到用户的方法。

　　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);
　}

}

　　这个是会话Bean的实现类。

　　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()+"");
　　}
　}
}

　　这个客户端增加学生的分数，并且测试显示这个学生的相关信息。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB，然后调用startDatabaseManager()方法，打开HSQL管理工具管理数据库。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

EJB 3.0 开发指南之依赖值对象

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

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

　　依赖值对象不支持继承，这将在EJB3.1中在讨论。

　　依赖类需要使用◎DependentObject来注释：

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

　　这个注释可以指定容器访问这个类的方法，是通过属性还是直接通过字段来访问。

　　在实体Bean的一个属性需要使用依赖值对象，那么这个属性的get方法需要使用@Dependent注释：

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

　　这个注释可以指定依赖的属性DependentAttribute：

@Target({}) @Retention(RUNTIME)

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

　　可以指定属性名称和映射的列名。这里，一个主实体Bean的属性可以映射到数据表中的多列。

　　如果你还不太明白，看下面的例子。

　　这个例子主要有以下几个文件，这个例子主要实现了管理学生的功能。Student是一个实体Bean，这个Bean的name属性是一个类，也就是Name类，这个Name类就是一个依赖值对象。StudentDAOBean是一个无状态的会话Bean，用来调用实体Bean。和前面的例子一样，我们还是使用Client测试。

　　·Student.java：实体Bean。

　　·Name.java：实体Bean所依赖的类。

　　·StudentDAO.java：会话Bean的业务接口

　　·StudentDAOBean.java：会话Bean的实现类

　　·Client.java：测试EJB的客户端类。

　　·jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　·Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

　　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，它提供学生的基本情况。学生的姓名是Name类，通过@Dependent(

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

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

来声明，并指定这个依赖类的两个属性first和last，并映射到数据表的FIRST和LAST列上。

　　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;
　}
}

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

　　1．这个类实现了java.io.Serializable接口

　　2．这个类使用@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);
}

　　这个会话Bean接口提供查找用户的方法。

　　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);
　}

}

　　这个是会话Bean的实现类。可以看到根据值对象的属性查找主实体Bean。

　　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("晁","岳攀","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());
　　}
　}
}

　　这个客户端增加学生的分数，并且测试显示这个学生的email。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

http://localhost:8080/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss%3Aservice%3DHypersonic%2Cdatabase%3DlocalDB，然后调用startDatabaseManager()方法，打开HSQL管理工具管理数据库。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

EJB 3.0 开发指南之定时服务

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

在EJB2.1的规范中需要实现ejbTimeout方法，当然还有ejbPassivate、ejbRemove等方法。在EJB3.0中，只有你想用它们的时候，你才必须创建它们，否则不必实现。

　　这个例子主要有5个文件，这个例子的Bean是一个无状态会话Bean：

　　NewsTimer.java：业务接口。

　　NewsTimer.java：业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean）。

　　Client.java：测试EJB的客户端类。

　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

NewsTimer.java

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

public interface NewsTimer
{
　public void fiveNews();
}

　　这个接口定义了fiveNews方法，如果这个方法被调用，5分钟后将往控制台上输出一条新闻。

　　你不必配置它的JNDI名称，也不必写它的配置文件。在JBOSS实现的EJB3.0中，你不必写任何的EJB部署文件和jboss部署文件。JBOSS默认使用接口的全称作为它的JNDI名。在上面的例子中，它的全称可以通过NewsTimerclass.forName()得到。

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), "子虚乌有电视台5分钟新闻栏目:现在过5分钟，又到即时新闻节目的时间了。");
　}

　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();
　}
}

　　这个类用来测试我们发布的计数器EJB。首先通过

ctx = new InitialContext();

　　得到上下文，然后通过lookup查找NewsTimer，然后启动计时。。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run –c all,启动JBOSS。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

EJB 3.0开发指南之依赖注入

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

依赖注入（Dependency Injection），又称作控制反转(IOC)，本来是一种设计模式，现在被吵得热火朝天，有点过了。比较有名项目如String,picoContainer等。

　　在EJB3.0中，可以通过在字段和设置方法上加上注释注入依赖，我想在很快会有新的项目，或者在原来的项目的基础上，一些IOC容器会采用注释的方式注入依赖，JDK5.0加入的注释的确是一个很强大的功能，相对而言，在.net中的属性却没有发挥那么大的价值。这就是开源的威力，成千上万的在开源java程序员不断涌现出新的想法新的功能。

　　看下面的例子：我们知道,JBOSS中已经默认配置了一个数据源，它的JNDI名称是"java:/DefaultDS"。下面这个例子声明了一个数据源，通过注释，就可以将JBOSS的这个默认的数据源赋值给它。

@Resource(jndiName="java:/DefaultDS")
public DataSource customerDB;
Resource注释的声明
@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组件来进行身份验证，sharebale指定是否共享,jndiName用来指定JDNI中的名称。resourceType()用来指定资源的类型。

　　如果name和resourceType都指向被注释的程序成员，AuthenticationType和resourceType都是缺省的，则可以使用Inject注释：

@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注释可以注入多个资源。

　　在Eclipse中导入本文提供的例子DI。

　　这个例子从数据库中读取JMS_USER表，并显示表中的内容。这个例子使用依赖注入的方式得到JBOSS默认的数据源。

　　这个例子主要有5个文件：

　　　JmsUsers.java：业务接口。

　　　JmsUsersBean.java：业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean）。

　　　Client.java：测试EJB的客户端类。

　　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

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();
}

　　这个接口很简单，定义了一个得到全部用户的方法，JBOSS默认使用接口的全称作为它的JNDI名。在上面的例子中，它的全称可以通过JmsUsers.class。getName（）得到。

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;
　}
}

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

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();
　　}
　}
}

　　这个类用来测试我们发布的EJB组件。显示从JMS_USERS表中读取的数据。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

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

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

消息驱动Bean的业务接口已经被定义，对于使用JMS来说那就是MessageListener接口，这个接口定义了OnMessage方法。

　　实现类必须使用MessageDriven注释。可以实现也可以不实现setMessageDrivenContext和ejbRemove方法。

　　在JBOSS中，通过ConnectionConfig指定消息的队列的JNDI名称。

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

　　在Eclipse中导入本文提供的例子Messager。

　　这个例子从客户端发送一个TextMessage，这个Bean组件接收到这个消息后，将把这个消息输出到控制台上。

　　这个例子主要有5个文件：

　　　Messager.java：业务组件。
　　
　　　Client.java：测试EJB的客户端类。
　
　　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　　queue-example-service.xml：消息服务，用来测试消息。

　　下面针对每个文件的内容做一个介绍。

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();
　　}
　}
}

　　这个消息Bean很简单，接收到消息后不做什么处理，就是将消息内容输出到控制台上，

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("消息已经发出");
　}
}

　　这个客户端将发送一个文本消息到队列中。

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

　　配置这个程序所需的消息服务。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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

EJB3.0开发指南之有状态会话Bean(转)

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

　和无状态会话Bean一样，一个有状态会话Bean必须有一个业务接口，这个接口由会话Bean来实现，或者也可以由会话Bean来产生。这样，你可以只写一个文件，就可以生成业务逻辑实现类、远程接口、本地接口等。

　　在目前jboss的实现中，必须要有一个独立的业务接口。

　　这个接口不必实现EJBObject或者EJBLocalObject。

　　一个有状态会话Bean 必须使用Statelfull注释，以表明它是一个有状态的会话Bean。EJB容器将根据这个注释来判定它的类型。或者实现javax.ejb.SessionBean接口。

　　一个有状态的会话Bean可以实现setSessionContext方法，也可以不实现。

　　在EJB2.0中调用EJBObject.remove方法以达到从容器中删除有状态会话Bean的功能。在EJB3.0中只需在一些方法加上Remove注释。一旦这些被标记的方法被调用后，此EJB将从容器中删除。

　　一个有状态的会话Bean可以通过依赖注入获取容器的资源和环境属性。

　　在Eclipse中导入本文提供的例子Stateful。

　　这个例子和无状态会话Bean的例子类似，下面只列出了不同的代码。

　　这个例子主要有5个文件：

　　　Counter.java：业务接口。

　　　CounterBean.java：业务实现类。将来我们开发的EJB也都是这样命名（在接口名上加上Bean）。

　　　Client.java：测试EJB的客户端类。

　　　jndi.properties：jndi属性文件，提供访问jdni的基本配置属性。

　　　Build.xml：ant 配置文件，用以编译、发布、测试、清除EJB。

　　下面针对每个文件的内容做一个介绍。

Counter.java
……
import javax.ejb.Remove;
……
@Remote

public interface Counter
{
　……
　@Remove
　public void clean();
}

　　这个接口很简单，和无状态会话Bean基本相同，但新增加了一个Clean方法，并为此方法加上Remove注释。一旦此方法被执行完毕，此Bean将被从容器中删除。

　　JBOSS默认使用接口的全称作为它的JNDI名。在上面的例子中，它的全称就是：com.kuaff.ejb3.stateful.Counter，你也可以通过Counter.class得到。

CounterBean.java
……
import javax.ejb.Stateful;
……
@Stateful

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

　@Remove

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

　　这个是计数器的实现类。注意这个类使用Stateful做了注释，这是必须的。同时，这个例子也演示了如何使用事务。事务的详细用法将在后面的章节中介绍。

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,将出错
　　　try
　　　{
　　　　System.out.println("当前的number:" + counter2.getNumber());
　　　}
　　　catch(EJBException ex)
　　　{
　　　　if (ex.getCausedByException() instanceof NoSuchObjectException)
　　　　{
　　　　　System.out.println("我都被删除啦，还找我！");
　　　　}
　　　　else
　　　　{
　　　　　throw ex;
　　　　}
　　　}
　　}
　　catch (NamingException e)
　　{
　　　e.printStackTrace();
　　}
　}
}

　　这个类用来测试我们发布的计数器EJB。首先通过

　　ctx = new InitialContext();得到上下文，然后通过lookup查找计数器，然后给计数器加10，显示当前的计数器信息。最后调用Clean方法，一旦这个方法执行完毕，此EJB将从容器中删除，在使用这个EJB将会出现异常。

　　请运行{$JBOSS_HOME}/bin目录下的run.bat: run ?call,启动JBOSS。

　　在Eclipse的Ant视图中执行ejbjar target。或者在命令行下，进入到此工程目录下，执行ant ejbjar,将编译打包发布此EJB。

　　在Eclipse的Ant视图中执行run target。或者在命令行下，进入到此工程目录下，执行ant run,测试这个EJB。

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