Java自定义表单、自定义字段-CSDN博客

最近想实现用户自定义数据库中的字段，我想大部分人第一想到的就是EAV(Entity-Attribute-Value)，这种方式对于写一个小的毕业设计应该还可以使用，当然也有很多CMS系统采用这种方式，毕竟其中Value表中的数据会猛增，同样，会涉及到查询优化问题，暂不考虑。

其次，在J2EE中，如果使用spring+hbiernate+springMVC(struts2)，Entity类有两种方式和数据库进行映射，一种是注解方式，一种是*.hbm.xml配置文件方式。

①注解方式，对于注解方式，因为最终目的是根据自定义的字段可以实时的在数据库表中对其字段进行生成，然后可以使用，最初想到的解决方法是重写相应实体类的.class文件，然后根据最新的.class文件生成相应的*.hbm.xml文件，利用configuration重新读取*.hbm.xml文件来建立buildSessionFactory(下面会给出详细代码)，最后发现即使实现了增加字段，也无法通过这种方式删除字段，不过还是看看往.class文件中写入field以及其getter/setter方法的java语句吧。

 1 /*
 2 * 添加字段
 3 */
 4 public class AddFieldAdapter extends ClassAdapter {
 5 
 6     private int accessModifier;
 7     private String name;
 8     private String desc;
 9     private boolean isFieldPresent;
10 
11     public AddFieldAdapter(ClassVisitor cv, int accessModifier, String name,
12             String desc) {
13         super(cv);
14         this.accessModifier = accessModifier;
15         this.name = name;
16         this.desc = desc;
17     }
18 
19     public FieldVisitor visitField(int access, String name, String desc,
20             String signature, Object value) {
21         if (name.equals(this.name)) {
22             isFieldPresent = true;
23         }
24         return cv.visitField(access, name, desc, signature, value);
25     }
26 
27     public void visitEnd() {
28         if (!isFieldPresent) {
29             FieldVisitor fv = cv.visitField(accessModifier, name, desc, null,
30                     null);
31 
32             if (null != fv) {
33                 fv.visitEnd();
34             }
35         }
36         cv.visitEnd();
37     }
39 }

 1             // 创建get,public,无参数，有返回值
 2             MethodVisitor mv = cWriter.visitMethod(Opcodes.ACC_PUBLIC, "get"
 3                     + StringUtils.capitalize(filedName), "()" + type, null,//type为返回的类型
 4                     null);
 5             mv.visitCode();
 6             mv.visitVarInsn(Opcodes.ALOAD, 0);//将this压栈
 7             mv.visitFieldInsn(Opcodes.GETFIELD,
 8                     this.entityClass.getSimpleName(), filedName, type);
 9             mv.visitInsn(Opcodes.ARETURN);
10             mv.visitMaxs(1, 1);
11             mv.visitEnd();
12 
13             // 创建set方法，public，传递一个参数
14             mv = cWriter.visitMethod(Opcodes.ACC_PUBLIC,//方法名为public
15                     "set" + StringUtils.capitalize(filedName), "(" + type //传递一个参数
16                             + ")V", null, null);//V表示返回的是void
17             mv.visitCode();//开始执行
18             mv.visitVarInsn(Opcodes.ALOAD, 0);//将this压栈
19             mv.visitVarInsn(Opcodes.ALOAD, 1);//将局部变量压栈
20             mv.visitFieldInsn(Opcodes.PUTFIELD,
21                     this.entityClass.getSimpleName(), filedName, type);
22             mv.visitInsn(Opcodes.ARETURN);
23             mv.visitMaxs(2, 2);
24             mv.visitEnd();//执行结束

关于如何将.class文件生成*.hbm.xml可以从网上找相关模板，借助模板将class文件转换生成xml配置文件方式，因为重点不采用这种方式，所以简单介绍下如何重写class文件即可，关于如何从*.hbm.xml文件重构sessionfactory映射到数据库中在稍后贴出代码。

②配置文件方式，配置文件的方式对于项目中使用本身就不是特别方便的（相对于注解来说），所有这种方式也是一开始只是为了尝试在重写了*.hbm.xml后是否可以通过代码的方式，在不重启服务器的情况下，将修改的内容实时的反映到我们的数据库中，所以在一开始的时候定义model或者entity时候，就应该写个与之对应的*.hbm.xml，例如下面这样。

 1 /**
 2 *实体类
 3 */
 4 public class Contact extends CustomizableEntity {
 5 
 6     /**
 7      * ID
 8      */
 9     private int id;
10 
11     /**
12      * 名称
13      */
14     private String name;
15 
16     public int getId() {
17         return id;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setId(int id) {
25         this.id = id;
26     }
27 
28     public void setName(String name) {
29         this.name = name;
30     }
31 }

 1 <?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 2 <hibernate-mapping auto-import="true" default-access="property"
 3     default-cascade="none" default-lazy="true">
 4 
 5     <class abstract="false" dynamic-insert="false" dynamic-update="false"
 6         mutable="true" name="com.hfmx.model.Contact" optimistic-lock="version"
 7         polymorphism="implicit" select-before-update="false" table="tb_contact">
 8         <id column="fld_id" name="id">
 9             <generator class="native" />
10         </id>
11 
12         <property column="fld_name" generated="never" lazy="false"
13             name="name" optimistic-lock="true" type="string" unique="false" />
14         <dynamic-component insert="true" name="customProperties"
15             optimistic-lock="true" unique="false" update="true">
16         </dynamic-component>
17     </class>
18 </hibernate-mapping>

上面的实体类中继承了一个父类，以及XML文件中的标签dynamic-component都是为了可以自定义字段做准备的，我们暂且忽略这部分内容，主要看看如何重构sessionFactory，其实这个实现的方式也是从网上找到的，当然为了能够与hibernate4.0结合，部分地方作了修改，下面把代码贴出来，重点地方会做点注释。

 1 public class HibernateUtil {
 2 
 3     private static HibernateUtil instance;
 4 
 5     private Configuration configuration;
 6 
 7     private SessionFactory sessionFactory;
 8 
 9     private Session session;
10 
11     public synchronized static HibernateUtil getInstance() {
12         if (null == instance) {
13             instance = new HibernateUtil();
14         }
15         return instance;
16     }
17 
18     private synchronized SessionFactory getSessionFactory() {
19         if (null == sessionFactory) {
20             Configuration _configuration = this.getConfiguration();
21 
22             ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
23                     .applySettings(_configuration.getProperties())
24                     .buildServiceRegistry();
25 
26             sessionFactory = _configuration
27                     .buildSessionFactory(serviceRegistry);
28         }
29         return sessionFactory;
30     }
31 
32     public synchronized Session getCurrentSession() {
33         if (null == session) {
34             session = getSessionFactory().openSession();
35             session.setFlushMode(FlushMode.COMMIT);    
36     }
37         return session;
38     }
39 
40     private synchronized Configuration getConfiguration() {
41         if (null == configuration) {
42             try {
43                 // 默认加载hibernate.cfg.xml
44                 configuration = new Configuration().configure();
45                 Class entityClass = Contact.class;
46                 String filePath = entityClass.getResource(
47                         entityClass.getSimpleName() + ".hbm.xml").getPath();
48                 // 替换空格
49                 filePath = filePath.replace("%20", " ");
50 
51                 File file = new File(filePath);
52                 // 通过class加载会发现在j2ee中不行
53                 // configuration.addClass(entityClass);
54                 //通过加载classes文件夹下面的文件，获取实时修改后的XML文件
55                 configuration.addFile(file);
56             } catch (HibernateException e) {
57                 e.printStackTrace();
58             }
59         }
60         return configuration;
61     }
62 
63     /**
64      * 重置
65      */
66     public void reset() {
67         Session session = getCurrentSession();
68         if (null != session) {
69             session.flush();
70             if (session.isOpen()) {
71                 session.close();
72             }
73         }
74         SessionFactory sf = getSessionFactory();
75         if (null != sf) {
76             sf.close();
77         }
78         this.configuration = null;
79         this.sessionFactory = null;
80         this.session = null;
81     }
82 
83     public PersistentClass getClassMapping(Class entityClass) {
84         return getConfiguration().getClassMapping(entityClass.getName());
85     }
86 }

这种方式即可在修改完XML后立即加载修改后的XML，对其进行映射到数据库中，然后生成新添加的字段，这种方式存在的弊端也在文章一开始做了介绍，无法删除字段，同时，配置文件在实际项目中越来越多的被Annotation所替代掉。所以，需要有一种新的方式来实现自定义字段，下面将重点介绍这种方式，同时，下面的内容也是对此配置方式的一个补充。如果看到这里觉得配置文件方式介绍的不够详细，可以在下面找出其中很多知识点。

现在，着重讲解通过纯的sql来实现数据库的自定义字段功能….

首先，我们来看下环境，我用的是springMVC+spring3+hibernate4.0

同时，对应新增的字段，要通过key-value的方式进行保存，即放在Map集合中，这样方便后期的读写

 1 /**
 2  * 支持自定义字段的业务实体类基类
 3  * 
 4  * @author wy
 5  * 
 6  */
 7 public abstract class CustomizableEntity {
 8 
 9     private Map<String, Object> customProperties;
10 
11     public Map<String, Object> getCustomProperties() {
12         if (null == customProperties)
13             customProperties = new HashMap<String, Object>();
14         return customProperties;
15     }
16 
17     public void setCustomProperties(Map<String, Object> customProperties) {
18         this.customProperties = customProperties;
19     }
20 
21     public Object getValueOfCustomField(String name) {
22         return getCustomProperties().get(name);
23     }
24 
25     public void setValueOfCustomField(String name, Object value) {
26         getCustomProperties().put(name, value);
27     }
28 }

 1 /**
 2 * 实体类MyUser继承CustomizableEntity，这个类里面已存在字段可视为固定字段
 3 */
 4 @Entity
 5 public class MyUser extends CustomizableEntity {
 6 
 7     /**
 8      * ID
 9      */
10     private int id;
11 
12     /**
13      * 姓名
14      */
15     private String userName;
16 
17     @Id
18     @GeneratedValue
19     public int getId() {
20         return id;
21     }
22 
23     public String getUserName() {
24         return userName;
25     }
26 
27     public void setId(int id) {
28         this.setValueOfCustomField("id", id);
29         this.id = id;
30     }
31 
32     public void setUserName(String userName) {
33         this.setValueOfCustomField("username", userName);
34         this.userName = userName;
35     }
36 }

完成上面两个类，在启动项目后，数据库中会添加一个myuser表，同时拥有两个字段(ID,userName)。

此时，我们来尝试看，看可否往myuser表中添加一个字段，通过下面简单的方式。

 1   /**
 2    * 添加字段列（UserDefineField是一个简单的实体类，包括自定义字段的name，*type以及中文名称，描述等等）
 3    */
 4    public void addFieldColumn(Class clazz, UserDefineField userDefine) {
 5         try {
 6             Session session = this.sessionFactory.getCurrentSession();
 7 
 8             String sql = "";
 9             //验证字段是否已经存在
10             sql = "select count(*) as c from userdefinefield where tableName='"
11                     + clazz.getCanonicalName()
12                     + "' and fieldName='"
13                     + userDefine.getFieldName() + "'";
14             Query countQuery = session.createSQLQuery(sql);
15             List<Object> list = countQuery.list();
16             long count = 0;
17             if (list.size() > 0) {
18                 Object object = list.get(0);
19                 if (null != object) {
20                     count = Long.parseLong(object.toString());
21                 }
22             }
23             System.out.println("count:" + count);
24 
25             if (count <= 0) {
26                 // 字段不存在是添加字段
27                 sql = "alter table " + clazz.getSimpleName() + " add column "
28                         + userDefine.getFieldName() + " "
29                         + userDefine.getFieldType();
30                 Query query = session.createSQLQuery(sql);
31                 query.executeUpdate();
32 
33                 // 修改自定义字段表
34                 sql = "insert into userdefinefield (tableName,fieldName,fieldType,fieldCN,fieldDesc) values('"
35                         + clazz.getCanonicalName()
36                         + "','"
37                         + userDefine.getFieldName()
38                         + "','"
39                         + userDefine.getFieldType()
40                         + "','"
41                         + userDefine.getFieldCN()
42                         + "','"
43                         + userDefine.getFieldDesc() + "')";
44                 query = session.createSQLQuery(sql);
45                 query.executeUpdate();
46             }
47         } catch (Exception e) {
48             System.out.println("纯数据库方式动态添加字段名称失败");
49             e.printStackTrace();
50         }
51     }

执行完后我们会发现数据库表中确实已经增加了一个新的字段，那对于删除字段，当然也就类似了，简单的看下代码

 1    /**
 2     * 删除字段列
 3     * 
 4     * @param clazz
 5     * @param fieldName
 6     */
 7     public void delFieldColumn(Class clazz, String fieldName) {
 8         Session session = this.sessionFactory.getCurrentSession();
 9         try {
10             // 删除字段
11             String sql = "alter table " + clazz.getSimpleName()
12                     + " drop column " + fieldName + "";
13             Query query = session.createSQLQuery(sql);
14             query.executeUpdate();
15 
16             sql = "delete from userdefinefield where tableName='"
17                     + clazz.getCanonicalName() + "' and fieldName='"
18                     + fieldName + "'";
19             query = session.createSQLQuery(sql);
20             query.executeUpdate();
21 
22         } catch (Exception e) {
23             System.out.println("纯数据库方式动态删除字段名称失败");
24             e.printStackTrace();
25         }
26     }

看到这里，很多人会不会想，这样实现只要会sql的人都可以，主要是如何对数据进行CRUD的操作，是的，光看上面的代码肯定觉得so easy，接下来看看如果查询、保存、修改、删除吧

① 查询

 1    /**
 2     * 根据ID进行用户查询
 3     * 
 4     * @param clazz
 5     * @param id
 6     * @return
 7     */
 8     public MyUser searchMyUser(Class clazz, int id) {
 9         MyUser myUser = new MyUser();
10         try {
11             Session session = this.sessionFactory.getCurrentSession();
12             String sql = "SELECT * FROM (select * from myuser where id="
13                     + id
14                     + " ) m join (select * from userdefinefield where tableName='"
15                     + clazz.getCanonicalName() + "') AS define";
16 
17             Query query = session.createSQLQuery(sql).setResultTransformer(
18                     Transformers.ALIAS_TO_ENTITY_MAP);
19             List<Map<String, Object>> list = (List<Map<String, Object>>) query
20                     .list();
21 
22             if (list.size() > 0) {
23                 Map<String, Object> map = list.get(0);
24 
25                 // 固有属性
26                 myUser.setId(Integer.parseInt(map.get("id").toString()));
27                 myUser.setUserName(map.get("userName").toString());
28             }
29 
30             for (Map<String, Object> map : list) {
31 
32                 // 自定义列名
33                 String fieldName = map.get("fieldName").toString();
34 
35                 myUser.setValueOfCustomField(fieldName, (null == map
36                         .get(fieldName)) ? "" : map.get(fieldName).toString());
37 
38                 UserDefine define = new UserDefine(map);
39                 myUser.setValueOfExctalyCustomProp(fieldName, define);
40             }
41 
42             return myUser;
43         } catch (Exception e) {
44             System.out.println("根据ID进行查询出现错误");
45             e.printStackTrace();
46             return null;
47         }
48     }

查询后，在control中打印出来看看效果

 1  // ****查询信息
 2  MyUser myUser = this.myservice.searchMyUser(MyUser.class, id);
 3 
 4  System.out.println("******查询结果******");
 5  System.out.println("id:" + myUser.getId());
 6  System.out.println("name:" + myUser.getUserName());
//自定义字段key-value显示
 7  for (String key : myUser.getCustomPropties.keySet()) {
 8    System.out.println("" + key + ":"+key+”  value:” + myUser.getValueOfCustomField(key));
10  }

② 保存

 1  /**
 2      * 保存信息
 3      * 
 4      * @param myuser
 5      */
 6     public void saveMyUser(MyUser myuser) {
 7         try {
 8             Session session = this.sessionFactory.getCurrentSession();
 9 
10             String sql = "insert into " + myuser.getClass().getSimpleName()
11                     + " ";
12             int index = 0;
13             for (String key : myuser.getCustomProperties().keySet()) {
14                 if (index == 0) {
15                     sql += "(" + key + "";
16                 } else {
17                     if (index == myuser.getCustomProperties().size() - 1) {
18                         sql += "," + key + ") ";
19                     } else {
20                         sql += "," + key + "";
21                     }
22                 }
23                 index++;
24             }
25 
26             index = 0;
27             for (String key : myuser.getCustomProperties().keySet()) {
28                 if (index == 0) {
29                     sql += "values('" + myuser.getCustomProperties().get(key)
30                             + "'";
31                 } else {
32                     if (index == myuser.getCustomProperties().size() - 1) {
33                         sql += ",'" + myuser.getCustomProperties().get(key)
34                                 + "')";
35                     } else {
36                         sql += ",'" + myuser.getCustomProperties().get(key)
37                                 + "'";
38                     }
39                 }
40                 index++;
41             }
42 
43             System.out.println("保存用户信息的sql：" + sql);
44             Query query = session.createSQLQuery(sql);
45             query.executeUpdate();
46 
47         } catch (Exception e) {
48             System.out.println("保存用户信息出错:" + e.getMessage());
49             e.printStackTrace();
50         }
51     }

③ 修改

 1    /**
 2      * 修改信息
 3      * 
 4      * @param myUser
 5      */
 6     public void updateMyUser(MyUser myUser) {
 7         try {
 8             Session session = this.sessionFactory.getCurrentSession();
 9 
10             String sql = "update myuser set userName='" + myUser.getUserName()
11                     + "'";
12             if (myUser.getCustomProperties().size() > 0) {
13                 for (String key : myUser.getCustomProperties().keySet()) {
14                     sql += "," + key + "='"
15                             + myUser.getCustomProperties().get(key) + "'";
16                 }
17             }
18             sql += " where id=" + myUser.getId();
19 
20             System.out.println("修改用户信息的sql：" + sql);
21 
22             Query query = session.createSQLQuery(sql);
23             query.executeUpdate();
24 
25         } catch (Exception e) {
26             System.out.println("修改用户信息出错:" + e.getMessage());
27             e.printStackTrace();
28         }
29     }