Spring和Hibernate动态建表及动态加载映射文件（无需Session factory...

时间  2019-11-08
标签 spring hibernate 动态 加载 映射 文件 无需 session factory 栏目 Spring 繁體版
原文   原文链接

         J.Office2有一功能是工做流支持动态表单设计，设计后能够动态生成数据库表，而且支持实时查询（单表及多表都可）。java

 

         因为J.Office2版本中采用了Hibernate做为底层的ORM框架，结合Spring框架，Spring容器启动后，SessionFactory就会被注入到各个业务的Dao层中去。sql

 

        动态建表功能比较容易实现，咱们能够new一个SessionFactory,而后把它的配置属性hibernate.hbm2ddl.auto改成update或create，就能够达到动态修改表结构的效果。数据库

 

            但若要加入新的hbm或class，须要从新调用SessionFactoryBean来获取一个全新的SessionFactory，这种方案试过了， 效果并不理想。从新加载，会致使大量的hbm或class文件从新加载，实在有点慢。而且严重影响如今注入SessionFactory的Dao。若 Dao采用动态构建SessionFactory，性能又是一问题。而Hibernate没有提供SessionFactory动态加入hbm或 Class文件。因此实在机关用尽。session

 

      因此最终仍是回到如何扩展Hibernate的SessionFactory类中去了，这想法已经有很多开发人员尝试过，JE也有一帖子专门讨论这个。不 过仅是一Demo，不完善。咱们提供了两个扩展的类（修改Hibernate中的两类，使其支持动态加入配置文件，而且能实时查询。app

 

咱们仅须要修改两个类，一个是Configuration,在其里面加一方法，以下：框架

     public void doComplie(){
         secondPassCompile();
     }eclipse

 

     修改ide

 

在SessonFactoryImpl类中加入如下方法，（有一些变量值不能修改的，请改成可修改）post

 

Java代码   收藏代码
  1. //add by csx  
  2. public void addNewConfig(Configuration cfg){  
  3.     log.info("add NewConfig.....");  
  4.       
  5.     Mapping mapping=this.configuration.getMapping();  
  6.     this.filters.putAll( cfg.getFilterDefinitions() );  
  7.     //Generators:  
  8.     Iterator classes = cfg.getClassMappings();  
  9.     while ( classes.hasNext() ) {  
  10.         PersistentClass model = (PersistentClass) classes.next();  
  11.           
  12.         if ( !model.isInherited() ) {  
  13.             IdentifierGenerator generator = model.getIdentifier().createIdentifierGenerator(  
  14.                     settings.getDialect(),  
  15.                     settings.getDefaultCatalogName(),  
  16.                     settings.getDefaultSchemaName(),  
  17.                     (RootClass) model  
  18.                 );  
  19.             identifierGenerators.put( model.getEntityName(), generator );  
  20.         }  
  21.     }  
  22.   
  23.     ///////////////////////////////////////////////////////////////////////  
  24.     // Prepare persisters and link them up with their cache  
  25.     // region/access-strategy  
  26.   
  27.     String cacheRegionPrefix = settings.getCacheRegionPrefix() == null ? "" : settings.getCacheRegionPrefix() + ".";  
  28.       
  29.     Map entityAccessStrategies = new HashMap();  
  30.     Map tmpEntityPersisters=new HashMap();  
  31.     Map tmpClassMetadata=new HashMap();  
  32.       
  33.       
  34.     this.configuration.getClassMap().putAll(cfg.getClassMap());  
  35.     classes = cfg.getClassMappings();  
  36.   
  37.     while ( classes.hasNext() ) {  
  38.           
  39.         PersistentClass model = (PersistentClass) classes.next();  
  40.           
  41.         model.prepareTemporaryTables( mapping, settings.getDialect() );  
  42.         String cacheRegionName = cacheRegionPrefix + model.getRootClass().getCacheRegionName();  
  43.           
  44.         // cache region is defined by the root-class in the hierarchy...  
  45.         EntityRegionAccessStrategy accessStrategy = ( EntityRegionAccessStrategy ) entityAccessStrategies.get( cacheRegionName );  
  46.         if ( accessStrategy == null && settings.isSecondLevelCacheEnabled() ) {  
  47.             AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );  
  48.             if ( accessType != null ) {  
  49.                   
  50.                 log.trace( "Building cache for entity data [" + model.getEntityName() + "]" );  
  51.                 EntityRegion entityRegion = settings.getRegionFactory().buildEntityRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );  
  52.                 accessStrategy = entityRegion.buildAccessStrategy( accessType );  
  53.                 entityAccessStrategies.put( cacheRegionName, accessStrategy );  
  54.                 allCacheRegions.put( cacheRegionName, entityRegion );  
  55.             }  
  56.         }  
  57.         EntityPersister cp = PersisterFactory.createClassPersister( model, accessStrategy, this, cfg.getMapping() );  
  58.         tmpEntityPersisters.put( model.getEntityName(), cp );  
  59.         tmpClassMetadata.put( model.getEntityName(), cp.getClassMetadata() );  
  60.           
  61.     }  
  62.       
  63.     //Named Queries:  
  64.     namedQueries.putAll(cfg.getNamedQueries());  
  65.     namedSqlQueries.putAll( cfg.getNamedSQLQueries() );  
  66.     sqlResultSetMappings.putAll(cfg.getSqlResultSetMappings());  
  67.     imports.putAll(cfg.getImports());  
  68.   
  69.     entityPersisters.putAll(tmpEntityPersisters);  
  70.   
  71.     classMetadata.putAll(tmpClassMetadata);  
  72.       
  73.     Map tmpEntityToCollectionRoleMap = new HashMap();  
  74.     Map tempCollectionPersisters=new HashMap();  
  75.       
  76.     this.configuration.getCollectionMap().putAll(cfg.getCollectionMap());  
  77.     Iterator collections = cfg.getCollectionMappings();  
  78.   
  79.     while ( collections.hasNext() ) {  
  80.         Collection model = (Collection) collections.next();  
  81.         final String cacheRegionName = cacheRegionPrefix + model.getCacheRegionName();  
  82.         final AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );  
  83.         CollectionRegionAccessStrategy accessStrategy = null;  
  84.         if ( accessType != null && settings.isSecondLevelCacheEnabled() ) {  
  85.             log.trace( "Building cache for collection data [" + model.getRole() + "]" );  
  86.             CollectionRegion collectionRegion = settings.getRegionFactory().buildCollectionRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );  
  87.             accessStrategy = collectionRegion.buildAccessStrategy( accessType );  
  88.             entityAccessStrategies.put( cacheRegionName, accessStrategy );  
  89.             allCacheRegions.put( cacheRegionName, collectionRegion );  
  90.         }  
  91.         CollectionPersister persister = PersisterFactory.createCollectionPersister(this.getConfiguration(), model, accessStrategy, this) ;  
  92.         tempCollectionPersisters.put( model.getRole(), persister.getCollectionMetadata() );  
  93.         Type indexType = persister.getIndexType();  
  94.         if ( indexType != null && indexType.isAssociationType() && !indexType.isAnyType() ) {  
  95.             String entityName = ( ( AssociationType ) indexType ).getAssociatedEntityName( this );  
  96.             Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );  
  97.             if ( roles == null ) {  
  98.                 roles = new HashSet();  
  99.                 tmpEntityToCollectionRoleMap.put( entityName, roles );  
  100.             }  
  101.             roles.add( persister.getRole() );  
  102.         }  
  103.         Type elementType = persister.getElementType();  
  104.         if ( elementType.isAssociationType() && !elementType.isAnyType() ) {  
  105.             String entityName = ( ( AssociationType ) elementType ).getAssociatedEntityName( this );  
  106.             Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );  
  107.             if ( roles == null ) {  
  108.                 roles = new HashSet();  
  109.                 tmpEntityToCollectionRoleMap.put( entityName, roles );  
  110.             }  
  111.             roles.add( persister.getRole() );  
  112.         }  
  113.           
  114.     }  
  115.     //加入新的  
  116.     collectionPersisters.putAll(tempCollectionPersisters);  
  117.   
  118.     Iterator itr = tmpEntityToCollectionRoleMap.entrySet().iterator();  
  119.     while ( itr.hasNext() ) {  
  120.         final Map.Entry entry = ( Map.Entry ) itr.next();  
  121.         entry.setValue( Collections.unmodifiableSet( ( Set ) entry.getValue() ) );  
  122.     }  
  123.       
  124.     collectionRolesByEntityParticipant.putAll( tmpEntityToCollectionRoleMap);  
  125.   
  126.     // after *all* persisters and named queries are registered  
  127.     Iterator iter = tmpEntityPersisters.values().iterator();  
  128.     while ( iter.hasNext() ) {  
  129.         ( (EntityPersister) iter.next() ).postInstantiate();  
  130.     }  
  131.     iter = tempCollectionPersisters.values().iterator();  
  132.     while ( iter.hasNext() ) {  
  133.         ( (CollectionPersister) iter.next() ).postInstantiate();  
  134.     }  
  135.       
  136.     queryPlanCache=new QueryPlanCache(this);  
  137.       
  138.       
  139. }  
 

咱们动态加入实体，动态可进行查询，Hibernate提供几种实体的查询策略，其中一个是咱们经常使用的pojo，若采用该方法，咱们得加上hbm与 class类或仅是含注解的class至hibernate的SessionFactory,这种方案而且没有问题，但会遇到当咱们修改表单字段，从新生 成对应的实体时，咱们就会遇到原有的实体class不能在ClassLoader里卸载。使用的仍是旧的Class,达不到动态查询的效果。若使用动态的 ClassLoader，代码将变得很复杂。（尝试过，代码相对比较繁杂）性能

 

        还好Hibernate提供了另外一种实体查询策略，基于Map的动态实体。基于这种方式，咱们配置一个一对多的表，其示例代码以下：

 

MainEntity.hbm.xml

Java代码   收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class table="main_entity" entity-name="MainEntity">  
  7.         <id name="mainId" column="mainId" type="java.lang.Long">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="itemSubject" type="java.lang.String" length="128"/>  
  11.         <property name="itemDescp" type="java.lang.String" />  
  12.         <property name="createtime" type="java.util.Date" />  
  13.         <bag name="subEntitys"  
  14.              table="sub_entity"  
  15.              lazy="false"  
  16.              inverse="true"  
  17.              cascade="save-update,delete-orphan"  
  18.         >  
  19.             <key>  
  20.                 <column name="mainId"/>  
  21.             </key>  
  22.             <one-to-many entity-name="SubEntity"/>  
  23.         </bag>  
  24.     </class>  
  25. </hibernate-mapping>  

 SubEntity.hbm.xml

 

 

Java代码   收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC  
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class table="sub_entity" entity-name="SubEntity">  
  7.         <id name="subId" column="subId" type="java.lang.Long">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="subject" type="java.lang.String" length="128"/>  
  11.         <property name="createtime" type="java.util.Date"/>  
  12.         <many-to-one name="mainEntity" entity-name="MainEntity" not-null="false" fetch="select">  
  13.             <column name="mainId"></column>  
  14.         </many-to-one>  
  15.     </class>  
  16. </hibernate-mapping>  
 

为两实体插入数据后，可动态测试以下：

 

 

Java代码   收藏代码
  1. public static void main(String[]args){  
  2.         ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("classpath:app-context.xml");  
  3.   
  4.         MyAnnotationSessionFactoryBean sessionFactoryBean=(MyAnnotationSessionFactoryBean)ctx.getBean("&sessionFactory");  
  5.           
  6.         SessionFactoryImpl sessionFactoryImpl=(SessionFactoryImpl)sessionFactoryBean.getObject();  
  7.       
  8.         Configuration cfg=new Configuration();    
  9.         //cfg.configure();  
  10.           
  11.         cfg.addFile("D:/download/eclipse/workspace2/SpringHibernate/src/com/hotent/entity/MainEntity.hbm.xml");  
  12.         cfg.addFile("D:/download/eclipse/workspace2/SpringHibernate/src/com/hotent/entity/SubEntity.hbm.xml");  
  13.         cfg.doComplie();  
  14.   
  15.         sessionFactoryImpl.addNewConfig(cfg);  
  16.   
  17.         MainEntityDao dao=(MainEntityDao)ctx.getBean("mainEntityDao");  
  18.   
  19.         List list=dao.query();  
  20.   
  21.         for(int i=0;i<list.size();i++){  
  22.             Map map=(Map)list.get(i);  
  23.             Iterator it=map.keySet().iterator();  
  24.             while(it.hasNext()){  
  25.                 //String key=(String)it.next();  
  26.                 Object key=it.next();  
  27.                 Object val=map.get(key);  
  28.                 System.out.println("--------------->key:"+key );  
  29.             }  
  30.         }  
  31.   
  32.         Configuration cfg2=new Configuration();  
  33.         cfg2.addFile("D:/dev/product/SpringHibernate/src/com/hotent/entity/MainEntity2.hbm.xml");  
  34.         cfg2.addFile("D:/dev/product/SpringHibernate/src/com/hotent/entity/SubEntity2.hbm.xml");  
  35.         cfg2.doComplie();  
  36.         sessionFactoryImpl.addNewConfig(cfg2);  
  37.           
  38.         List list2=dao.query();  
  39.           
  40.         for(int i=0;i<list2.size();i++){  
  41.             Map map=(Map)list2.get(i);  
  42.             Iterator it=map.keySet().iterator();  
  43.             while(it.hasNext()){  
  44.                 //String key=(String)it.next();  
  45.                 Object key=it.next();  
  46.                 Object val=map.get(key);  
  47.                 System.out.println("key:"+key );  
  48.             }  
  49.         }  
  50.           
  51.     }  
 
Java代码   收藏代码
  1. MainEntity2.hbm.xml与SubEntity2.hbm.xml文件相对原来的文件增长了一些列或删除了一些列  

 

执行后，能够实时看到不一样的结果，而且不会影响现有的dao。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程