EJB3 映射的学习

   这次简单小结的是实体bean的做法
1 、配置JBOSS数据源
 * 从目录JBOSS_HOME\docs\examples\jca下找到相应的数据库数据源配置的模版文件,如mysql-ds.xml
 * 拷贝模版文件到JBOSS_HOME\server\default\deploy目录下
 * 修改其中的用户名、密码、数据库主机、数据库名称等等属性
 * 拷贝数据库驱动到server\default\lib下
2、在META-INF目录下创建persistence.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<persistence>
   <persistence-unit name="test">
      <jta-data-source>java:/MySqlDS</jta-data-source>
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
          <property name="hibernate.hbm2ddl.auto" value="create"/>
      </properties>
   </persistence-unit>
</persistence>

3 之后可以开始写bean了
       下面列出相关的注意要点:

    @Entity
@Table(name="T_User")
public class User implements Serializable{
 
 /**
  * 在缺省情况下，使用GeneratedValue，默认的生成策略是hibernate的native生成策略
  */
 @Id
 @GeneratedValue
 private int id;

 

/**
  * 可以将ID的生成策略定义为UUID，这时候，ID的生成策略将跟hibernate绑定
  */
 @Id
 @GeneratedValue(generator="hibernateuuidgenerator")
 @GenericGenerator(name="hibernateuuidgenerator",strategy="uuid")
 private String id;

 

   很典型的使用模式

@Stateless(name="UserManager")
@Remote

public class UserManagerImpl implements UserMananger {

 /**
  * 注入实体管理器对象
  */
 @PersistenceContext(unitName="test")
 private EntityManager em;
 
 public void addUser(User user) {
  
  //使用EntityManager的persist方法，将数据持久化到数据库
  em.persist(user);

 

}

   其中@PersistenceContext(unitName="test")

中的unitname就是persistence.xml中的指定的
  <?xml version="1.0" encoding="UTF-8"?>
<persistence>
   <persistence-unit name="test">
      <jta-data-source>java:/MySqlDS</jta-data-source>
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
          <property name="hibernate.hbm2ddl.auto" value="create"/>
      </properties>
   </persistence-unit>
</persistence>     

 

4 一对多的关系/多对一关系

 

 

A   再来看单向的多对一关系如何:
    所谓单向的多对一,即只能从多的一方去找到一的一方,"一"的一方不负责任何东西,是简单的POJO,比如
  下面的例子:
   @Entity
public class Company {
 
 @Id
 private int id;
 private String name;
 
}
   @Entity
public class Employee {
 
 @Id
 private int id;
 private String name;
 
 @ManyToOne
 @JoinColumn(name="cid")
 private Company company;
}

joincolumn表明它们通过cid来关联的,就是在empolee表中,最后会有字段cid,去 做外键关联company表的id字段.
   这种单向的多对一关系的话,比如:
      Employee e=new Employee();

      .......

      Company c=new Company();

       ........

       e.setCompany(c);

    默认情况下,会在加载employee的时候也把company加载,但有时会遇到性能上的问题,比如要输出这个员工的所在公司时,会这样输出:
      e.getCompany().getComapnyname();

    一般希望在这个时候才加载company对象,要这样的话,必须要加lazy=true属性,如在empolyee类中,
   @ManyToOne(cascade={CascadeType.All},fetch=FetchType.Lazy)
 @JoinColumn(name="cid")
 private Company company;

  B   单向的一对多关系
      比如category和book的关系,多的一方book是纯的POJO了,category可以找到book,但book类无法获得categroy的 信息
   比如category.java里
      @OneToMany(cascade={CascadeType.ALL})
      @JoinColumn(name="category")
        private Set<book> booksTables = new HashSet<book>;
      使用时:
    book p=new book();
 p.setName("asp.net");   
   p.setPublisher("tsinghua");
   p.setPrice(new Double(12.7));
   Category cat=new Category();
   cat.setName("pc");
   cat.setDescription("computer book");
    cat.getBooksTables().add(p);

 则加载category时,会把对应的所有book对象也加载出来，因此效率不高.

 

C  双向的一对多关系:

     即一的一方有set,多的一方持有一的一方的对象
    @Entity
public class Classes1 {
 
 @Id
 private int id;
 private String cname;
 //双向一对多
 @OneToMany(mappedBy="classes1")
 private Set<Student1> student1s;
}

 

@Entity
public class Student1 {
 
 @Id
 private int id;
 private String name;
 
 @ManyToOne
@JoinColumn(name="class1")
 private Classes1 classes1;
 
}

   注意,和hibernate中的类似,用了mappedby的一方,是关联中的被动地位,主动的是student1来的.

  调用时:
    book p=new book();
  p.setName("asp.net");   
  p.setPublisher("tsinghua");
  p.setPrice(new Double(12.7));
   Category cat=new Category();
 cat.setName("pc");
   cat.setDescription("computer book");
   p.setCategoryTable(cat); 

 即可，注意关联是在多的主动一方发起来持久化的.

 

5 双向多对多关系
    @Entity
public class Role {
 
 @Id
 private int id;
 private String name;
 
 @ManyToMany
 @JoinTable(name="T_Role_Staff")
 private Set<Staff> staffs;
}

 

 

@Entity
public class Staff {
 
 @Id
 private int id;
 private String name;
 
 @ManyToMany(mappedBy="staffs")
 private Set<Role> roles;
}

  调用,上面的jointable是主动方,持久化时必须由主动方维护,所以
      Role  r=new Role();

      xxxxxxx

    Staff s=new Staff();

     xxxxxxx

    r.getStaffs().add(s);