Hibernate 注解对Hibernate属性(CascadeType、JoinColumn、JoinTable、ForeignKey等)的研究...

----------------------------------

Spring,FetchType.LAZY和FetchType.EAGER什么区别?

FetchType.LAZY:懒加载,加载一个实体时,定义懒加载的属性不会马上从数据库中加载。

2、FetchType.EAGER:急加载,加载一个实体时,定义急加载的属性会立即从数据库中加载。

3、比方User类有两个属性,name跟address,就像百度知道,登录后用户名是需要显示出来的,此属性用到的几率极大,要马上到数据库查,用急加载;而用户地址大多数情况下不需要显示出来,只有在查看用户资料是才需要显示,需要用了才查数据库,用懒加载就好了。所以,并不是一登录就把用户的所有资料都加载到对象中,于是有了这两种加载模式。
------------------------------------------------------------------------------

CascadeType.PERSIST:级联新增 

CascadeType.MERGE:级联合并 

CascadeType.REFRESH:级联刷新 

CascadeType.REMOVE:级联删除 

CascadeType.ALL:以上四种都是 

 
 

本文列出几个“EJB 学习阶段总结:JBoss下发布一个Toy企业应用”开发测试过程中遇到的几个问题。

1. Hibernate 懒加载有一定局限性:EJB远程调运时Hibernate懒加载Session失效

通过实例说明:给Entity类中添加Transformer类,Transformer与UserCard存在一对一的单向关联,如下:

Java代码   收藏代码
  1. @Entity(name="Transformer")  
  2. @Table(name="k_transformer")  
  3. public class Transformer implements Serializable{  
  4.       
  5.     private Long id;  
  6.     private UserCard userCard;  
  7.     @Column  
  8.     @Id  
  9.     @GeneratedValue  
  10.     public Long getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(Long id) {  
  14.         this.id = id;  
  15.     }  
  16.     @OneToOne(  
  17.         targetEntity = com.home.po.UserCard.class,   
  18.             <strong><span style="color: #ff0000;"><em>fetch = FetchType.LAZY</em></span></strong>,   
  19.             cascade = { CascadeType.ALL })  
  20.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )             
  21.     @JoinColumn(name = "UserCard_id")  
  22.     @ForeignKey(name = "TRANSFORMER_TO_USERCARD_FK")   
  23.     public UserCard getUserCard() {  
  24.         return userCard;  
  25.     }  
  26.     public void setUserCard(UserCard userCard) {  
  27.         this.userCard = userCard;  
  28.     }  
  29. }  

注意OneToOne属性设定FetchType必须是LAZY,因为我们测试的是Hibernate懒加载

 添加一个HibernateTest Session Bean,如下:

Java代码   收藏代码
  1. public interface TransformerService {  
  2.     public void persist(Transformer t);  
  3.     public void analysis(Long id);  
  4.     public Transformer analysisRemote(Long id);  
  5. }  

 

Java代码   收藏代码
  1. public interface TransformerServiceLocal extends TransformerService {  
  2. }  

 

Java代码   收藏代码
  1. @Stateless  
  2. @Remote(TransformerService.class)  
  3. @Local(TransformerServiceLocal.class)  
  4. public class TransformerServiceSession implements TransformerServiceLocal {  
  5.       
  6.     @PersistenceContext(unitName="com.home.po")   
  7.     protected EntityManager em;  
  8.   
  9.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
  10.     public void persist(Transformer t) {  
  11.         em.persist(t);  
  12.     }  
  13.   
  14.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
  15.     public void analysis(Long id) {  
  16.         Transformer t = em.find(Transformer.class, id);  
  17.         analysisEntity(t);  
  18.     }  
  19.   
  20.     <span style="color: #000000;">private void analysisEntity(Transformer t) {  
  21.         System.out.println(t.getUserCard());  
  22.     }</span>  
  23.   
  24.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
  25.     public Transformer analysisRemote(Long id) {  
  26.         return em.find(Transformer.class, id);  
  27.     }  
  28.   
  29. }  

 

在客户端先向数据库中插入一条数据,在运行如下代码段:

Java代码   收藏代码
  1. public void analysis() throws NamingException {  
  2.        ……  
  3.       TransformerService service = (TransformerService) ctx.lookup("home-test-all/TransformerServiceSession/remote");  
  4.         service.analysis(new Long(1));  
  5.         Transformer tra = service.analysisRemote(new Long(1));  
  6.         analysisEntityInRemote(tra);  
  7. }  
  8.       
  9. <span style="color: #000000;">private void analysisEntityInRemote(Transformer t) {  
  10.         System.out.println(t.getUserCard());  
  11. }</span>  

  注意上述加红倾斜的代码段描述的方法analysisEntity,analysisEntityInRemote作用都是相同的,取出Transformer中UserCard属性,但是运行结果却如下,TransformerServiceSession 中的analysisEntity运行良好,Jboss Console控制台打印输出如下信息:  而Remote端Eclipse Console口抛出Session无效的异常:

Java代码   收藏代码
  1. Exception in thread "main" org.hibernate.LazyInitializationException: could not initialize proxy - no Session  
  2.     at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:62)  
  3.     at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:116)  
  4.     at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:166)  
  5.     at com.home.po.UserCard_$$_javassist_0.toString(UserCard_$$_javassist_0.java)  
  6.     at java.lang.String.valueOf(Unknown Source)  
  7.     at java.io.PrintStream.println(Unknown Source)  
  8.     at com.home.ear.test.HibernateTestClient.analysisEntityInRemote(HibernateTestClient.java:41)  
  9.     at com.home.ear.test.HibernateTestClient.analysis(HibernateTestClient.java:37)  
  10.     at com.home.ear.test.HibernateTestClient.main(HibernateTestClient.java:47)  

 具体原因,继续研究中……

2 hibernate.jdbc.batch_size与 hibernate.jdbc.fetch_size初始值大小对Hibernate工作效率的影响:

修改Persistence Entity EJB模块中persistence.xml中Properties属性可以改变hibernate.jdbc.batch_size与 hibernate.jdbc.fetch_size的值,我做了如下两组测试,如下:

如下一,改变hibernate.jdbc.batch_size的大小,插入1000条User连续三次,记录每次插入时间,并计算出三次平均时间:  如下二改变Change hibernate.jdbc.fetch_size大小,从数据库中取出2000条和4000条数据,记录取出时间,如下:  如上两组数据,可以得出结论,在这个应用中hibernate.jdbc.batch_size设置为20-30之间Hibernate工作效率最好;而hibernate.jdbc.fetch_size是值设置为40左右Hibernate的工作效率最好

 

3  比较@OneToMany下@JoinColumn和@JoinTable的差别(对性能的影响)

@JoinColumn不产生级联表,将一方的主键存放在另一方的表中,如下,为JoinColumn的Entity Bean配置

以User与Friend为例:

Java代码   收藏代码
  1. @OneToMany (  
  2.     targetEntity=com.home.po.Friend.class,  
  3.     fetch=FetchType.LAZY,  
  4.     cascade = { CascadeType.ALL })  
  5.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
  6.     @JoinColumn(name="userId")    
  7.     @ForeignKey(name="USER_TO_FRIEND_FK")  
  8. public List<Friend> getFriends() {  
  9.         return friends;  
  10. }  

 这种配置下 产生表如下图:

 @JoinTable产生级联表,将双方的主键存放在一张独立的表中,如下为@JoinTable的配置

Java代码   收藏代码
  1. @OneToMany (  
  2.              targetEntity=com.home.po.Friend.class,  
  3.         fetch=FetchType.LAZY,  
  4.         cascade = { CascadeType.ALL })  
  5. @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
  6. @JoinTable(name="k_user_friend",   
  7.         joinColumns = @JoinColumn(name = "USER_ID"),   
  8.         inverseJoinColumns = @JoinColumn(name = "FRIEND_ID"))  
  9. @ForeignKey(name = "k_user_friend_FK",   
  10.         inverseName = "k_user_friend_FK_R")  
  11. public List<Friend> getFriends() {  
  12.     return friends;  
  13. }  

 这种配置下 产生表如下图:

 如上用直线标出的5张表就是5对一对多关系产生的级联表,它里面存储两个表的主键。

这两种处理对数据的插入和存取有什么影响,就这一问题做如下测试:

      1  分别在两种配置下通过EJB向数据库中插入2000个User 5次,记录每次时间,求出平均时间;

      2  分别在两种配置下通过EJB从数据库中取出10000条数据5次,记录每次时间,求出平均时间;

结果如下两组图分别是JoinTable和JoinColumn下的测试数据

   从上图比较可以得出结论:

      1 JoinTable下操作数据库花费的时间要长于JolinColumn;

      2 JolinColumn下节省的时间约为JoinTable下的2.5%;

分析原因:JoinTable花费时间多的原因是JoinTable下生成的中间表,要存取数据时都要查询中间的级联表,所以花费时间多;

 

4 测试建立外键与不建立外键两种情况下对存取数据库的影响

如上面3中都是设置外键的情况下测试的,下面我们在JoinColumn下做一组不设置外键的测试,不设置外键Annotation相当简单就是在原来的基础上去掉@ForeignKey标记,如下

Java代码   收藏代码
  1. @OneToMany (  
  2.     targetEntity=com.home.po.Friend.class,  
  3.     fetch=FetchType.LAZY,  
  4.     cascade = { CascadeType.ALL })  
  5.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
  6.     @JoinColumn(name="userId")    
  7. public List<Friend> getFriends() {  
  8.         return friends;  
  9. }  

 为了对比我们假设两种情况,一是JolinColumn下配置ForeignKey,二是JolinColumn下不配置ForeignKey,在两种情况下做如下测试:

      1  分别在两种配置下通过EJB向数据库中插入2000个User 5次,记录每次时间,求出平均时间;

      2  分别在两种配置下通过EJB从数据库中取出10000条数据5次,记录每次时间,求出平均时间;

测试结果如下面两张表所示:

    从上面两组图我们可以得出如下结论:

      1 ForeignKey对数据库的存取影响比较大,特别是数据库的查询

      2 设置ForeignKey可以减少数据库存取的时间

      3 设置ForeignKey插入数据库节省的时间是不设置ForeignKey的5.5%,查询时则可以节省6.5%

 

--------------------------------------------------------------------------------------------------

说明:以上时间有一定局限性,只是在当前这种情况下测试的结果,不过可以当做参考。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值