传入Java对象 自动创建动态表 并录入数据

看到Hibernate你给一个对象，他就能动态的创建配置文件里面指定的表名，然后把数据录入到数据库，当初感觉是很神奇，不过，好像Hibernate不能动态的分表创建表和录入数据

我这里写了一个公用的类，你给一个对象，告诉我按年还是按月生成表，并告诉我那个字段是不需要在表中创建的，该类就可以动态的分表创建需要的表，并录入数据

注意：

由于业务需要，这里对于字段的支持只有int和Integer，double和Double

还有String，同时对于String统一创建为了Varchar(100)的字段

表会统一创建一个id自增主键

 

Java代码  

1. package com.xd.nms.util;  
2. import java.lang.reflect.Field;  
3. import java.text.SimpleDateFormat;  
4. import java.util.Date;  
5. import java.util.Map;  
6. import java.util.Set;  
7. import org.apache.commons.logging.Log;  
8. import org.apache.commons.logging.LogFactory;  
9. import org.springframework.jdbc.core.JdbcTemplate;  
10. /** 
11.  * @说明 动态插入数据和创建表 
12.  * @author 崔素强 
13.  * @version 1.0 
14.  * @since 
15.  */  
16. public class CommonTableInsert {  
17.     public static Log logger = LogFactory.getLog(CommonTableInsert.class);  
18.     /** 
19.      * 入口方法 
20.      * @param tableName 表前缀 
21.      * @param dateFormat 格式化方法 
22.      * @param obj 保存的对象 
23.      * @return 
24.      */  
25.     @SuppressWarnings("unchecked")  
26.     public static int insertObject(String tableName,String dateFormat,Object obj, Map noCol){  
27.         int re = 0;          
28.         try {     
29.             JdbcTemplate jt = (JdbcTemplate) SpringFactory.getObject("jdbcTemplate");  
30.             SimpleDateFormat format = new SimpleDateFormat(dateFormat);               
31.             String tname = tableName + "_" + format.format(new Date());  
32.             if(CommonDBUtil.getAllTableName(jt,tname)){ // 如果有某表  
33.                 re = saveObj(jt,tname,obj, noCol); // 保存数据     
34.             }else{  
35.                 re = createTable(jt,tname,obj, noCol); // 动态创建表  
36.                 if(re == 1){  
37.                     re = saveObj(jt,tname,obj, noCol); // 保存数据  
38.                 }  
39.             }                
40.         } catch (Exception e) {     
41.             logger.error("公用方法插入数据入口方法错误", e);  
42.         }            
43.         return re;     
44.     }  
45.     /**   
46.      * 保存方法，注意这里传递的是实际的表的名称   
47.      */    
48.     @SuppressWarnings("unchecked")  
49.     private static int saveObj(JdbcTemplate jt,String tableName,Object obj, Map noCol){     
50.         int re = 0;  
51.         StringBuffer sb = new StringBuffer("");  
52.         try{                 
53.             sb.append(" insert into " + tableName + " (");     
54.             Map<String,String> map = ObjectUtil.getProAndValMap(obj); // 对象的属性和属性值  
55.             Map<String,String> mapType = ObjectUtil.getProTypeMap(obj); // 对象的属性类型列表  
56.             Set<String> set = map.keySet();     
57.             for(String key : set){  
58.                 // 如果该列不是 非处理列  
59.                 if(noCol.get(key) == null){  
60.                     sb.append(key + ",");  
61.                 }  
62.             }     
63.             sb.append(" tableName ) ");                  
64.             sb.append(" values ( ");     
65.             for(String key : set){  
66.                 if(noCol.get(key) == null){  
67.                     if(mapType.get(key).equals("class java.lang.String")){  
68.                         sb.append("'" + (map.get(key) + "',"));  
69.                     }else{  
70.                         sb.append(map.get(key) + ",");  
71.                     }  
72.                 }  
73.             }     
74.             sb.append("'" + tableName + "'); ");   
75.             re = jt.update(sb.toString());             
76.         } catch (Exception e) {     
77.             logger.error("公用方法录入数据时错误", e);  
78.             logger.error("公用方法录入数据语句：" + sb.toString());  
79.         }            
80.         return re;     
81.     }  
82.     /**   
83.      * 根据表名称 和 实体属性 创建一张表 
84.      * @param tableName   
85.      * @param obj 具体生成什么样的表看该对象 
86.      */    
87.     @SuppressWarnings("unchecked")  
88.     private static int createTable(JdbcTemplate jt,String tableName,Object obj, Map noCol){     
89.         StringBuffer sb = new StringBuffer("");     
90.         sb.append("CREATE TABLE `" + tableName + "` (");     
91.         sb.append(" `id` int(11) NOT NULL AUTO_INCREMENT,");  
92.         Class c = obj.getClass();  
93.         Field field[] = c.getDeclaredFields();  
94.         for (Field f : field) {  
95.             if(noCol.get(f.getName()) == null){  
96.                 String type = f.getType().toString();  
97.                 if(type.equals("class java.lang.String")){// Str  
98.                      sb.append("`" + f.getName() + "` varchar(100) DEFAULT NULL,");     
99.                 }else if(type.equals("int") || type.equals("class java.lang.Integer")){// int  
100.                     sb.append("`" + f.getName() + "` int(11) DEFAULT NULL,");     
101.                 }else if(type.equals("double") || type.equals("class java.lang.Double")){// double  
102.                     sb.append("`" + f.getName() + "` double DEFAULT NULL,");     
103.                 }  
104.             }  
105.         }  
106.         sb.append(" `tableName` varchar(255) DEFAULT NULL,");  
107.         sb.append(" PRIMARY KEY (`id`)");     
108.         sb.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;");     
109.         try {     
110.             jt.update(sb.toString());     
111.             return 1;     
112.         } catch (Exception e) {  
113.             logger.error("公用方法生成表时错误", e);  
114.             logger.error("公用方法生成表语句：" + sb.toString());  
115.         }     
116.         return 0;     
117.     }   
118. }  

 

这个对于之前写的那个动态建表，新增了过滤不需要在表中创建的字段

原理就是读取对象的各个字段属性，如果能加以配置文件或者读取对象属性的标记，那其实能做到基本和Hibernate一致，不但能支持多种类型，还能做字段校验等