Hibernate 注解对Hibernate属性（CascadeType、JoinColumn、JoinTable、ForeignKey等）的研究 对Hibernate属性（CascadeType、JoinColumn、JoinTable、ForeignKey等）的研究

企业开发 2018-05-13 09:12:45 阅读次数: 0

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

Spring，FetchType.LAZY和FetchType.EAGER什么区别？

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

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

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

CascadeType.PERSIST：级联新增 

CascadeType.MERGE:级联合并 

CascadeType.REFRESH:级联刷新 

CascadeType.REMOVE:级联删除 

CascadeType.ALL:以上四种都是 


 
 


  
  

对Hibernate属性（CascadeType、JoinColumn、JoinTable、ForeignKey等）的研究



  
  

  
  


   
   Hibernate
   
   JDBC
   
   EJB
   
   JBoss
   
   企业应用 
  
  


 
 

 
 


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


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


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


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. @Entity(name="Transformer")  
    2. 

    
    
  2. @Table(name="k_transformer")  
    3. 

    
    
  3. public class Transformer implements Serializable{  
    4. 

    
    
  4.       
    5. 

    
    
  5.     private Long id;  
    6. 

    
    
  6.     private UserCard userCard;  
    7. 

    
    
  7.     @Column  
    8. 

    
    
  8.     @Id  
    9. 

    
    
  9.     @GeneratedValue  
    10. 

    
    
  10.     public Long getId() {  
    11. 

    
    
  11.         return id;  
    12. 

    
    
  12.     }  
    13. 

    
    
  13.     public void setId(Long id) {  
    14. 

    
    
  14.         this.id = id;  
    15. 

    
    
  15.     }  
    16. 

    
    
  16.     @OneToOne(  
    17. 

    
    
  17.         targetEntity = com.home.po.UserCard.class,   
    18. 

    
    
  18.             <strong><span style="color: #ff0000;"><em>fetch = FetchType.LAZY</em></span></strong>,   
    19. 

    
    
  19.             cascade = { CascadeType.ALL })  
    20. 

    
    
  20.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )             
    21. 

    
    
  21.     @JoinColumn(name = "UserCard_id")  
    22. 

    
    
  22.     @ForeignKey(name = "TRANSFORMER_TO_USERCARD_FK")   
    23. 

    
    
  23.     public UserCard getUserCard() {  
    24. 

    
    
  24.         return userCard;  
    25. 

    
    
  25.     }  
    26. 

    
    
  26.     public void setUserCard(UserCard userCard) {  
    27. 

    
    
  27.         this.userCard = userCard;  
    28. 

    
    
  28.     }  
    29. 

    
    
  29. }  
    30. 

   
   


  
  


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


  
  
 添加一个HibernateTest Session Bean，如下：


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. public interface TransformerService {  
    2. 

    
    
  2.     public void persist(Transformer t);  
    3. 

    
    
  3.     public void analysis(Long id);  
    4. 

    
    
  4.     public Transformer analysisRemote(Long id);  
    5. 

    
    
  5. }  
    6. 

   
   


  
  


  
  
 


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. public interface TransformerServiceLocal extends TransformerService {  
    2. 

    
    
  2. }  
    3. 

   
   


  
  


  
  
 


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. @Stateless  
    2. 

    
    
  2. @Remote(TransformerService.class)  
    3. 

    
    
  3. @Local(TransformerServiceLocal.class)  
    4. 

    
    
  4. public class TransformerServiceSession implements TransformerServiceLocal {  
    5. 

    
    
  5.       
    6. 

    
    
  6.     @PersistenceContext(unitName="com.home.po")   
    7. 

    
    
  7.     protected EntityManager em;  
    8. 

    
    
  8.   
    9. 

    
    
  9.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
    10. 

    
    
  10.     public void persist(Transformer t) {  
    11. 

    
    
  11.         em.persist(t);  
    12. 

    
    
  12.     }  
    13. 

    
    
  13.   
    14. 

    
    
  14.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
    15. 

    
    
  15.     public void analysis(Long id) {  
    16. 

    
    
  16.         Transformer t = em.find(Transformer.class, id);  
    17. 

    
    
  17.         analysisEntity(t);  
    18. 

    
    
  18.     }  
    19. 

    
    
  19.   
    20. 

    
    
  20.     <span style="color: #000000;">private void analysisEntity(Transformer t) {  
    21. 

    
    
  21.         System.out.println(t.getUserCard());  
    22. 

    
    
  22.     }</span>  
    23. 

    
    
  23.   
    24. 

    
    
  24.     @TransactionAttribute(TransactionAttributeType.REQUIRED)  
    25. 

    
    
  25.     public Transformer analysisRemote(Long id) {  
    26. 

    
    
  26.         return em.find(Transformer.class, id);  
    27. 

    
    
  27.     }  
    28. 

    
    
  28.   
    29. 

    
    
  29. }  
    30. 

   
   


  
  


  
  
 


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


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. public void analysis() throws NamingException {  
    2. 

    
    
  2.        ……  
    3. 

    
    
  3.       TransformerService service = (TransformerService) ctx.lookup("home-test-all/TransformerServiceSession/remote");  
    4. 

    
    
  4.         service.analysis(new Long(1));  
    5. 

    
    
  5.         Transformer tra = service.analysisRemote(new Long(1));  
    6. 

    
    
  6.         analysisEntityInRemote(tra);  
    7. 

    
    
  7. }  
    8. 

    
    
  8.       
    9. 

    
    
  9. <span style="color: #000000;">private void analysisEntityInRemote(Transformer t) {  
    10. 

    
    
  10.         System.out.println(t.getUserCard());  
    11. 

    
    
  11. }</span>  
    12. 

   
   


  
  


  
  
  注意上述加红倾斜的代码段描述的方法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. 

    
    
  2.     at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:62)  
    3. 

    
    
  3.     at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:116)  
    4. 

    
    
  4.     at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:166)  
    5. 

    
    
  5.     at com.home.po.UserCard_$$_javassist_0.toString(UserCard_$$_javassist_0.java)  
    6. 

    
    
  6.     at java.lang.String.valueOf(Unknown Source)  
    7. 

    
    
  7.     at java.io.PrintStream.println(Unknown Source)  
    8. 

    
    
  8.     at com.home.ear.test.HibernateTestClient.analysisEntityInRemote(HibernateTestClient.java:41)  
    9. 

    
    
  9.     at com.home.ear.test.HibernateTestClient.analysis(HibernateTestClient.java:37)  
    10. 

    
    
  10.     at com.home.ear.test.HibernateTestClient.main(HibernateTestClient.java:47)  
    11. 

   
   


  
  


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


  
  
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. 

    
    
  2.     targetEntity=com.home.po.Friend.class,  
    3. 

    
    
  3.     fetch=FetchType.LAZY,  
    4. 

    
    
  4.     cascade = { CascadeType.ALL })  
    5. 

    
    
  5.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
    6. 

    
    
  6.     @JoinColumn(name="userId")    
    7. 

    
    
  7.     @ForeignKey(name="USER_TO_FRIEND_FK")  
    8. 

    
    
  8. public List<Friend> getFriends() {  
    9. 

    
    
  9.         return friends;  
    10. 

    
    
  10. }  
    11. 

   
   


  
  


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


  
  


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


  
  


   
   

    
    

     
     Java代码  
     
     收藏代码

    
    

   
   


   
   
    

    
    
  1. @OneToMany (  
    2. 

    
    
  2.              targetEntity=com.home.po.Friend.class,  
    3. 

    
    
  3.         fetch=FetchType.LAZY,  
    4. 

    
    
  4.         cascade = { CascadeType.ALL })  
    5. 

    
    
  5. @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
    6. 

    
    
  6. @JoinTable(name="k_user_friend",   
    7. 

    
    
  7.         joinColumns = @JoinColumn(name = "USER_ID"),   
    8. 

    
    
  8.         inverseJoinColumns = @JoinColumn(name = "FRIEND_ID"))  
    9. 

    
    
  9. @ForeignKey(name = "k_user_friend_FK",   
    10. 

    
    
  10.         inverseName = "k_user_friend_FK_R")  
    11. 

    
    
  11. public List<Friend> getFriends() {  
    12. 

    
    
  12.     return friends;  
    13. 

    
    
  13. }  
    14. 

   
   


  
  


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


  
  




  
  
 如上用直线标出的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. 

    
    
  2.     targetEntity=com.home.po.Friend.class,  
    3. 

    
    
  3.     fetch=FetchType.LAZY,  
    4. 

    
    
  4.     cascade = { CascadeType.ALL })  
    5. 

    
    
  5.     @Cascade( { org.hibernate.annotations.CascadeType.ALL } )   
    6. 

    
    
  6.     @JoinColumn(name="userId")    
    7. 

    
    
  7. public List<Friend> getFriends() {  
    8. 

    
    
  8.         return friends;  
    9. 

    
    
  9. }  
    10. 

   
   


  
  


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


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


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


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


  
  


 

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


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


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


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


  
  
 


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


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

本文列出几个“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%

 

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

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

猜你喜欢

转载自guobin6125.iteye.com/blog/1596793
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022