BlogJava-semovy-文章分类-EJB

EJB学习日记(20)

semovy — Fri, 12 Oct 2007 03:06:00 GMT

非实体的基类映射

最近我们都说了很多继承方面的映射策略，可是有时候我们却需要继承一个非实体的类，这个类存在于我们的工程项目中，但是我们又不希望它成为一个实体类，这个时候怎么办呢？这个时候我们可以用@javax.persistence.MappedSuperclass来注释它，我们现在就修改一下我们前几天的例子，把Person类定义成一个不持久化的类。代码如下：

@MappedSuperclass
public class Person {
   @Id @GeneratedValue
   public int getId( ) { return id; }
   public void setId(int id) { this.id = is; }

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

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

@Entity
@Table(name="CUSTOMER")
@Inheritance(strategy=InheritanceType.JOINED)
@AttributeOverride(name="lastname", column=@Column(name="SURNAME"))
public class Customer extends Person {

}

@Entity
@Table(name="EMPLOYEE")
@PrimaryKeyJoinColumn(name="EMP_PK")
public class Employee extends Customer {

}

因为Person已经不是一个实体类了，所以在数据库里面将没有它所对应的表，所有的子类都继承了定义在它里面的属性，当然，如果你想在子类里面重新定义在父类里面定义过的属性的时候，你可以用@javax.persistence.AttributeOverride来声明，当我们的代码运行以后，将会在数据库里面建立如下的结构：

create table CUSTOMER (
   id integer primary key not null,
   firstName
varchar(255),
   SURNAME
varchar(255),
   street varchar(255),
   city varchar(255),
   state varchar(255),
   zip varchar(255),
);

create table EMPLOYEE (
   EMP_PK integer primary key not null,
   employeeId integer
);

就像你看到的，Customer类继承了Person里面的id,firstName ,lastName这些属性，因为用了@AttributeOverride来指定重写的属性，所以在数据库里面lastName对应的列就变成了SURNAME.像这种映射方法在你不想强制你的超类持久化的时候特别有用。

@MappedSuperclass不仅可以注释在基类上面，你也可以注释在两个层次的实体类中间，当然，你也可以不加任何注释，不过，当你什么注释都不加的时候，持久化管理器就会完全忽略你的这个类了。

个人还是觉得要映射的时候，写清楚更好一些，不要用太多的默认了，因为默认用多了都不知道是怎么回事了，还有，当一些事情不太确定的时候，不防去试一下，反应试一下也无所谓，自己亲自去试了才能印象更深，希望大家在学EJB的时候，多多动手去写写。我也得努力了：）

semovy 2007-10-12 11:06 发表评论

EJB学习日记(19)

semovy — Fri, 12 Oct 2007 02:49:00 GMT

继承映射策略之----每个子类一张表

在每个子类一张表的映射策略中，每一个子类都有一张属于自己的表，但是这张表只包括了定义在这个子类上面的属性而已，定义在它的父类的属性它的表里面是没有的，所以这样的方式映射的话，就不会浪费一点资源了，每一张表，每一列都是不可少的，也不会出现冗余。这种格式是有点像TABLE_PER_CLASS的策略，只不过这种方案是规范的，没有像TABLE_PER_CLASS一样重复定义列，在这里我们叫它JOINED策略。

按我们的例子，这种策略映射出来的话，数据库的结构将如下所示：

create table Person (
   id integer primary key not null,
   firstName varchar(255),
   lastName varchar(255),
);

create table Customer (
   id integer primary key not null,
   street varchar(255),
   city varchar(255),
   state varchar(255),
   zip varchar(255),
);

create table Employee (
   EMP_PK integer primary key not null,
   employeeId integer
);

当持久化管理器加载一个类或者查询一个子类的时候，它必须要对数据库做连接动作，所以我们必须要保存这几张表有一个能够彼此连接起来的列。在我们的例子里面，EMPLOYEE, CUSTOMER, 和 PERSON表共享同样的主键值，这种策略的注释也是挺简单的：

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class Person {

}

@Entity
public class Customer extends Person {

}

@Entity
@PrimaryKeyJoinColumn
(name="EMP_PK")
public class Employee extends Customer {

}

在持久化的时候，持久化管理器需要知道每一张表用哪一列来进行连接，所以当我们要指定某一列的时候，就可以用如下注释：

@javax.persistence.PrimaryKeyJoinColumn，它的声明如下：

package javax.persistence;

@Target({TYPE, METHOD, FIELD})
public @interface PrimaryKeyJoinColumn
   String name( ) default "";
   String referencedColumnName( ) default "";
   String columnDefinition( ) default "";
}

name()方法提出你此表中需要用来连接的列的名字，它默认是与父类的主键进行连接，当我们不想与父类的主键进行连接时，我们可以用referencedColumnName( )这个方法来指定你要连接父类的哪个具体的列，它可以被定义为父类的任意列，但是默认是连接父类的主键列，如果从父类到子类的主键名都是一样的，那么这个属性就没必要再设了，因为Customer和Person的主键是一样的，所以在Customer里面不需要定义任何额外的属性，一切默认就可以了，但是由于Employee里面的主键名和其它的不一样，所以它必须显式地声明它的主键是哪一个。如果有的类有复合主键，那么可以用这个注释：
@javax.persistence.PrimaryKeyJoinColumns

package javax.persistence;

@Target({TYPE, METHOD, FIELD})
public @interface PrimaryKeyJoinColumns {
@PrimaryKeyJoinColumn[] value( );
}

它包括了多个@PrimaryKeyJoinColumn的注释。

注意：有些持久化实现这种策略会需要一个辨别器列，虽然大部份是不需要的，所以最好是在使用前查看一下你的持久化提供商的实现说明。

优点：
这种策略虽然没有SINGLE_TABLE策略的速度快，但是你可以定义任何的非空约束在任何的表里面，并且这种模式是规范化的。
缺点：
唯一的缺点就是没有SINGLE_TABLE 策略的性能好。

到现在我们三种处理继承映射的策略都说完了，在不同的场合和环境下选择不同的映射策略是最明智的选择，没有一种策略可以胜任所有场合，否则的话，出一种就可以了，干嘛还出三种呢。希望大家在实际工作中选出适合自己的映射策略，更好的提高工作效率。

semovy 2007-10-12 10:49 发表评论

EJB学习日记(17)

semovy — Fri, 12 Oct 2007 02:48:00 GMT

单个实体BEAN的映射到数据库的方式很简单，但是如果我们的实体BEAN之间存在着继承关系呢？在数据库里面将如何表现这种继承关系？
JAVA持久化规范里面提供了三种方式去处理继承实体的映射方式：
一，所有继承层次共单独一张表
二，每个具体的类一个单独的表
三，每个子类一张表

为了更好的举例说明，我们构造出如下的继承层次，以做为例子使用。

我们今天先来看看第一种方式，那就是所有的继承层次共单独一张表。

一，所有继承层次共单独一张表

在这种模式中，一张数据库的表里面将放入所有的继承层次的类的属性，在我们的例子中，我们的Person,Customer,Empolyee的实体都将映射在同一张表里面，表的结构如下所示：

create table PERSON_HIERARCHY
(
   id integer primary key not null,
   firstName varchar(255),
   lastName varchar(255),
   street varchar(255),
   city varchar(255),
   state varchar(255),
   zip varchar(255),
   employeeId integer,
   DISCRIMINATOR varchar(31) not null
);

正是因为我们把所有继承层次的实体都放在同一张表里面，所以我们需要一个来标志具体类型的列，它指示当前记录是属于哪个类的，这样EntityManager好还原成相应的实体BEAN而不致于出错。我们还是先看看代码是如何告诉EntityManager它的继承实现方式的。

@Entity
@Table(name="PERSON_HIERARCHY")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="DISCRIMINATOR",
                     discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("PERSON")
public class Person {
   private int id;
   private String firstName;
   private String lastName;

   @Id @GeneratedValue
   public int getId( ) { return id; }
   public void setId(int id) { this.id = id; }

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

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

@javax.persistence.Inheritance注释就是用来声明继承的时候它的持久化策略的，它的声明如下：

package javax.persistence;

@Target(TYPE) @Retention(RUNTIME)
public @interface Inheritance {
InheritanceType strategy( ) default SINGLE_TABLE;

}

public enum InheritanceType {
SINGLE_TABLE, JOINED, TABLE_PER_CLASS
}

在这里，strategy()方法定义了我们所使用的继承映射模式，我们在这里用的是单独一张表放所有的继承层次实体，所以我们使用了枚举InheritanceType.SINGLE_TABLE,有一点我们需要注意的是，@Inheritance这个注释仅仅只在继承层次的根类上是必须要有的，一般它的子类都没有必要写这个注释，除非你想改变继承映射的实现方式。

package javax.persistence;

@Target(TYPE) @Retention(RUNTIME)
public @interface DiscriminatorColumn
   String name( ) default "DTYPE";
   DiscriminatorType discriminatorType( ) default STRING;
   String columnDefinition( ) default "";
   int length( ) default 10;
}

因为我们使用一张表来保存所有继承层次的类，所以我们需要一个某种方式好让持久化实现者知道如何去分辨我们真正想要保存的对象是属于哪个继承层次的，我们靠从一个辨别器的列里面去获得这一点。@javax.persistence.DiscriminatorColumn这个流释就是指示我们哪个类将会存储辨别器，看着注释我们可以知道，这个注释并不是必要的，因为它每项都有默认值，对于辨别器的类型，默认是String类型，我们除了String类型之外，还可以用如下几个类型：char,Integer。

package javax.persistence;

@Target(TYPE) @Retention(RUNTIME)
public @interface DiscriminatorValue {
String value( )
}

这个注释是指示我们辨别器的值是多少，这个只是我们提示辨别器的类型是String的时候，还需要我们去写，如果类型是int或者char的时候，是不需要我们去提定它们的辨别器的值的。所以最好还是使用char或者int类型，以使我们从这些细节方面解放出来。

在我们建立了这种映射策略之后，子类的定义就显得简单多了：

@Entity
@DiscriminatorValue
("CUST")
public class Customer extends Person {
   private String street;
   private String city;
   private String state;
   private String zip;
   public String getStreet( ) { return street; }
   public void setStreet(String street) { this.street = street; }

}

我们也可以都用默认的值，什么额外的注释都不要加

@Entity
public class Employee extends Customer {
   private int employeeId;

   public int getEmployeeId( ) { return employeeId; }
   public void setEmployeeId(int id) { employeeId = id; }
}

在这个例子里面，Customer实体的辨别器列的值设为CUST，这是我们人为设置的。当然我们如果不设置的话，就像Employee，那么它的辨别器列的值就会被设为Employee, 因为它的类的名字就是Employee。

优点：
SINGLE_TABLE的映射策略是最简单的实现并且性能来说，也是比其它两个要高。因为它只有一张表需要去处理。持久化引擎不需要去做任何复杂的连接组合或者子查询等等，因为所有的的数据都存在一张表里面
缺点：
这种策略最大的一个缺点就是所有的有关子类的属性的映射列都必须是nullable，因为你不可能让一个类拥有所有的属性，毕竟这些属性是所有的类加起来的，所以你不能为你的类加上NOT NULL的约束。还有，因为所有子类的属性列对于某些实体类来说都是没有用的，所以SINGLE_TABLE 策略也是不符合规范的。

semovy 2007-10-12 10:48 发表评论

EJB学习日记(18)

semovy — Fri, 12 Oct 2007 02:48:00 GMT

继承映射策略之----每个具体类一张表

昨天我们看了继承关系中的实现，昨天是用一张表保存所有级别的类，今天我们来了解一下第二种实现方法，每一个类一个单独的表的实现，在数据库我们的例子表现如下：

create table Person (
   id integer primary key not null,
   firstName varchar(255),
   lastName varchar(255),
);

create table Customer (
   id integer primary key not null,
   firstName varchar(255),
   lastName varchar(255),
   street varchar(255),
   city varchar(255),
   state varchar(255),
   zip varchar(255),
);

create table Employee (
   id integer primary key not null,
   firstName varchar(255),
   lastName varchar(255),
   street varchar(255),
   city varchar(255),
   state varchar(255),
   zip varchar(255),
   employeeId integer,
);

此种方式和SINGLE_TABLE的最大的不同就是这些表里面没有了辨别器这一列了，我们不再需要为每一个特定的类设定一个标志以识别它是哪个具体的类了。在这种方式的实现里，每一张表都保存了该类的所有的属性，当然也包括它从父类中继承过来的属性。我们看看代码吧：

@Entity
@Inheritance(strategy=InheritanceType
.TABLE_PER_CLASS)

public class Person {

}

@Entity
public class Customer extends Person {

}

@Entity
public class Employee extends Customer {

}

从以上代码可以看出，唯一需要的元数据注释只有InheritanceType，并且这个注释仅仅是用在基类Person上面而已，在他的子类中，根本看不出来有什么不一样，它们就像一个很普通的实体BEAN一样。

优点：
相比于SINGLE_TABLE的映射策略来说，此策略的优点是你可以在每一个子类上定义一些属性的约束，比方说某些属性不能为null等等，这些都是可以定义的，但是你在SINGLE_TABLE里面却是不能定义的，它还有一个优点就是，它对于处理那些遗留的数据库来说更加的容易一些，因为它更灵活一些。
缺点：
此策略依然是不规范的，没有做到物尽其用，因为它为每一个子类都重复定义了很多列，这势必给数据库的资源造成了浪费，当需要进行多态加载的时候，就会进行多次查询，这样也会降低数据库的查询效率，这样比较起来就没有SINGLE_TABLE 策略速度快，但是它在别的方面性能会好一些，在开发你的实体BEAN的时候，最好不要用这种策略，除非你不得不这样做，否则还是用第三种策略来得更好一些，那第三种策略是怎样实现的呢，我们下次再讲。

semovy 2007-10-12 10:48 发表评论

EJB学习日记(16)

semovy — Fri, 12 Oct 2007 02:46:00 GMT

实体之间的级联关系

我们在以前的七种关系映射中经常会在注释中看到如下方法：cascade()，它表示级联，也就是有关联的一些实体，当我们对其中的一些进行操作的时候，与它相关联的实体应该怎么办。这样时候，就需要我们定义cascade的属性了，cascade一共有五种属性，我们可以用其中的一种，也可以用其中的多种混合，其中可用的属性如下：

public enum CascadeType
{
ALL, PERSIST,
MERGE, REMOVE,
REFRESH
}

属性中ALL表示所有的级联，如果选了它就表示所有的级联了，也就不必选其它的了。下面我们一个一个来讲讲它们的用处吧：

1，PERSIST
PERSIST的意思就是持久的意思，它表示当我们对其中一个实体进行持久化操作的时候，与它相关联的也同样持久化进数据库，也就是执行insert动作。这样在我们保存的时候，只需要保存一个实体就可以了，与它相关联的实体也会被同时保存。

Customer cust = new Customer( );
Address address = new Address( );
cust.setAddress(address);

entityManager.persist(cust);

在上面的代码中，我们只需要持久化cust就可以了，与cust相关联的Address会自动被保存进数据库。如果我们没有指定PERSIST关联，那么我们就需要再调用entityManager.persist(address)来保存Address，这样就比较麻烦了。

2，MERGE
MERGE就是合并的意思，也就是把当前的实体BEAN的内容合并到数据库里面去，如果当前实体BEAN在数据库里面没有相应的记录，则它会自动插入新的记录，在这一点上，它和PERSIST比较相似。

cust.setName("William");
cust.getAddress( ).setCity("Boston");

entityManager.merge(cust);

在以上代码中，当我们把cust的名字改了，并且把地址里面的城市名也改了以后，我们合并到数据库的时候，Address表中的数据也一样会跟着更新，那如果我们新加一个地址进去呢？会怎么样呢？结果还是一样的，如果EntityManager发现没有这条数据时，它为了把主体合并到数据库里面去，它就会插入一个新的实体到数据库中。在我们在一对多的时候，可以看到这一点：

Phone phone = new Phone( );
phone.setNumber("617-666-6666");

cust.getPhoneNumbers( ).add(phone);
Customer newCust=entityManager.merge(cust);

在这里加了一个新的号码，然后我们合并cust，结果新的phone也被插入数据库了。在这里我们要注意的一点是，在这里只有返回值newCust才是在当前持久化上下文相关联的BEAN，而做为参数传进去的cust并不是，它可以只是一个简单的脱离了EntityManager管理的类。

3，DELETE
DELETE顾名思义就是删除的意思，当我们删除一个实体的时候，我们标志了DELETE关联的实体都会被相应的删除。

Customer cust = entityManager.find(Customer.class, 1);
entityManager.remove(cust);

当我们删除一个cust的时候，它相关联的phone，address也会一并被删除。

4，REFRESH
REFRESH就是更新的意思，它有点类似于MERGE，但是它是和MERGE相反的，我们MERGE的时候，会把当前实体的值合并到数据库中，而当我们REFRESH的时候，却是把据库的最新值更新到我们的实体BEAN中。

Customer cust ;
entityManager.refresh(cust); // address would be refreshed too

在上面，如果address在数据库中被别的程序更改了，那么当这句话调用结束之后，cust里面的address也跟着更新了，在这里，cust和address的数据不会被写入数据库，相反的，数据库的最新值将被写入到它们里面。当我们不需要把数据写入数据库，而只需要从数据库里面取最新的时候，这个方法是很有用的。比如数据库某些列是数据库触发某个事件自动更新的，而不需要我们自己去更新，就可以用这个，这个时候，最好不是在这一列上加如下注释以确保此列数据不会被我们人为地更改：
@Column (insertable=false, updatable=false...

5，ALL
ALL就是全部的意思，它表示以上四种关联它都拥有。

其实并不是所有的场合都适合用关联，因为有些时候，一些数据的更新并不影响别的数据，这个时候就不需要关联了，比如，我们不希望多对多的时候，如果人改国籍不应该把原来的国家的实体删掉吧。所以在我们使用关联的时候，一定要想清楚，是不是实体之间有相辅相成的关系或者缺一不可的关系。其实使用关联只是让我们偷偷懒而已，因为它可以让我们少写一些相关的代码，呵呵：）

semovy 2007-10-12 10:46 发表评论

EJB学习日记(14)

semovy — Fri, 12 Oct 2007 02:45:00 GMT

实体BEAN的七种关系之---------多对多单向
Many-to-Many Unidirectional Relationship

多对多的单向关系,一般来说只是为了节省数据库的空间而已,因为它只需要查询关系的一端就可以了,并且它和一对多的不同之处就在于,一对多可以用被控端维护一个对主控端的外键就可以搞定,而它不行,必须要有一张中间的表来进行关系的映射,在某种程度上,它也是挺像一对多的关系的.这种关系在现实中可以用如下关系来说明它:

人和项目的关系,一个人可以参加很多个项目,一个项目也可以让很多人参加,这就是多对多的关系,但是我们在这里可以限定一下,也就是可以知道一个人他参加了哪几个项目,但是我们不需要知道一个项目有多少人参加(如果我们需要知道的话,那就是多对多的双向关系了).

代码如下:

/*
* Person.java
*
* Created on 2007-9-15, 0:11:58
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

/**
*
* @author Admin
*/
@Entity
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    private Long id;
    private String name;
    private String sex;
    private int age;
    private Address address;
    private List<Phone> phones;
    private IDCard idCard;
    private Country country;
    private List<Car> cars;
    private List<Flight> flights;
    private List<Project> projects;

    @ManyToMany
    public List<Project> getProjects() {
        return projects;
    }

    public void setProjects(List<Project> projects) {
        this.projects = projects;
    }

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "PersonANDFlight", joinColumns = {@JoinColumn(name = "personID")}, inverseJoinColumns = {@JoinColumn(name = "flightID")})
    public List<Flight> getFlights() {
        return flights;
    }

    public void setFlights(List<Flight> flights) {
        this.flights = flights;
    }

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "person")
    public List<Car> getCars() {
        return cars;
    }

    public void setCars(List<Car> cars) {
        this.cars = cars;
    }

    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "countryID")
    public Country getCountry() {
        return country;
    }

    public void setCountry(Country country) {
        this.country = country;
    }

    @OneToOne(cascade = CascadeType.ALL)
    public IDCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IDCard idCard) {
        this.idCard = idCard;
    }

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "personID")
    public List<Phone> getPhones() {
        return phones;
    }

    public void setPhones(List<Phone> phones) {
        this.phones = phones;
    }

    @OneToOne(cascade = {CascadeType.ALL})
    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }
}

Project代码如下

/*
* Project.java
*
* Created on 2007-9-27, 9:47:01
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;

/**
*
* @author hadeslee
*/
@Entity
public class Project implements Serializable {

    private static final long serialVersionUID = 1L;
    private Long id;
    private String name;
    private String description;
    private Date fromDate;
    private Date toDate;

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Temporal(javax.persistence.TemporalType.DATE)
    public Date getFromDate() {
        return fromDate;
    }

    public void setFromDate(Date from) {
        this.fromDate = from;
    }

    public String getName() {
        return name;
    }

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

    @Temporal(javax.persistence.TemporalType.DATE)
    public Date getToDate() {
        return toDate;
    }

    public void setToDate(Date to) {
        this.toDate = to;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }
}

从代码中我们可以看出,我们只在关系的主控端 Person里面加上了@ManyToMany的注释,而在Project里面却没有任何其它的注释,但是由于我们是多对多的关系,不是一对多的关系,是不能由被维护端的一个外键指向我们自己的,因为它有可能要指向很多个人,所以我们只能用一张中间关系表的方式来实现这种关系.

七种关系,到现在已经全部讲完了.其实我们可以在脑海里面过一遍.这七种关系的特点和它适用的地方,在实际的工作中,需要的是活学活用.希望大家都能用好这七种关系.:)

semovy 2007-10-12 10:45 发表评论

EJB学习日记(15)

semovy — Fri, 12 Oct 2007 02:45:00 GMT

EJB中的集合映射

我们在前面的一对多以及多对多的情况可以看到，我们会需要对集合进行映射，对于基于List的映射我们在前面已经看过了。但是如果我们想对Map进映射呢，那该怎么办？

其实JPA已经帮我们设计好了。那就是利用@MapKey来进行注释。

我们还是先要看看MapKey的代码吧：

package javax.persistence;

@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface MapKey
{
String name( ) default "";
}

应用如下：

@Entity
public class Customer implements java.io.Serializable {

    private Map<String, Phone> phoneNumbers = new HashMap<String, Phone>( );

    @OneToMany(cascade={CascadeType.ALL})
    @JoinColumn(name="CUSTOMER_ID")
@MapKey(name="number")

    public Map<String, Phone> getPhoneNumbers( ) {
       return phoneNumbers;
    }
    public void setPhoneNumbers(Map<String, Phone> phones)
{
        this.phoneNumbers = phones;
    }
}

在此我们可以看出，@MapKey它只有一个方法，那就是指定名字，并且指定的名字必须是它所在的实体的成员，否则的话就识别不了了，如果我们留空的话，那默认的key就是这个实体类的主键。用它的好处就是，我们有时候对于这个实体来说，仅仅需要知道的是它的某一部份，并且我们希望利用这一部分来进行对实体的操作以及辨别。这样用Map就比用List方便一些了。

在此我们只是在以前一对多的基础上改了一点点而已，以前一对多的时候，没有@MapKey的注释，那么它返回的就是一个List，现在我们加了@MapKey的注释，这样EntityManager来进行操作的时候，就会自动把我们的实体列表根据我们所指定的Key生成一个Map了。在某些情况下用Map确实比用List要方便许多。

semovy 2007-10-12 10:45 发表评论

EJB学习日记(13)

semovy — Thu, 27 Sep 2007 06:26:00 GMT

实体BEAN的七种关系之---------多对多双向
Many-to-Many Bidirectional Relationship

一般来说,多对多的双向发生在双方都持有对方的很多引用,A可能持有很多个B,B也可能持有很多个A,并且A和B之间还要求能够互相查询.在现实中,我们可以用如下的例子来说明这种关系:

人和航班,一个人可以订很多次航班,可以是订了今天的,也可以订明天的,因为他工作繁忙,同样的,一个航班不可能只为一个人而开,也可以接受很多个人的预订.并且这种查询是双向的,一个人他可以查询他订了多少个航班,一个航班也可以查询它被多少人订了,这样才好根据订的情况进行安排.

先看看代码吧.

还是老样子,Person类的代码

/*
* Person.java
*
* Created on 2007-9-15, 0:11:58
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

/**
*
* @author Admin
*/
@Entity
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    private Long id;
    private String name;
    private String sex;
    private int age;
    private Address address;
    private List<Phone> phones;
    private IDCard idCard;
    private Country country;
    private List<Car> cars;
    private List<Flight> flights;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "PersonANDFlight", joinColumns = {@JoinColumn(name = "personID")}, inverseJoinColumns = {@JoinColumn(name = "flightID")})
    public List<Flight> getFlights() {
        return flights;
    }

    public void setFlights(List<Flight> flights) {
        this.flights = flights;
    }

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "person")
    public List<Car> getCars() {
        return cars;
    }

    public void setCars(List<Car> cars) {
        this.cars = cars;
    }

    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "countryID")
    public Country getCountry() {
        return country;
    }

    public void setCountry(Country country) {
        this.country = country;
    }

    @OneToOne(cascade = CascadeType.ALL)
    public IDCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IDCard idCard) {
        this.idCard = idCard;
    }

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "personID")
    public List<Phone> getPhones() {
        return phones;
    }

    public void setPhones(List<Phone> phones) {
        this.phones = phones;
    }

    @OneToOne(cascade = {CascadeType.ALL})
    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }
}

代表航班的Flight类的代码:

/*
* Flight.java
*
* Created on 2007-9-24, 14:35:45
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import java.util.Date;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Temporal;

/**
*
* @author hadeslee
*/
@Entity
public class Flight implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;

    @Temporal(javax.persistence.TemporalType.TIME)
    public Date getArriveTime() {
        return arriveTime;
    }

    public void setArriveTime(Date arriveTime) {
        this.arriveTime = arriveTime;
    }

    public String getFlightNumber() {
        return flightNumber;
    }

    public void setFlightNumber(String flightNumber) {
        this.flightNumber = flightNumber;
    }

    public String getFromCity() {
        return fromCity;
    }

    public void setFromCity(String fromCity) {
        this.fromCity = fromCity;
    }

    @Temporal(javax.persistence.TemporalType.TIME)
    public Date getLeaveTime() {
        return leaveTime;
    }

    public void setLeaveTime(Date leaveTime) {
        this.leaveTime = leaveTime;
    }
    @ManyToMany(mappedBy="flights")
    public List<Person> getPersons() {
        return persons;
    }

    public void setPersons(List<Person> persons) {
        this.persons = persons;
    }

    public String getToCity() {
        return toCity;
    }

    public void setToCity(String toCity) {
        this.toCity = toCity;
    }
    private String flightNumber;
    private String fromCity,toCity;
    private Date leaveTime,arriveTime;
    private List<Person> persons;

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

}

我们再来看一看ManyToMany的声明

public @interface ManyToMany
{
   Class targetEntity( ) default void.class;
   CascadeType[] cascade( ) default {};
   FetchType fetch( ) default LAZY;
   String mappedBy( ) default "";
}

从代码可以看出,注释都差不多,只不过多对多的时候,仅仅从两张用外键相连是不够的,必须生成一张用于连接的中间表.也就如下代码所声明的地方:
@ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "PersonANDFlight", joinColumns = {@JoinColumn(name = "personID")}, inverseJoinColumns = {@JoinColumn(name = "flightID")})
    public List getFlights() {
        return flights;
    }

我们声明了一张用来连接的表,并且声明了主控端的列名和反转端的列名,其实这个声明不是必要的,当我们不用@JoinTable来声明的时候,JBOSS也会为我们自动生成一个连接用的表,表名默认是主控端的表名加上下划线"_"再加上反转端的表名.

从上面的注释我们可以看出,此关系的主控端在Person这一方,因为我们可以在Flight那一方看到如下注释:
@ManyToMany(mappedBy="flights")
    public List getPersons() {
        return persons;
    }

正是因为双向关系的存在,也由于Person是主控端, 所以Person要取消某次预定只要remove相应的Flight就可以了,而Flight由于是反转端,所以虽然它也可以得到它的所有预定的人,但是它却无法改变这种关系,即使它remove掉了某个Person,但是这种关系并不会在数据库里面表现出来,因为毕竟航班是不能随便取消一个人的登机资格的.

其实按我的理解来说,多对多的双向有点类似于一对多的单向,只不过双方都是一对多,我们这个例子完全可以用一对多来实现,但是一对多实现的话,就会有很多重复的数据存在,因为每个关系都可能会有重复的元素,比如我们这个例子,如果一对多的话,每个航班都会对应几百人,哪怕这几百人下次还坐你的航班,你还要重新定义一下.因为上次的几百人的外键已经指向你了.还要再指向另一个你,必须要重新生成几百个元素,所以在这种情况下,多对多就可以很好的重用数据库里面的表了,在Person和Flight表中,都不会有重复的元素存在了.并且关系也明朗了许多.

semovy 2007-09-27 14:26 发表评论

EJB学习日记(12)

semovy — Thu, 27 Sep 2007 06:25:00 GMT

实体BEAN的七种关系之---------一对多双向
One-to-Many Bidirectional Relationship

在实际生活中,一对多的双向关系也是有的,我们在这里举一个人和车的例子,人可以有很多车,车也必须要有一个主人(只要它是合法的),我们可以知道一个人有多少辆车,我们也可以通过任意一辆车牌号查到这辆车的主人是谁,这种关系不像人和电话,电话是很容易换的,并且很多号码是不用身份证的,但是车必须要上牌并且要用身份证的,这样才好管理嘛.下面我们来看代码吧

还是一样,先定义一个Person类(我们的Person已经一天一天的变大了:)

然后我们再定义一个Car类

/*
* Car.java
*
* Created on 2007-9-20, 19:40:39
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Temporal;

/**
*
* @author hadeslee
*/
@Entity
public class Car implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private Person person;
    private String carNumber;
    private String carName;
    private Date date;

    public String getCarName() {
        return carName;
    }

    public void setCarName(String carName) {
        this.carName = carName;
    }

    public String getCarNumber() {
        return carNumber;
    }

    public void setCarNumber(String carNumber) {
        this.carNumber = carNumber;
    }

    @Temporal(javax.persistence.TemporalType.DATE)
    public Date getCarDate() {
        return date;
    }

    public void setCarDate(Date date) {
        this.date = date;
    }
    @ManyToOne(cascade=CascadeType.ALL,optional=false)
    @JoinColumn(name="personID")
    public Person getPerson() {
        return person;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

}

从这里我们可以看到双向的一对多其实和双向的一对一差不多,一个是关系的主控端,一个是关系的被维护端.
,在一对一的双向关系里面,我们可以让任意一方做关系的主控端,任意一方做关系的被维护端(mapped 来注释),但是一对多或者说多一对的双向关系中,主控端必须是多的那一方,也就是Car,在它里面起一个外键指向Person类的主键,然后我们在对它们进行处理的时候,必须两端都要设置一下,才能保证数据的更新是如我们所愿的,比如

Person p=new Person();
Car car=new Car();
....
p.setCar(car);
car.setPerson(p);
entityManager.persist(p);
这个时候会把car和p都写入数据库,当我们要把car的主人换成p1时,需要做如下动作
p.getCars().remove(car);
car.setPerson(p1);
p1.setCar(car);
这样就可以了,其实只要我们保持一个良好的习惯,那就是更新关系的时候,双方都更新一下,这样就不容易出错了.

semovy 2007-09-27 14:25 发表评论

EJB学习日记(10)

semovy — Thu, 27 Sep 2007 06:24:00 GMT

实体BEAN的七种关系之---------一对多单向
One-to-Many Unidirectional Relationship

一对多单向最典型的应用莫过于人和电话的关系了,我们一个人可以有很多个电话,有时候还经常会换号码,我们可以既有小灵通也有手机,家里还有固定电话,这就是很典型的一对多关系,为什么要是单向的呢,因为电话的易变性,这个号码可能今天是你的,明天就可能是别人的了,并且现在买手机号码是不需要身份证的,所以从电话号码是不可能查到你的身份证了.并且电话号码也不应该和人绑定,一般我们都是问别人电话是多少,却比较少去问一个号码是谁的(这种情况也有,就是你收到陌生人的电话或短信的时候).那我们还是先看代码吧.

首先我们还是先要定义一个人的实体类

然后是电话的实体类

/*
* Phone.java
*
* Created on 2007-9-18, 17:23:28
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

/**
*
* @author hadeslee
*/
@Entity
public class Phone implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private String phoneNumber;

    public String getPhoneNumber() {
        return phoneNumber;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

}

我们可以在Person类里面发现如下注释

@OneToMany(cascade=CascadeType.ALL)
    @JoinColumn(name="personID")
    public List getPhones() {
        return phones;
    }

它代表是一对多,一是指类本身,多是指这个成员,也就是一个类可以对应多个成员.
在一对多里面,无论是单向还是双向,映射关系的维护端都是在多的那一方,也就是Phone那里,因为要在数据库面表现的话,也只有让Phone起一个指向Person的外键,不可能在Person里面指向Phone,这一点和一对一不一样,一对一可以在任意一方起一个外键指向对方.可是一对多却不行了.在这里@JoinColumn这个注释指的却是在Phone里面的外键的列的名字,它并不像在一对一里面的注释指的是自己表里面的外键列名.这一点要特别注意一下.
如果是一对多的双向关系,那么这个注释就要应用到多的那边去了,虽然注释还在Person类里面,但是它起的效果却是在Phone里面起一个叫personID的外键, 因为多的那边要有外键指向少的这边.

如果你不加    @JoinColumn(name="personID")这个注释的话,那么JBOSS就会自动帮你生成一张中间表,它负现Person和Phone表之间的联系.它将会做如下事情:

CREATE TABLE PERSON_PHONE

(

    PERSON_id INT,

 PHONE_id INT

);

ALTER TABLE PERSON_PHONE ADD CONSTRAINT person_phone_unique

   UNIQUE (PHONE_id);



ALTER TABLE PERSON_PHONE ADD CONSTRAINT personREFphone

   FOREIGN KEY (PERSON_id) REFERENCES PERSON (id);



ALTER TABLE PERSON_PHONE ADD CONSTRAINT personREFphone2

   FOREIGN KEY (PHONE_id) REFERENCES PHONE (id);

所以我们最好还是指定一下,以让程序产生更加确定的行为，不过一般是推荐另外生成一个中间表好一些，因为这样的话，对原来两张表的结构不对造成任何影响。在遗留系统的时候很多用，有些时候，一些表都是以前就建好了的，要改表的结构是不太可能的，所以这个时候中间的表就显得很重要了，它可以在不侵入原来表的情况下构建出一种更清淅更易管理的关系。

所以一对多的单向关联，我们还是推荐使用一张中间表来建立关系。

semovy 2007-09-27 14:24 发表评论

EJB学习日记(11)

semovy — Thu, 27 Sep 2007 06:24:00 GMT

实体BEAN的七种关系之---------多对一单向
Many-to-One Unidirectional Relationship

多对一单向在某种程度上不但和一对一单向相似并且还和一对多单向挺相似的，但是又不完全相同。多一对单向一般应用在很多实体对应一个实体，被对应的那个实体并不需要知道谁对应它了，典型的例子就是人对应国家，很多人可以是同一个国家的人，但是一个国家却不可能统计那么多它的人民。我们还是用代码来说话吧。

先定义Person实体类

再定义Country实体类

/*
* Country.java
*
* Created on 2007-9-20, 0:32:41
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
*
* @author Admin
*/
@Entity
public class Country implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private String name;
    private String phoneHead;
    private long population;
    private String area;
    private String useLanguage;

    public String getUseLanguage() {
        return useLanguage;
    }

    public void setUseLanguage(String language) {
        this.useLanguage = language;
    }

    public String getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    public String getName() {
        return name;
    }

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

    public String getPhoneHead() {
        return phoneHead;
    }

    public void setPhoneHead(String phoneHead) {
        this.phoneHead = phoneHead;
    }

    public long getPopulation() {
        return population;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

}

在这里我们可以看到，Country类和以前一些实体类是一样的，只有最基本的主键注释，对于有人和他关联的事情，他是一点都不知道的。我们可以在Person类看到如下的注释：

@ManyToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="countryID")
    public Country getCountry() {
        return country;
    }

@ManyToOne的定义如下

public @interface ManyToOne
{
   Class targetEntity( ) default void.class;
   CascadeType[] cascade( ) default {};
   FetchType fetch( ) default EAGER;
   boolean optional( ) default true;
}

在这里就没有mapped这个属性了，因为在一对多一对多一对的关系里面，关系的维护端都是在多的那一面，所以ManyToOne是没有mapped这个属性的，当然OneToMany也可以不用这个属性而使当前表占主导地位，就像昨天的那个例子一样。因为主控端是Person .外键也是建在Person上面，因为它是多的一面。当然我们在这里也可以省掉@JoinColumn，那样的话会怎么样呢，会不会像一对多单向一样生成中间的表呢？事实是不会的，在这里如果我们去掉@JoinColumn的话，那么一样会在Person表里面生成一列指向Country的外键，这一点和一对多的单向是不一样，在一对多的单向里面，如果我们不在Person 里面加上@JoinColumn这个注释，那么JBOSS将会为我们生成一个中间的表，这个表会有一个列指向Person主键，一个列指向Phone主键。所以说为了程序有一定的行为，有些东西我们还是不要省的好。

其实多对一单向是有点向一对一单向的，在主控端里面，也就是从Person的角度来看，也就是对应了一个Country而已，只不过这个Country是很多Person所共用的，而一对一却没有这一点限制。

semovy 2007-09-27 14:24 发表评论

EJB学习日记(9)

semovy — Thu, 27 Sep 2007 06:23:00 GMT

实体BEAN的七种关系之---------一对一双向
One-to-One Bidirectional Relationship

一对一双向的情况其实在现实生活中也是挺常见的,最常见的就是人和身份证的关系了,我们每个人都有一个身份证(只要你年满16岁,并且申请了),并且每个身份证都对应一个人,我们可以根据一个人查到他的身份证号码,也可以根据一个身份证号码查到一个人的具体情况,(第一代身份证重码的情况还是有的:( ) .好了,闲话不多说,还是看看代码吧.

先定义一个Person类

IDCard类

/*
* IDCard.java
*
* Created on 2007-9-18, 17:05:51
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;

/**
*
* @author hadeslee
*/
@Entity
public class IDCard implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private Person person;
    private String cardNumber;
    public String getCardNumber() {
        return cardNumber;
    }

    public void setCardNumber(String cardNumber) {
        this.cardNumber = cardNumber;
    }
    @OneToOne(cascade=CascadeType.ALL,mappedBy="idCard",optional=false)
    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
    public void setId(Long id) {
        this.id = id;
    }
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }


}

在这里我们可以看到一对一单向和一对一双向其实差别也不是很大,无非就是在对方的类里面也定义了一个自己,这样就互相都能找到对方了,在数据表的表现来看,和一对一单向是一模一样的,都是从Person表里面起一个外键连到IDCard的主键.但是只有这种方法吗?

在Person类里面,定义的IDCard注释是和Address一样的,可是我们在IDCard里面定义的注释却和Person里面的不一样:

@OneToOne(cascade=CascadeType.ALL,mappedBy="idCard",optional=false)
    public Person getPerson() {
        return person;
    }
多了一个mappedBy这个方法,它表示什么呢?它表示此表和Person的关系是定义在Person里面的idCard这个成员上面的,它表示此表是一对一关系中的从表,也就是关系是在person表里面维护的,这一点很重要.

我们也可以让主导权在IDCard上面,也就是让它产生一个指向Person的外键,这也是可以的,但是最好是让 Person来维护整个关系,这样更符合我们正常的思维.

我们也可以看到在Person里面IDCard是注释是optional=true,也就是说一个人是可以没有身份证的,但是一个身份证不可以没有人,所以在IDCard里面注释person的时候,optional就为false了,这样就可以防止一个空的身份证记录进数据库.

semovy 2007-09-27 14:23 发表评论

EJB学习日记(8)

semovy — Tue, 18 Sep 2007 13:36:00 GMT

实体BEAN的七种关系之---------一对一单向

一对一单向,顾名思义,就是只要求从A方到达B方,而不需要从B方到达A方,典型的例子就是,一个人对应一个地址,因为现实生活中,一个地址可能住很多人,所以一般我们只需要根据人查到它的地址,而不太会需要从一个地址去查谁住在那里,不过,真的有这种需求的话,我们就要以用另外一种关系来实现了,这个以后再讲

首先我们声明一个人的实体类,Person

再来看看Address的实体BEAN定义

/*
* Address.java
*
* Created on 2007-9-15, 0:13:50
*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package lbf.entitybean.test1;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
*
* @author Admin
*/
@Entity
public class Address implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private String country,province,city,street;
    private int postcode;
    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public int getPostcode() {
        return postcode;
    }

    public void setPostcode(int postcode) {
        this.postcode = postcode;
    }

    public String getStreet() {
        return street;
    }

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

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return id;
    }

}

以上便是两个类的定义,从Person里面我们可以看到如下的代码

@OneToOne(cascade=CascadeType.ALL,optional=true)
    public Address getAddress() {
        return address;
    }
在这里的@OneToOne就是注释是一对一的关系,其中cascade是表示级联的关系,是级联删除还是级联更新,还是所有,我们这里选择的是所有,这样的好处就是,我们在插入Person的时候,就顺带的把Person里面包含的Address一起插入数据库里面,当我们删除Person的时候,也是把这个Person对应的Address从数据库里面删除,否则就需要我们人工的删除两遍或者插入两遍等等,optional表示这个成员是不是可选的,我们这里是可选的,也就是说一个人可以没有地址(比如流浪汉:)).
然后我们发现,在Address里面只有一些简单的EntityBean的注释,并没有表示关系的注释,这是因为本例是一对一单向的实现,Person里面有 Address,而Address却什么都不知道,它对应到数据库里面只是一张简单的表而已,Person对应到数据库里面就有一个指向Address的外键.我们也可以增加注释指定外键的列的名字,如下:
@OneToOne(cascade=CascadeType.ALL,optional=true)
@JoinColumn(name="addressID")
    public Address getAddress() {
        return address;
    }
如果我们不加的话,也是可以通过的,在JBOSS里面,它会自动帮你生成你指向这个类的类名加上下划线再加上id的列,也就是默认列名是:address_id.

如果是主键相关联的话,那么可以运用如下注释

@OneToOne(cascade={CascadeType.ALL})
   @PrimaryKeyJoinColumn

   public Address getAddress( ) {
      return homeAddress;
   }
它表示两张表的关联是根据两张表的主键的

以下是一些注释的定义,我们看一下可以了解一下这些注释有哪些方法,

public @interface JoinColumn
{
   String name( ) default "";
   String referencedColumnName( ) default "";
   boolean unique( ) default false;
   boolean nullable( ) default true;
   boolean insertable( ) default true;
   boolean updatable( ) default true;
   String columnDefinition( ) default "";
   String table( ) default "";
}

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

public @interface PrimaryKeyJoinColumn
{
   String name( ) default "";
   String referencedColumnName( ) default "";
   String columnDefinition( ) default "";
}

semovy 2007-09-18 21:36 发表评论

EJB初学日记（6）

semovy — Tue, 18 Sep 2007 13:31:00 GMT

实体BEAN的关联

今天自己写了一个例子,有关实体BEAN的关联问题,我写的这个例子是一对多的情况,一是人,多是狗,一个人可以养多条狗,每条狗都必须有一个主人,在删除主人的时候,狗就没有存在的必要了,所以狗也要跟着删除,可是删除狗的时候,主人却可以在.一开始我实现的时候,删除狗的操作是错误的,我以为直接把Person里面的Dog删掉,然后更新Person就可以了,谁知不是这样的,你在增加了Person中的狗的时候,你更新Person就可以把狗加进来了,可是当你把Person里面的狗删除掉时,再更新Person,数据库里面的狗却不会少.而要你显示的调用em.remove()去删除你想删除的狗,并且你对这狗不能设置为级联删除,否则你删除狗的时候把人也删掉了,这当然不是我们希望看到的.

下面附上代码

package com.hadeslee.session;

import com.hadeslee.entity.Person;
import java.util.List;
import javax.ejb.Remote;

/**
* This is the business interface for PersonDAO enterprise bean.
*/
@Remote
public interface PersonDAORemote {
     public void insertPerson(Person p);
     public List getAllPersons();
     public Person findPerson(long id);
     public void deletePerson(long id);
}

package com.hadeslee.session;

import com.hadeslee.entity.Dog;
import com.hadeslee.entity.Person;
import java.util.List;
import javax.ejb.Remote;


/**
  * This is the business interface for PersonToDogs     enterprise bean.
  */
@Remote
public interface PersonToDogsRemote extends PersonDAORemote{
     public void addDog(Person p,Dog dog);
     public Person removeDog(Person p,Dog dog);
     public List getDogs(Person p);
     public Person getOwner(Dog dog);
}

   /*
   * PersonDAOBean.java
   *
   * Created on 2006年12月13日, 下午3:53
   *
   * To change this template, choose Tools | Template Manager
   * and open the template in the editor.
   */

  package com.hadeslee.session;

  import com.hadeslee.entity.Person;
import java.util.List;
import javax.ejb.Stateful;
import javax.persistence.Query;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

/**
  *
  * @author lbf
  */
@Stateful
public class PersonDAOBean implements com.hadeslee.session.PersonDAORemote {
   @PersistenceContext
    protected EntityManager em;
  /** Creates a new instance of PersonDAOBean */
    public PersonDAOBean() {
    }

    public void insertPerson(Person p) {
       em.persist(p);
       System.out.println("保存成功");
   }

    public List getAllPersons() {
      Query query=em.createQuery("select p from Person p order by p.id");
          return query.getResultList();
    }

     public Person findPerson(long id) {
        return em.find(Person.class,id);
       }
       public void deletePerson(long id){
         em.remove(em.find(Person.class,id));
     }

}

   1.  /*
   2.  * PersonToDogsBean.java
   3.  *
   4.  * Created on 2006年12月13日, 下午4:50
   5.  *
   6.  * To change this template, choose Tools | Template Manager
   7.  * and open the template in the editor.
   8.  */
   9.
  10. package com.hadeslee.session;
  11.
  12. import com.hadeslee.entity.Dog;
  13. import com.hadeslee.entity.Person;
  14. import java.util.List;
  15. import javax.ejb.Stateless;
  16. import javax.persistence.Query;
  17.
  18. /**
  19.  *
  20.  * @author lbf
  21.  */
  22. @Stateless
  23. public class PersonToDogsBean extends PersonDAOBean implements com.hadeslee.session.PersonToDogsRemote {
  24.
  25.     /** Creates a new instance of PersonToDogsBean */
  26.     public PersonToDogsBean() {
  27.     }
  28.
  29.     public void addDog(Person p, Dog dog) {
  30.         p.addDog(dog);
  31.         em.merge(p);
  32.     }
  33.
  34.     public Person removeDog(Person p, Dog dog) {
  35.         //em.remove(dog);
  36.         p.removeDog(dog);
  37.         System.out.println("此时P的大小是："+p.getDogs().size());
  38.         em.merge(p);
  39.         return p;
  40.     }
  41.
  42.     public List getDogs(Person p) {
  43.         return p.getDogs();
  44.     }
  45.
  46.     public Person getOwner(Dog dog) {
  47.         Query query=em.createQuery("select p from Person p where p.id=?1");
  48.         query.setParameter(1,dog.getOwner().getId());
  49.         return (Person)query.getSingleResult();
  50.     }
  51.
  52. }

目前的代码是不能正常删除的,要正常删除狗的话,必须把em.remove() 那句话还原,然把再把em.merge()那句话注释起来才行还有一个现象,那就是我在对远程对象进行了操作以后,并不会反映到我的本地对象,比如我调用了删除人里面的一条狗,在远程或者在数据库里面确实是删掉了,可是我在调用人的时候,里面还是有那么的狗,这样就会产生不同步的现象,为了消除这种现象,我把接口写了一个,改为进行了删除操作的时候,它会再次返回Person对象,这个时候就可以保证远程对象和本地对象的一致性了. 增加代码没写,所以每次增加了狗后,调用Person对象时,依然是增加前一样的,也就是说,当我持有了远程对象发过来的本地对象后,如果我不对其进行操作,无论你怎么调用远程方法,此方法会对其有影响的,JVM都不会返回一个最新的给你,而你用的永远是第一次传过来的那个以象,所以,在远程对象传输中,必须要注意同步性,要么就每次都从远程去取最新的对象,要么就先对本地对象做同样的操作,比如前面的addDog动作,先在本地执行一遍,然后远程执行远程的,这样就可以同步了,不过我觉得如果是网络允许的情况下,还是每次对对象操作后都能返回最新的对象好一些,免得手工去保持和远程对象的同步,这样不可靠.
一对多目前只看到了这么多,接下来要看一下多对多的情况.

semovy 2007-09-18 21:31 发表评论

EJB学习日记(7)

semovy — Tue, 18 Sep 2007 13:31:00 GMT

七种映射关系

在实体BEAN中,互相之间的关系有七种,分别是如下七种

1,一对一单向
2,一对一双向
3,一对多单向
4,一对多双向
5,多对一单向
6,多对多单向
7,多对多双向

大家可能发现,为什么没有多对一双向呢?其实多对一的双向,就是一对多的双向,道理是一样的.

今天把典型的应用场哈举个例子,改天再用代码来说话
1,一对一单向.
典型场合:一个人对应一个地址,我们一般只要求给定一个人知道他的地址,却不需要给定一个地址确定一个人的
2,一对一双向
典型场合:一个人对应一个身份证号,我们可以根据一个人得到它的身份证号码,也可以根据身份证号码确定一个人
3,一对多单向
典型场合:一个人对应很多他的电话, 我们一般只要求给定一个人得到他的所有电话,却不会用一个电话去反查一个人,因为电话是很容易改变的
4,一对多双向
典型场合:旅行和预订,一次旅程有多个预订,我们可以根据某次旅程查到这次旅行所对应的预订,也可以根据一次预订查到它所属的那次旅程
5,多对一单向
典型场合:人民和国家,我们只需要知道我们人民是属于哪个国家的,而国家不可能确实地知道它有多少个人民.
6,多对多单向
典型场合:预定和舱位,你可以多次预定一个舱位,也可一定预定多个舱位.一般都是根据某次预定来知道预定了哪些舱位
7,多对多双向
典型场合:老师和学生,老师可以有很多学生,学生也可以有很多老师,可以根据学生查出他所有的老师,也可以根据老师查出他所有的学生.

其实在数据库里面,表现的形式单向和双向都是一样的,只是我们在程序里面为了逻辑清楚而人分的分类了.下次我们将了解一下这七种关系的不同代码,以及他们在数据库里面的表现形式

semovy 2007-09-18 21:31 发表评论

EJB初学日记(5)

semovy — Tue, 18 Sep 2007 13:30:00 GMT

以前看到一本书上写的,有关定义实体BEAN的一些细节,直到今天才知道其中的差别

代码1:

/*
* Test.java
*
* Created on 2006年12月15日, 上午12:06
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package com.hadeslee.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
* Entity class Test
*
* @author lbf
*/
@Entity
public class Test implements Serializable {
    private Long id;
    private String name,sex,age;
    private int idCard;
    /** Creates a new instance of Test */
    public Test() {
    }

    /**
     * Gets the id of this Test.
     * @return the id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {
        return this.id;
    }

    /**
     * Sets the id of this Test to the specified value.
     * @param id the new id
     */
    public void setId(Long id) {
        this.id = id;
    }
    public void setNameID(int ids){
        this.idCard=ids;
    }
    public int getNameID(){
        return idCard;
    }

    /**
     * Returns a hash code value for the object.  This implementation computes
     * a hash code value based on the id fields in this object.
     * @return a hash code value for this object.
     */
    @Override
    public int hashCode() {
        int hash = 0;
        hash += (this.id != null ? this.id.hashCode() : 0);
        return hash;
    }

    /**
     * Determines whether another object is equal to this Test.  The result is
     * true if and only if the argument is not null and is a Test object that
     * has the same id field values as this object.
     * @param object the reference object with which to compare
     * @return true if this object is the same as the argument;
     * false otherwise.
     */
    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Test)) {
            return false;
        }
        Test other = (Test)object;
        if (this.id != other.id && (this.id == null || !this.id.equals(other.id))) return false;
        return true;
    }

    /**
     * Returns a string representation of the object.  This implementation constructs
     * that representation based on the id fields.
     * @return a string representation of the object.
     */
    @Override
    public String toString() {
        return "com.hadeslee.entity.Test[id=" + id + "]";
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

}

代码2:

/*
* Test.java
*
* Created on 2006年12月15日, 上午12:06
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package com.hadeslee.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
* Entity class Test
*
* @author lbf
*/
@Entity
public class Test implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name,sex,age;
    private int idCard;
    /** Creates a new instance of Test */
    public Test() {
    }

    /**
     * Gets the id of this Test.
     * @return the id
     */

    public Long getId() {
        return this.id;
    }

    /**
     * Sets the id of this Test to the specified value.
     * @param id the new id
     */
    public void setId(Long id) {
        this.id = id;
    }
    public void setNameID(int ids){
        this.idCard=ids;
    }
    public int getNameID(){
        return idCard;
    }

    /**
     * Returns a hash code value for the object.  This implementation computes
     * a hash code value based on the id fields in this object.
     * @return a hash code value for this object.
     */
    @Override
    public int hashCode() {
        int hash = 0;
        hash += (this.id != null ? this.id.hashCode() : 0);
        return hash;
    }

    /**
     * Determines whether another object is equal to this Test.  The result is
     * true if and only if the argument is not null and is a Test object that
     * has the same id field values as this object.
     * @param object the reference object with which to compare
     * @return true if this object is the same as the argument;
     * false otherwise.
     */
    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Test)) {
            return false;
        }
        Test other = (Test)object;
        if (this.id != other.id && (this.id == null || !this.id.equals(other.id))) return false;
        return true;
    }

    /**
     * Returns a string representation of the object.  This implementation constructs
     * that representation based on the id fields.
     * @return a string representation of the object.
     */
    @Override
    public String toString() {
        return "com.hadeslee.entity.Test[id=" + id + "]";
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

}

代码1和代码2唯一的差别就是@Id的注释地方不同了

同样是注释主键,当在直接用在变量上注释时,如果其它的成员变量没有指定名字,则数据库生成的表的各列名字将以定义的成员变量的变量名为准

当用在getter方法注释时,则数据库生成的表的各列名字将取getXXXX的XXXX名字,将不再取定义的成员变量名

像上面的例子中,代码1会有IdCard这一列,则代码2取而代之的将是NameID这一列.这看上去是一个小小的差别,但是了解了终究是好事.呵呵.终于懂清楚在get上注释和直接在成员变量上注释的差别了,一般来说是不会有什么差别的,一般标准的JAVABEAN都是成员变量名和getter,setter签名一样的.

semovy 2007-09-18 21:30 发表评论

EJB初学日记(3)

semovy — Tue, 18 Sep 2007 13:29:00 GMT

摘要: 今天主要是看了一下拦截器的实现,在EJB3.0里面,实现拦截非常简单.加一个注释就可以了,这样就可以随时监视某个方法的调用了,拦截器可以是拦截某一个方法也可以是拦截一个类的所有方法的.具体如下首先写一个拦截器方法,拦截器方法并不需要实现什么接口,只要符合一定的规范就可以了, 规范是: Object xxxxx(InvocationContext context)thr... 阅读全文

semovy 2007-09-18 21:29 发表评论

EJB初学日记(4)

semovy — Tue, 18 Sep 2007 13:29:00 GMT

关于session bean的一些问题
EJB里面,session bean是占了挺重要的地位的,一些重要的事情都是交给session bean来处理的

session BEAN一般用于操作一些对外的方法,供客户调用.会话BEAN分两种,一种是有状态的会话BEAN,一种是无状态的会话BEAN,它们有什么不同呢?

有状态的会话BEAN,会记录每一个调用者的状态,每个人都有一个自己的实例,相比之下,它比较耗内存.一般用于做专用的事情
无状态的会话BEAN,则不会记录每一个调用者的状态,所有人共有一个实例,所以它不耗内存,一般用于做一些通用的事情

会话BEAN中有一种叫定时服务,并不是所有的会话BEAN都可以有定时服务器,而只有无状态的会话BEAN可以有定时的服务,如果调用的是有状态的会话BEAN的话,那么运行时就会出异常,不知道是不是有状态的会话BEAN不允许有定时服务.对于会话BEAN,我们可以掌握它的生命周期

EJB容器创建和管理session bean实例,有些时候，你可能需要定制 session bean的管理过程。例如，你可能想在创
建session bean实例的时候初始化字段变量,或在bean实例被销毁的时候关掉外部资源。上述这些，你都可能通过
在 bean 类中定义生命周期的回调方法来实现。这些方法将会被容器在生命周期的不同阶段调用（如：创建或销
毁时）。通过使有下面所列的注释，EJB 3.0允许你将任何方法指定为回调方法。这不同于 EJB 2.1，EJB 2.1中，
所有的回调方法必须实现，即使是空的。EJB 3.0中，bean可以有任意数量，任意名字的回调方法。
·@PostConstruct：当bean对象完成实例化后，使用了这个注释的方法会被立即调用。这个注释同时适用于
有状态和无状态的会话bean。
·@PreDestroy：使用这个注释的方法会在容器从它的对象池中销毁一个无用的或者过期的 bean 实例之前调
用。这个注释同时适用于有状态和无状态的会话 bean。
·@PrePassivate：当一个有状态的session bean实例空闲过长的时间，容器将会钝化(passivate)它，并把它的
状态保存在缓存当中。使用这个注释的方法会在容器钝化bean实例之前调用。这个注释适用于有状态的会话bean。
当钝化后，又经过一段时间该 bean 仍然没有被操作，容器将会把它从存储介质中删除。以后，任何针对该 bean
方法的调用容器都会抛出例外。
·@PostActivate：当客户端再次使用已经被钝化的有状态 session bean 时，新的实例被创建，状态被恢复。
使用此注释的session bean会在bean的激活完成时调用。这个注释只适用于有状态的会话 bean。
·@Init：这个注释指定了有状态session bean初始化的方法。它区别于@PostConstruct注释在于：多个@Init
注释方法可以同时存在于有状态session bean 中，但每个 bean实例只会有一个@Init注释的方法会被调用。这取
决于bean是如何创建的（细节请看EJB 3.0规范）。@PostConstruct在@Init之后被调用。

另一个有用的生命周期方法注释是@Remove，特别是对于有状态 session bean。当应用通过存根对象调用使用了
@Remove注释的方法时，容器就知道在该方法执行完毕后，要把 bean实例从对象池中移走。

这里要注意的一点是,对于无状态的会话BEAN,即使你调用了标记为@Remove的方法,这个会话BEAN依然有效,所以,这个注释应该用在有状态的会话BEAN中,这样当你调用了它所标记的方法后,再调用这个会话BEAN的其它方法就会抛出一个异常
javax.ejb.EJBNoSuchObjectException: Could not find Stateful bean:它会说找不到这个有状态的会话BEAN了,因为这个时候经过你调用了标记为@Remove的方法后,EJB容器已经将它销毁了,以后的任何调用都是无效的了,这样有利于我们更好的掌握会话BEAN的生命周期,免得产生很有有状态的会话BEAN的时候,过多的消耗服务器的内存.

semovy 2007-09-18 21:29 发表评论

EJB初学日记(2)

semovy — Tue, 18 Sep 2007 13:28:00 GMT

其实在学习EJB之前,就听说过EJB,有人说他很复杂,也有人说一般般而已,但是几乎所有的人都说EJB3.0确实是简单了许多.
一般讲起JAVA EE,一般人都认为是应用在网页里面的,甚至有人把JAVA EE和JSP等同起来,要知道,JAVA EE是一个很庞大的结构,而JSP只是里面一部份中的一部份而已.

今天我就把JAVA EE的EJB应用到JAVA SE中看一看,在JBOSS里面布署好EJB,然后在swing里面调用EJB,并且观察一些特性.

首先我们先定义一个EJB的接口,接口里面放上我们需要远程调用的方法
在定义接口的时候,可以给它加上@Remote或者@Local注释,表示是远程还是本地,也可以什么都不加,就是一个很普通的接口,然后在实现的时候加上相应的注释,我们就采取第二种,也就是接口的定义里面什么注释都没有

package test1;
/**
* This is the business interface for Hello enterprise bean.
*/
public interface HelloLocal {
public String helloFromLocal(String s);
}

package test1;

import javax.ejb.Remote;

/**
* This is the business interface for Hello enterprise bean.
*/
public interface HelloRemote {
public String helloFromRemote(String s);
}

以上是两个接口, 一开始是拟做本地调用和远程调用的两个接口,后来我想,能不能让一个接口既是本地接口也是远程接口呢,在JBOSS是可以的.实现如下

/*
* HelloBean.java
*
* Created on 2007年9月6日, 下午6:02
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package test1;

import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.swing.JOptionPane;

/**
*
* @author hadeslee
*/
@Stateless
@Remote({HelloLocal.class,HelloRemote.class})
@Local({HelloLocal.class,HelloRemote.class})
public class HelloBean implements test1.HelloRemote, test1.HelloLocal {
    private int i=0;
    /** Creates a new instance of HelloBean */
    public HelloBean() {
    }

    public String helloFromRemote(String s) {
        i++;
        System.out.println("第"+i+"次调用");
        System.out.println("来自远程的问侯:"+s);
        return "远程返回:"+s+":"+i;
    }

    public String helloFromLocal(String s) {
        i++;
        System.out.println("第"+i+"次调用");
        JOptionPane.showMessageDialog(null,"来自本地的问侯:"+s);
        System.out.println("来自本地的问侯:"+s);
        return "本地返回:"+s+":"+i;
    }

}

在实现的类里面@Remote@Local表示它们要实现的接口,我把两个都放进去了,在NetBeans里面,会有错误的提示,提示内容如下:
Bean使用以下类做为本地和远程业务接口:test1.HelloLocal
但是我编译以后一样是可以布署的,不知道别的EJB容器是否可以这样做.jboss确实是可以的

好了,现在我们都定义好了,马上把它们布署到JBOSS里面去吧.

布署完了之后,就开始开发我们的应用程序了,因为这个调用只涉及到一个方法,我们就不用去定义一个界面了.
我们简单的程序如下.

/*
* TestHello.java
*
* Created on 2007年9月6日, 下午6:06
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package testejb;

import java.util.Properties;
import javax.naming.InitialContext;
import test1.HelloLocal;
import test1.HelloRemote;

/**
*
* @author hadeslee
*/
public class TestHello {

    /** Creates a new instance of TestHello */
    public TestHello() {
    }
    public static void main(String[] args) throws Exception{

        Properties props = new Properties();
        //这些是JBOSS的初始化一些参数
        props.setProperty("java.naming.factory.initial",
                "org.jnp.interfaces.NamingContextFactory");
        props.setProperty("java.naming.provider.url", "localhost:1099");
        props.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming");
        InitialContext ctx;
        ctx = new InitialContext(props);
        //找到远程接口,这时其实也可以转成HelloLocal
        HelloRemote hello = (HelloRemote) ctx.lookup("HelloBean/remote");
        System.out.println(hello.helloFromRemote("千里冰封"));
        //可以直接转型过来
        HelloLocal local=(HelloLocal)hello;
        System.out.println(local.helloFromLocal("hadeslee"));

    }
}

这个时候,我们就可以看到,会有一个 JOptionPane弹出来,点了确定之后,客户端这边才会有输出,JOpitonPane出来之后不一定在最前端显示,所以可能需要找一下,就是因为这个问题搞得我糊涂了一下,我找了半天找不到,后来一个一个窗口的最小化,终于发现了JOptionPane在那里.

为了能运行客户端,你需要把如下的JAR包放到运行客户端的classpath里面,如果是用NetBeans开发的话,加入一个库可以了,库里面包含的JAR文件如下:
[jboss安装目录]\client\commons-logging.jar
[jboss安装目录]\client\ concurrent.jar
[jboss安装目录]\client\ ejb3-persistence.jar
[jboss安装目录]\client\ hibernate-annotations.jar
[jboss安装目录]\client\ hibernate-client.jar
[jboss安装目录]\client\ javassist.jar
[jboss安装目录]\client\ jboss-annotations-ejb3.jar
[jboss安装目录]\client\ jboss-aop-jdk50-client.jar
[jboss安装目录]\client\ jboss-aspect-jdk50-client.jar
[jboss安装目录]\client\jboss-common-client.jar
[jboss安装目录]\client\ jboss-ejb3-client.jar
[jboss安装目录]\client\ jboss-ejb3x.jar
[jboss安装目录]\client\jboss-j2ee.jar
[jboss安装目录]\client\jboss-remoting.jar
[jboss安装目录]\client\jbosssx-client.jar
[jboss安装目录]\client\jboss-transaction-clie
[jboss安装目录]\client\jnp-client.jar
[jboss安装目录]\client\trove.jar
[jboss安装目录]\client\jbossws-client.jar
[jboss安装目录]\client\jboss-jaxws.jar
[jboss安装目录]\client\xmlsec.jar

这样的话,就可以把EJB布署在EJB容器里面,而我们可以在任何地方调用它了.只要你在想调用的地方,带上上面的JAR包就可以了.

semovy 2007-09-18 21:28 发表评论

EJB初学日记(1)

semovy — Tue, 18 Sep 2007 13:27:00 GMT

今天终于还是下定决心看看EJB,看着SPRING看了两天,觉得一点头绪都没有,我不是一个讲究速成的人,但是总是感觉和它们的理念不太一样,唉,真可怜,都怪自己,初学JAVA的时候就把J2SE看得太重了.

在学习了J2SE一整年之后,发现JAVA的应用还远远没有掌握,我学习一年的结果就是刚刚对JAVA有所了解而已,回首这一年的路,挺艰难的,但是现在以一个过来人的姿态去看的时候,我又学得很庆幸.因为我没有放弃,在我学习条件最艰苦的时候,在我最无助的时候我都没有放弃.曾经记得为了想一个小小的程序,为了实现一个小小的功能,在那里苦思冥想,想得都想吐了,还记得半夜从梦中醒来的时候,脑子里满是程序代码,甚至做梦的时候也在编程序,想算法.就这样,一年,我磕磕碰碰的走过来了.

一年后的今天,我将重新站在一个全新的起点上:J2EE,面全企业的应用,希望以后心态能像一年前一样.踏踏实实地走过.一步一个脚印.记得一年前,我刚学JAVA时,喜欢写学习日记,喜欢把自己不懂的,以及当天收获的,还有对一些程序的理解和看法记下来,并且过一段时间就去看以前写的学习日记,那时候经常会发现自己有所进步.那种感觉,真的很好.

今天算我第一天,我下面把我今天所看到的,写下来,以及自己不太了解的地方写下来,做为一个初学者最真实的心理反应和想法,也为自己J2EE之路留下些纪念.

今天下载了黎活明的EJB3.0实例教程,学了如何装JBoss4.0,第一次我下载的是免安装版,直接解压缩就可以用了,但是一直都配置不好那个EJB的应用,后来,删掉重新按照书上的地址下载了一个安装版的,并按照介始的顺序和方法安装了一遍,一布署,呵,真的可以了.看到网页打开的一霎那,真的感觉很有成就感,虽然应用都是别人写的.

由于此书用的IDE是Eclipse,可是我用的IDE是NetBeans,所以有些地方就实践不了了,但是能实践的,我都尽量会去实践一下,哪怕是抄代码,我也会亲手抄一遍.我觉得这对我们初学者来说有很大的帮助.

今天学的是会话BEAN,有状态会话BEAN和无状态会话BEAN
声明接口的代码

/*
* HelloWorld.java
*
* Created on 2006年12月7日, 下午9:26
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package lbf.demo;

/**
*
* @author lbf
*/
public interface HelloWorld {

    /** Creates a new instance of HelloWorld */
    public String sayHello(String who);

}

实现接口的代码

/*
* HelloWorldBean.java
*
* Created on 2006年12月7日, 下午9:27
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package lbf.demo.impl;

/**
*
* @author lbf
*/
import lbf.demo.*;
import javax.ejb.*;
@Stateless
@Remote({HelloWorld.class})   //表示是远程调用
public class HelloWorldBean implements HelloWorld {

    /** Creates a new instance of HelloWorldBean */
    public HelloWorldBean() {
    }
    public String sayHello(String who){
        return who+"说：这是我的第一个EJB东东！！";
    }
}

打包成JAR文件以后,放到JBOSS_HOME/server/all/deploy下面就可以了,JBOSS支持热布置,这一点和TOMCAT一样

只是两者的目录结构有一点不一样而已,并且它也支持WAR布署.同样也是复制到JBOSS_HOME/server/all/deploy下面

用ctx.lookup("HelloWorldBean/remote"); 来查找绑定的BEAN,一般命名规则是

在这里我要重点说明一下EJB JNDI名称默认的命名规则，命名规则如下：
1> 如果EJB应用打包成后缀为*.ear 的发布文件，默认的 JNDI 名称是
访问本地接口：EAR-FILE-BASE-NAME/EJB-CLASS-NAME/local
访问远程接口：EAR-FILE-BASE-NAME/EJB-CLASS-NAME/remote
例：如果HelloWorld应用打包成HelloWorld.ear 文件，访问她远程接口的 JNDI 名是：
HelloWorld/HelloWorldBean/remote

2> 如果EJB应用打包成后缀为*.jar 的发布文件, 默认的 JNDI 名称是
访问本地接口：EJB-CLASS-NAME/local
访问远程接口：EJB-CLASS-NAME/remote
例： HelloWorld应用打包成HelloWorld.jar 文件，访问她远程接口的 JNDI名称是：HelloWorldBean/remote
另外有一点要注意：EJB-CLASS-NAME 是不带包名的，如 com.foshanshop.ejb3.impl.HelloWorldBean只需取
HelloWorldBean。
目前网上很多教材获取JNDI名的方式都过时了，如：
HelloWorld helloworld = (HelloWorld) ctx.lookup(HelloWorld.class.getName());

stateless每次查找都会返回同一个BEAN,而stateful每次查找都会产生一个新的BEAN,用来保存特定的客户会话

那按照上面的命名规则,岂不是很容易生成相同的名字的BEAN?因为它的名字那么短,如何避免这种情况呢.EJB应该有解决的办法吧.看以后吧

希望以后的日记中能搞清楚这个问题

semovy 2007-09-18 21:27 发表评论

EJB 3.0 的新规范概览及其未来发展

semovy — Fri, 07 Sep 2007 08:00:00 GMT

开始

　　无论如何由于EJB的复杂性使之在J2EE架构中的表现一直不是很好。EJB大概是J2EE架构中唯一一个没有兑现其能够简单开发并提高生产力的组建。 EJB3.0规范正尝试在这方面作出努力以减轻其开发的复杂性。EJB3.0减轻了开发人员进行底层开发的工作量，它取消或最小化了很多（以前这些是必须实现）回调方法的实现，并且降低了实体Bean及O/R映射模型的复杂性。

　　在本文中，我首先会介绍EJB3.0中几个主要的改变。它对进一步深入了解EJB3.0是非常重要的。随后，我会从更高的层面来描述已经被提交到EJB3.0规范中的细节，并一个个的讲解新的规范中的改变：实体 Bean,O/R映射模型，实体关系模型和EJB QL(EJB查询语言)等等。

　　背景

　　EJB3.0中两个重要的变更分别是：使用了Java5中的程序注释工具和基于Hibernate的O/R映射模型。

　　Java5中的元数据工具。

　　Java5 （以前叫J2SE1.5或Tiger）中加入了一种新的程序注释工具。通过这个工具你可以自定义注释标记，通过这些自定义标记来注释字段、方法、类等等。这些注释并不会影响程序的语义，但是可以通过工具（编译时或运行时）来解释这些标记并产生附加的内容（比如部署描述文件），或者强制某些必须的运行时行为（比如EJB组件的状态特性）。注释的解析可以通过源文件的解析（比如编译器或这IDE工具）或者使用Java5中的APIs反射机制。注释只能被定义在源代码层。由于所有被提交到EJB3.0草案中的注释标记都有一个运行时的RetentionPolicy，因此会增加类文件占用的存储空间，但这却给容器制造商和工具制造商带来了方便。

　　Hibernate

　　目前Hibernate非常受欢迎，它是开发源代码的Java O/R映射框架，目的是把开发人员从繁琐的数据持久化编程中解脱出来。它也有一个标准的HQL（Hibernate 查询语言）语言，你可以在新的EJB QL中看到它的影子。Hibernate在处理如数据查询、更新、连接池、事务处理、实体关系处理等方面非常简单。

　　概览

　　在已经提交的EJB3.0规范中主要涉及两个方面的改变：

　　1. 一套以注释为基础的EJB编程模型，再加上EJB2.1中定义的通过部署描述符和几个接口定义的应用程序行为。

　　2. 新的实体Bean持久化模型，EJBQL也有许多重要的改变。

　　还有一些有关上述的提议，比如：一个新的客户端编程模型，业务接口的使用以及实体Bean的生命周期。请注意EJB2.1编程模型（包括部署描述符和home/remote接口）仍然是有效的。新的简化模型并没有完全取代EJB2.1模型。

　　EJB注释

　　EJB 规范组织一个重要的目标是减轻原始代码的数量，并且他们为此给出了一个完美而简介的办法。在EJB3.0的里，任何类型的企业级Bean只是一个加了适当注释的简单Java对象(POJO)。注释可以用于定义bean的业务接口、O/R映射信息、资源引用信息，效果与在EJB2.1中定义部署描述符和接口是一样的。在EJB3.0中部署描述符不再是必须的了；home接口也没有了，你也不必实现业务接口（容器可以为你完成这些事情）。

　　比如，你可以使用@Stateless注释标记类把Java类声明为一个无状态回话bean。对于有状态回话bean来说，@Remove注释可以用来标记一个特定的方法，通过这个注释来说明在调用这个方法之后bean的实例将被清除掉。

　　为了减少描述组件的说明信息，规范组织还采纳了由异常进行配置（configuration-by-exception）的手段，意思是你可以为所有的注释提供一个明确的缺省值，这样多数常规信息就可以据此推断得出。

　　新的持久化模型

　　新的实体bean也是一个加了注释的简单Java对象(POJO)。一旦它被EntityManager访问它就成为了一个持久化对象，并且成为了持久化上下文（context）的一部分。一个持久化上下文与一个事务上下文是松耦合的；严格的讲，它隐含的与一个事务会话共存。

　　实体关系也是通过注释来定义的，O/R映射也是，并提供几种不同的数据库规范操作，在EJB2.1中这些要通过开发人员自己的设计模式或者其它技术来完成的（比如，自增长主键策略）。

　　深入研究

　　现在是时候详细了解EJB3.0草案了。让我们开始探讨所有EJB中四种企业级bean，并看看他们在新的规范中是什么样子。

　　无状态回话bean

　　在EJB3.0规范中，写一个无状态回话bean(SLSB)只需要一个简单的Java文件并在类层加上@Stateless注释就可以了。这个bean可以扩展javax.ejb.SessionBean接口，但这些不是必须的。

　　一个SLSB不再需要home接口，没有哪类EJB再需要它了。Bean类可以实现业务接口也可以不实现它。如果没有实现任何业务接口，业务接口会由任意 public的方法产生。如果只有几个业务方法会被暴露在业务接口中，这些方法可以使用@BusinessMethod注释。缺省情况下所有产生的接口都是local（本地）接口，你也可以使用@Remote注释来声明这个接口为remote（远程）接口。

　　下面的几行代码就可以定义一个HelloWorldbean了。而在EJB2.1中同样的bean至少需要两个接口，一个实现类和几个空的实现方法，再加上部署描述符。

import javax.ejb.*;

/**
* A stateless session bean requesting that a remote business
* interface be generated for it.
*/
@Stateless
@Remote
public class HelloWorldBean {
public String sayHello() {
return "Hello World!!!";
}
}

　　有状态回话bean

　　除了几个SFSB的特别说明之外，有状态回话bean(SFSB)和SLSB一样精简：

　　·一个SFSB应该有一个方法来初始化自己（在EJB2.1中是通过ejbCreate()来实现的）。在EJB3.0的规范中建议这些初始化操作可以通过自定义方法完成，并把他们暴露在业务接口中。在使用这个bean之前由客户端来调用相应的初始化方法。目前规范组织就是否提供一个注释来标记某个方法用于初始化还存在争议。

　　·Bean的提供者可以用@Remove注释来标记任何SFSB的方法，以说明这个方法被调用之后bean的实例将被移除。同样，规范组织仍然在讨论是否要有一种机制来处理这种特殊的情况，即当这个方法出现异常的情况下bean的实例是否被移除。

　　下面是对以上问题我个人的观点：

　　·是否应该有一个注释来标明一个方法进行初始化呢？我的观点是——应该有，这样容器就可以在调用其他方法之前至少调用一个方法来进行初始化。这不仅可以避免不必要的错误(由于没有调用初始化方法)而且可以使容器更明确的判断是否可以重用SFSB实例。我暂且把这个问题放一放，规范组织只考虑为一个方法提供一个注释来声明它是一个初始化方法。

　　·对于第二个问题我的观点也是肯定的。这有利于Bean的提供者合客户端程序对其进行控制。只有一个遗留的问题：那就是一旦调用这个方法失败，是否能移除这个bean 的实例？答案是不能，但是它将会在回话结束的时候被移除。

消息驱动Bean

　　消息驱动Bean是唯一一种必须实现一个业务接口的Bean。这个接口指出bean支持的是哪一种消息系统。对于以JMS为基础的MDB来说，这个接口是 Javax.jms.MessageListener。注意MDB业务接口不是一个真正意义上的业务接口，它只是一个消息接口。

　　实体Bean

　　·实体Bean使用@Entity注释来标记，所有实体bean中的属性/字段不必使用@Transient注释来标记。实体bean的持久化字段可以通过JavaBean-style机制或者声明为public/protected字段来实现。

　　·实体bean可以使用助手类来描述其状态，但是这些类的实例并没有持久化唯一性（persistent identity）的特性(即，唯一标识这个bean的字段等)，实际上这些助手类与他们的实体bean实例是紧密结合的；并且这些对象还是以非共享方式来访问实体对象的。

　　实体关联

　　EJB3.0同时支持Bean之间双向的合单向的关联，它们可以是一对一、一对多、多对一或者是多对多的关联。然而双向关联的两端还要分为自身端（owning side）和对方端（inverse side）不同的端。自身端负责向数据库通告关联的变更。对于多对多的关联自身端必须明确的声明。实际上对方端通过isInverse=true进行注释（由此自身端就不必说明了而是由另一段推断出）。看来上面的描述，规范组织还能说让EJB变的简单了吗？

　　O/R映射

　　EJB3.0 中的O/R映射模型也有了重要的改变，它从原来的abstract-persistence-schema-based变成了现在的Hibernate- inspired模式。尽管目前规范组织还在就此进行讨论但是一个明确的模型将会出现在下一个版本的草案中。

　　举例来说，O/R映射模型将通过bean类中的注释来声明。而且此方法还会指出对应的具体表和字段。O/R映射模型提供了一套自有的SQL；而且除了提供一些基本的SQL外还支持某些高层开发的功能。比如，有一个通过@Column注释声明的字段columnDefinition，那么可以写这样的SQL： columnDefinition="BLOB NOT NULL"

　　客户端程序模型

　　一个EJB客户端可以通过 @Inject注释以一种“注入”的方式获得一个bean的业务接口引用。你也可以使用另一个注释 @javax.ejb.EJBContext.lookup()来完成上面的操作，但是规范中没有告诉我们一个普通的Java客户端怎样获得一个Bean 的实例，因为这个普通的Java客户端是运行在一个客户端容器中，它无法访问@javax.ejb.EJBContex对象。现在还有另外一种机制来完成上面的工作那就是使用一个超级上下文环境对象：@javax.ejb.Context()。但是规范中没有指出该如何在客户端中使用这个对象。

　　EJB QL

　　EJB QL可以通过@NamedQuery来注释。这个注释有两个成员属性分别是name和queryString.一旦定义了这些属性，就可以通过 EntityManager.createNamedQuery(name)来指向这个查询。你也可以创建一个标准的JDBC风格的查询并使用 EntityManager.createQuery(ejbqlString)或EntityManager.createNativeQuery (nativeSqlString)(这个方法用于执行一个本地查询)来执行查询。

　　EJB QL有两个地方可以定义其参数。javax.ejb.Query接口提供了定义参数、指向查询、更新数据等等方法。下面是一个EJBQL指向查询的例子：

.. ..
@NamedQuery(
name="findAllCustomersWithName",
queryString="SELECT c FROM Customer c WHERE c.name LIKE :custName"
)
.. ..
@Inject public EntityManager em;
customers = em.createNamedQuery("findAllCustomersWithName")
.setParameter("custName", "Smith")
.listResults();

　　下面列出了一些EJB QL的增强特性：

　　·支持批量更新和删除。

　　·直接支持内连接和外连接。FETCH JOIN运行你指出关联的实体，Order可以指定只查询某个字段。

　　·查询语句可以返回一个以上的结果值。实际上，你可以返回一个依赖的类比如下面这样：

SELECT new CustomerDetails(c.id, c.status, o.count)
FROM Customer c JOIN c.orders o
WHERE o.count > 100
　　·支持group by 和having。

　　·支持where子句的嵌套子查询。

　　在提交的EJB3.0草案中，EJB QL与标准SQL非常的接近。实际上规范中甚至直接支持本地的SQL(就像我们上面提到的那样)。这一点对某些程序员来说也许有些不是很清楚，我们将在下面进行更详细的讲解。

　　多样性

　　方法许可(Method permissions)可以通过@MethodPermissions或@Unchecked注释来声明；同样的，事务属性也可以通过 @TransactionAttribute注释来声明。规范中仍然保留资源引用和资源环境引用。这些一样可以通过注释来声明，但是有一些细微的差别。比如，上下文(context)环境要通过注入工具控制。容器根据bean对外部环境引用自动初始化一个适当的已经声明的实例变量。比如，你可以象下面这样获得一个数据源（DataSource）：

@Resource(name="myDataSource") //Type is inferred from variable
public DataSource customerDB;
　　在上面的例子中如果你不指定引用资源的名称(name)那么其中的customerDB会被认为是默认值。当所有的引用属性都可得到时，@Injec注释就可以这样写：

@Inject public DataSource customerDB;
　　容器负责在运行时初始化customerDB数据源实例。部署人员必须在此之前在容器中定义好这些资源属性。

　　更好的消息是：那些以前必须检测的异常将一去不复返。你可以声明任意的应用程序异常，而不必在再抛出或捕获其他类似CreateException和 FinderException这样的异常。容器会抛出封装在javax.ejb.EJBException中的系统级异常或者只在必要时候抛出 IllegalArgumentException或IllegalStateException异常。

EJB文件处理模式

　　在我们结束本节之前，让我的快速的浏览一下容器提供商在EJB处理模式方面可能的变更。规范中对此并没有明确的表态，但我可以想到至少两种模式。

　　·一种办法是首先利用EJB文件生成类似于EJB2.1部署模式的文件（包括必要的接口和部署描述符）然后再用类似于EJB2.1的方式来部署这个EJB组件。当然，这样产生的部署描述符可能并不标准但是它可以解决同一个容器对EJB2.1和EJB3.0兼容的问题。

　　·另一种方法是一种类似于JSP托放的部署模式。你可以把一个EJB文件放到一个预先定义的目录下，然后容器会识别这个EJB并处理它，然后部署并使之可以使用。这种方法可以建立于上面那种方法之上，在支持反复部署时有很大的帮助。考虑到部署的简单性也是EJB3.0规范的目的之一，我真诚的希望在下一个草案出来时能够确定一个模式(至少能有一个非正式的)。

　　你有什么想法？

　　EJB3.0规范的制定正在有序的进行，为了使 EJB的开发变得更加容易，EJB规范组织作出的努力是有目共睹的。就像他们说的那样，一切对会变得简单，但做到这一点并不容易。目前已经定义了50个注释标记(还有几个将在下一个草案中发布)，每一个都有自己的缺省规则和其他的操作。当然，我真的不希望EJB3.0变成EJB2.1的一个翻版"EJB 3.0 = EJB 2.1 for dummies"（希望这个等式不要成立）。最后，我还是忍不住要提一些我自己的观点：

　　·首先，规范确实使反复部署变得容易了，并且有一个简单的模式来访问运行时环境。我还是觉得home接口应该放弃。

　　·在早期的EJB规范中，实体bean用于映射一个持久化存储。理论上(也许只是理论上)可能需要把实体bean映射到一个遗留的EIS (entERPrise information system)系统中。出于将来扩展的考虑这样作是有好处的，并且可以使更多的业务数据模型采用实体bean。也因此其伴随的复杂性使得实体bean不被看好。在本次提交的草案中，一个实体bean只是一个数据库的映射。并且是基于非抽象持久化模式和简单的数据访问模式的更加简单开发。

　　·我对模型变更持保留态度，我认为在EJB中包含SQL脚本片断并不是个好注意。一些开发人员完全反对包含某些“SQL片段（SQLness）”（比如 @Table 和 @Column注释）。我的观点是这些SQLness是好的，据此我们可以清楚的知道我们到底要数据库作些什么。但是某些SQL段我看来并不是很好，比如 columnDefinition="BLOB NOT NULL"，这使得EJB代码和SQL之间的耦合太过紧密了。

　　·尽管对于本地SQL的支持看似很诱人，其实在EJB代码中嵌入SQL是一个非常糟糕的主意。当然，有些办法可以避免在EJB中硬编码SQL，但是这应该在规范中说明，而不能是某些开发人员自己定义的模式。

　　·假设@Table注释只用于类。在运行时通过@Table注释的name属性定义的表名称将必须对应一个实际的数据库表。规范对此应该给予清楚的说明和一致的模式。

　　·规范还需要更清楚的说明客户端编程模型，尤其是普通Java客户端。规范中所有的参考都假设或者隐含的使用EJB客户端。而且规范中对客户端的向后兼容方面也没有给出明确的说法。

　　·Transient注释应该重新命名以避免和已有的transient关键字发生冲突。事实上，在这一点上我们更乐于稍微的背离一下 configuration-by-exception原则并且定义一个@Persistent注释来明确的定义持久化字段。@Persistent注释可以仅仅是一个标记注释或者它可以有几个属性来关联O/R映射注释。

　　与其他规范的关联

　　目前可能影响到EJB3.0的JSR有JSR175（java语言元数据工具）和JSR181（Java Web服务元数据）

　　JSR175已经初步完成并且不会和EJB3.0有太大的冲突；但是JSR181与EJB3.0有两个关联的地方：

　　·Web Service接口：EJB规范将采用一种机制适应JSR181以便可以把一个bean实现为一个Web service并告诉Web service如何被客户端调用。

　　·JSR 181计划采用不同的机制来处理安全问题。在早期的规范中EJB建议使用一个一致的机制（MethodPermissions），但是JSR 181计划使用一个稍微不同的方式（SecurityRoles和SecurityIdentity注释）。同样的RunAs注释的定义也存在这些许差别。这一问题还在解决中最终会在J2EE层的规范中维持其一致性。

　　在J2EE 1.5中的一些开发规范可能与EJB3.0有关联。除了上面说到的几个关联之外现在没有其他的开发规范与EJB3.0有冲突。

　　结束语

　　在使EJB的开发变得简单高效之前，我们还有很长一段路要走。规范组织在降低EJB的开发难度方面起了个好头。O/R映射模型的提议还处在早期阶段，规范组织正在完善它。我希望它不要太复杂也不要与SQL过分的耦合。让我们不要只是停留在期望、希望、思考和请求中：提出你的想法并把你的建议发送给规范组织 ejb3-feedback@sun.com。JCP并不是很民主的组织，但是你的建议一定是有价值的。

semovy 2007-09-07 16:00 发表评论

EJB3.0入门

semovy — Sun, 02 Sep 2007 14:04:00 GMT

EJB3.0规范使开发EJB比过去更容易，可能诱惑你考虑开发第一个EJB。如果真是这种情况，那么祝贺你，
你经成功避免了在你以前EJB开发者的很多挫折，并且享受到EJB3.0开发的便利性。但是你开始开发以前，
你可能想知道EJB是什么和它们用于什么目的。本篇文章解释了EJB的基础和你如何在一个J2EE程序中使用
它们。

什么是EJB？

一个企业JavaBean (EJB)是一个可重用的，可移植的J2EE组件。 EJB由封装了业务逻辑的多个方法组成。
例如，一个EJB可以有包括一个更新客户数据库中数据的方法的业务逻辑。多个远程和本地客户端可以调用这
个方法。另外，EJB运行在一个容器里，允许开发者只关注与bean中的业务逻辑而不用考虑象事务支持，安全
性和远程对象访问等复杂和容易出错的事情。EJB以POJO或者普通旧的Java对象形式开发，开发者可以用元数
据注释来定义容器如何管理这些Bean。

EJB类型

EJB主要有三种类型：会话Bean，实体Bean和消息驱动Bean。会话Bean完成一个清晰的解耦的任务，例如
检查客户账户历史记录。实体Bean是一个代表存在于数据库中业务对象的复杂业务实体。消息驱动Bean用于
接收异步JMS消息。让我们更详细的认识这些类型。

会话Bean

会话Bean一般代表着业务流程中象"处理订单"这样的动作。会话Bean基于是否维护过度状态分为有状
态或者无状态。
无状态会话Bean 没有中间状态。它们不保持追踪一个方法调用另一个方法传递的信息。因此一个无状
态业务方法的每一次调用都独立于它的前一个调用；例如，税费计算或者转移账款。当计算税费额的方法被
调用时，税费值被计算并返回给调用的方法，没有必要存储调用者为将来调用备用的内部状态。因为它们不
维护状态，所以这些Bean是仅仅由容器管理。当客户端请求一个无状态的Bean实例时，它可以接收来自由容器管理的无状态会话Bean实例集中的一个实例。也因为无状态会话Bean能够被共享，所以容器可以维护更少
数量的实例来为大量的客户端服务。简单地象该Bean增加元注释@Stateless 来指定一个 Java Bean作为一个
无状态会话Bean被部署和管理。
一个有状态的会话Bean维护一个跨越多个方法调用的会话状态；例如在线购物篮应用。当客户开始在线
购物时，客户的详细信息从数据库获得。相同的信息对于当客户从购物篮中增加或者移除商品等等操作时被调用的其他方法也是可访问的。但是因为该状态不是在会话结束，系统崩溃或者网络失败时保留，所以有状
态会话Bean是暂时的。当一个客户端请求一个有状态会话Bean实例时，客户端将会得到一个会话实例，该Bean的状态只为给客户端维持。通过向方法增加元注释@Remove来告诉容器当某个方法调用结束一个有状态
会话Bean实例应该被移除。

会话Bean实例

import javax.ejb.Stateless.*;

/** * 一个简单无状态会话Bean实现了CalculateEJB接口的incrementValue()方法**/ @Stateless(name="CalculateEJB") public class CalculateEJBBean implements CalculateEJB { int value = 0; public String incrementValue() { value++; return "value incremented by 1"; } }

实体Bean

实体Bean是管理持久化数据的一个对象，潜在使用一些相关的Java对象并且可以依靠主键被唯一识别。通
过包括@Entity 元注释来指定一个类是一个实体Bean。实体Bean表示来自数据库的持久化数据，例如客户表
中的一个记录，或者一个员工表中的一个员工记录。实体Bean也可以被多个客户端共享。例如一个员工实体
能够被多个计算一个员工每年工资总额或者更新员工地址的客户端使用。实体Bean对象特定变量能够保持持
久化。实体Bean中所有没有@Transient 元注释的变量需要考虑持久化。EJB3.0的一个主要特色是创建包含使用元数据注释的对象/关系映射实体Bean的能力。例如，指定实体Bean的empId变量映射到employee表中的
EMPNO属性，象下面实例中一样用@Table(name="Employees") 注释这个表的名字和用@Column
(name="EMPNO")注释empId变量。另外，EJB3.0中的一个特色是你可以很容易的在开发时测试实体
Bean，可以用Oracle Application Server Entity Test Harness在容器外部运行一个实体Bean。

实体Bean实例

import javax.persistence.*; import java.util.ArrayList; import java.util.Collection;

@Entity @Table(name = "EMPLOYEES") public class Employee implements java.io.Serializable { private int empId; private String eName; private double sal; @Id @Column(name="EMPNO", primaryKey=true) public int getEmpId(){ return empId;}

public void setEmpId(int empId) { this.empId = empId; }

public String getEname() { return eName; }

public void setEname(String eName) { this.eName = eName; } public double getSal() { return sal; }

public void setSal(double sal) { this.sal = sal; } public String toString() { StringBuffer buf = new StringBuffer(); buf.append("Class:") .append(this.getClass().getName()).append(" :: ").append(" empId:").append(getEmpId()).append(" ename:").append(getEname()).append("sal:").append(getSal()); return buf.toString(); } }

消息驱动Bean

驱动Bean (MDB) 提供了一个实现异步通信比直接使用Java消息服务（JMS）更容易地方法。创建MDB接
收异步JMS消息。容器处理为JMS队列和主题所要求加载处理的大部分工作。它向相关的MDB发送所有的消
息。一个MDB允许J2EE应用发送异步消息，该应用能处理这些消息。实现javax.jms.
MessageListener接口和使用@MessageDriven注释该Bean来指定一个Bean是消息驱动Bean。

消息驱动Bean实例

import javax.ejb.MessageDriven; import javax.ejb.ActivationConfigProperty; import javax.ejb.Inject; import javax.jms.*; import java.util.*; import javax.ejb.TimedObject; import javax.ejb.Timer; import javax.ejb.TimerService; @MessageDriven( activationConfig = { @ActivationConfigProperty(propertyName="connectionFactoryJndiName", propertyValue="jms/TopicConnectionFactory"), @ActivationConfigProperty(propertyName="destinationName", propertyValue="jms/myTopic"), @ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Topic"), @ActivationConfigProperty(propertyName="messageSelector", propertyValue="RECIPIENT = 'MDB'")
} )

/** *监听可配置JMS队列或者主题和通过当一个消息发送到队列或者主题 *调用它的onMessage()方法得到提醒的一个简单的消息驱动 *该Bean打印消息的内容*/

public class MessageLogger implements MessageListener, TimedObject {

@Inject javax.ejb.MessageDrivenContext mc; public void onMessage(Message message) { System.out.println("onMessage() - " + message); try{String subject = message.getStringProperty("subject"); String inmessage = message.getStringProperty("message"); System.out.println("Message received\n\tDate: " + new java.util.Date() + "\n\tSubject: " + subject + "\n\tMessage: " + inmessage + "\n"); System.out.println("Creating Timer a single event timer"); TimerService ts = mc.getTimerService(); Timer timer = ts.createTimer(30000, subject); System.out.println("Timer created by MDB at: " + new Date(System.currentTimeMillis()) +" with info: "+subject); } catch (Throwable ex) { ex.printStackTrace(); } }public void ejbTimeout(Timer timer) { System.out.println("EJB 3.0: Timer with MDB");System.out.println("ejbTimeout() called at: " + new Date(System.currentTimeMillis()));return; }}

使用EJB

客户端是访问Bean的应用程序。虽然没有必要保存在客户层，但是能够作为一个独立的应用，JSP，
Servlet，或者另一个EJB。客户端通过Bean的远程或者本地接口访问EJB中的方法，主要取决于客户端和Bean
运行在同一个还是不同的JVM中。这些接口定义了Bean中的方法，而由Bean类实际实现这些方法。当一个
客户端访问该Bean类中的一个方法时，容器生成Bean的一个代理，被叫做远程对象或者本地对象。远程或者
本地对象接收请求，委派它到相应的Bean实例，返回结果给客户端。调用一个Bean中的方法，客户端使用定
义在EJB不是描述文件的名字查找到Bean。在以下实例中，客户端使用上下文对象找到命名为"StateLessejb"
Bean。

EJB 客户端实例

import javax.naming.Context; import javax.naming.InitialContext;

/** * 一个调用无状态会话Bean中方法的简单的Bean客户端 */

public class CalculateejbClient { public static void main(String [] args) { Context context = new InitialContext();
CalculateEJB myejb = (CalculateEJB)context.lookup("java:comp/env/ejb/CalculateEJB"); myejb.incrementValue(); } }

总结

EJB3.0开发企业JavaBean是相当容易的。此规范使用元数据注释定义Bean的类型和暴露给客户端的方法。
因此，无论你将创建一个执行特定任务的会话Bean还是映射一个表到实体Bean来更新数据，你都能象使用普
通Java对象和接口一样进行处理，在业务方法中使用元注释向客户端暴露方法。既然你已经理解了EJB的基础,
可以到OTN中EJB 3.0 Resources Page发现更多信息。

semovy 2007-09-02 22:04 发表评论