Java自定義表單、自定義字段

      最近想實現用戶自定義數據庫中的字段，我想大部分人第一想到的就是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，例如下面這樣。

/**
*實體類
*/
public class Contact extends CustomizableEntity {

    /**
     * ID
     */
    private int id;

    /**
     * 名稱
     */
    private String name;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}

<?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">
<hibernate-mapping auto-import="true" default-access="property"
    default-cascade="none" default-lazy="true">

    <class abstract="false" dynamic-insert="false" dynamic-update="false"
        mutable="true" name="com.hfmx.model.Contact" optimistic-lock="version"
        polymorphism="implicit" select-before-update="false" table="tb_contact">
        <id column="fld_id" name="id">
            <generator class="native" />
        </id>

        <property column="fld_name" generated="never" lazy="false"
            name="name" optimistic-lock="true" type="string" unique="false" />
        <dynamic-component insert="true" name="customProperties"
            optimistic-lock="true" unique="false" update="true">
        </dynamic-component>
    </class>
</hibernate-mapping>

     上面的實體類中繼承了一個父類，以及XML文件中的標簽dynamic-component都是為了可以自定義字段做准備的，我們暫且忽略這部分內容，主要看看如何重構sessionFactory，其實這個實現的方式也是從網上找到的，當然為了能夠與hibernate4.0結合，部分地方作了修改，下面把代碼貼出來，重點地方會做點注釋。

public class HibernateUtil {

    private static HibernateUtil instance;

    private Configuration configuration;

    private SessionFactory sessionFactory;

    private Session session;

    public synchronized static HibernateUtil getInstance() {
        if (null == instance) {
            instance = new HibernateUtil();
        }
        return instance;
    }

    private synchronized SessionFactory getSessionFactory() {
        if (null == sessionFactory) {
            Configuration _configuration = this.getConfiguration();

            ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
                    .applySettings(_configuration.getProperties())
                    .buildServiceRegistry();

            sessionFactory = _configuration
                    .buildSessionFactory(serviceRegistry);
        }
        return sessionFactory;
    }

    public synchronized Session getCurrentSession() {
        if (null == session) {
            session = getSessionFactory().openSession();
            session.setFlushMode(FlushMode.COMMIT);    
    }
        return session;
    }

    private synchronized Configuration getConfiguration() {
        if (null == configuration) {
            try {
                // 默認加載hibernate.cfg.xml
                configuration = new Configuration().configure();
                Class entityClass = Contact.class;
                String filePath = entityClass.getResource(
                        entityClass.getSimpleName() + ".hbm.xml").getPath();
                // 替換空格
                filePath = filePath.replace("%20", " ");

                File file = new File(filePath);
                // 通過class加載會發現在j2ee中不行
                // configuration.addClass(entityClass);
                //通過加載classes文件夾下面的文件，獲取實時修改后的XML文件
                configuration.addFile(file);
            } catch (HibernateException e) {
                e.printStackTrace();
            }
        }
        return configuration;
    }

    /**
     * 重置
     */
    public void reset() {
        Session session = getCurrentSession();
        if (null != session) {
            session.flush();
            if (session.isOpen()) {
                session.close();
            }
        }
        SessionFactory sf = getSessionFactory();
        if (null != sf) {
            sf.close();
        }
        this.configuration = null;
        this.sessionFactory = null;
        this.session = null;
    }

    public PersistentClass getClassMapping(Class entityClass) {
        return getConfiguration().getClassMapping(entityClass.getName());
    }
}

     這種方式即可在修改完XML后立即加載修改后的XML，對其進行映射到數據庫中，然后生成新添加的字段，這種方式存在的弊端也在文章一開始做了介紹，無法刪除字段，同時，配置文件在實際項目中越來越多的被Annotation所替代掉。所以，需要有一種新的方式來實現自定義字段，下面將重點介紹這種方式，同時，下面的內容也是對此配置方式的一個補充。如果看到這里覺得配置文件方式介紹的不夠詳細，可以在下面找出其中很多知識點。

     現在，着重講解通過純的sql來實現數據庫的自定義字段功能….

     首先，我們來看下環境，我用的是springMVC+spring3+hibernate4.0

     同時，對應新增的字段，要通過key-value的方式進行保存，即放在Map集合中，這樣方便后期的讀寫

/**
 * 支持自定義字段的業務實體類基類
 * 
 * @author wy
 * 
 */
public abstract class CustomizableEntity {

    private Map<String, Object> customProperties;

    public Map<String, Object> getCustomProperties() {
        if (null == customProperties)
            customProperties = new HashMap<String, Object>();
        return customProperties;
    }

    public void setCustomProperties(Map<String, Object> customProperties) {
        this.customProperties = customProperties;
    }

    public Object getValueOfCustomField(String name) {
        return getCustomProperties().get(name);
    }

    public void setValueOfCustomField(String name, Object value) {
        getCustomProperties().put(name, value);
    }
}

/**
* 實體類MyUser繼承CustomizableEntity，這個類里面已存在字段可視為固定字段
*/
@Entity
public class MyUser extends CustomizableEntity {

    /**
     * ID
     */
    private int id;

    /**
     * 姓名
     */
    private String userName;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    public String getUserName() {
        return userName;
    }

    public void setId(int id) {
        this.setValueOfCustomField("id", id);
        this.id = id;
    }

    public void setUserName(String userName) {
        this.setValueOfCustomField("username", userName);
        this.userName = userName;
    }
}

     完成上面兩個類，在啟動項目后，數據庫中會添加一個myuser表，同時擁有兩個字段(ID,userName)。

     此時，我們來嘗試看，看可否往myuser表中添加一個字段，通過下面簡單的方式。

  /**
   * 添加字段列（UserDefineField是一個簡單的實體類，包括自定義字段的name，*type以及中文名稱，描述等等）
   */
   public void addFieldColumn(Class clazz, UserDefineField userDefine) {
        try {
            Session session = this.sessionFactory.getCurrentSession();

            String sql = "";
            //驗證字段是否已經存在
            sql = "select count(*) as c from userdefinefield where tableName='"
                    + clazz.getCanonicalName()
                    + "' and fieldName='"
                    + userDefine.getFieldName() + "'";
            Query countQuery = session.createSQLQuery(sql);
            List<Object> list = countQuery.list();
            long count = 0;
            if (list.size() > 0) {
                Object object = list.get(0);
                if (null != object) {
                    count = Long.parseLong(object.toString());
                }
            }
            System.out.println("count:" + count);

            if (count <= 0) {
                // 字段不存在是添加字段
                sql = "alter table " + clazz.getSimpleName() + " add column "
                        + userDefine.getFieldName() + " "
                        + userDefine.getFieldType();
                Query query = session.createSQLQuery(sql);
                query.executeUpdate();

                // 修改自定義字段表
                sql = "insert into userdefinefield (tableName,fieldName,fieldType,fieldCN,fieldDesc) values('"
                        + clazz.getCanonicalName()
                        + "','"
                        + userDefine.getFieldName()
                        + "','"
                        + userDefine.getFieldType()
                        + "','"
                        + userDefine.getFieldCN()
                        + "','"
                        + userDefine.getFieldDesc() + "')";
                query = session.createSQLQuery(sql);
                query.executeUpdate();
            }
        } catch (Exception e) {
            System.out.println("純數據庫方式動態添加字段名稱失敗");
            e.printStackTrace();
        }
    }

       執行完后我們會發現數據庫表中確實已經增加了一個新的字段，那對於刪除字段，當然也就類似了，簡單的看下代碼

   /**
    * 刪除字段列
    * 
    * @param clazz
    * @param fieldName
    */
    public void delFieldColumn(Class clazz, String fieldName) {
        Session session = this.sessionFactory.getCurrentSession();
        try {
            // 刪除字段
            String sql = "alter table " + clazz.getSimpleName()
                    + " drop column " + fieldName + "";
            Query query = session.createSQLQuery(sql);
            query.executeUpdate();

            sql = "delete from userdefinefield where tableName='"
                    + clazz.getCanonicalName() + "' and fieldName='"
                    + fieldName + "'";
            query = session.createSQLQuery(sql);
            query.executeUpdate();

        } catch (Exception e) {
            System.out.println("純數據庫方式動態刪除字段名稱失敗");
            e.printStackTrace();
        }
    }

      看到這里，很多人會不會想，這樣實現只要會sql的人都可以，主要是如何對數據進行CRUD的操作，是的，光看上面的代碼肯定覺得so easy，接下來看看如果查詢、保存、修改、刪除吧

 ① 查詢

 1    /**
    * 根據ID進行用戶查詢
    * 
    * @param clazz
    * @param id
    * @return
    */
    public MyUser searchMyUser(Class clazz, int id) {
        MyUser myUser = new MyUser();
        try {
            Session session = this.sessionFactory.getCurrentSession();
            String sql = "SELECT * FROM (select * from myuser where id="
                    + id
                    + " ) m join (select * from userdefinefield where tableName='"
                    + clazz.getCanonicalName() + "') AS define";

            Query query = session.createSQLQuery(sql).setResultTransformer(
                    Transformers.ALIAS_TO_ENTITY_MAP);
            List<Map<String, Object>> list = (List<Map<String, Object>>) query
                    .list();

            if (list.size() > 0) {
                Map<String, Object> map = list.get(0);

                // 固有屬性
                myUser.setId(Integer.parseInt(map.get("id").toString()));
                myUser.setUserName(map.get("userName").toString());
            }

            for (Map<String, Object> map : list) {

                // 自定義列名
                String fieldName = map.get("fieldName").toString();

                myUser.setValueOfCustomField(fieldName, (null == map
                        .get(fieldName)) ? "" : map.get(fieldName).toString());

                UserDefine define = new UserDefine(map);
                myUser.setValueOfExctalyCustomProp(fieldName, define);
            }

            return myUser;
        } catch (Exception e) {
            System.out.println("根據ID進行查詢出現錯誤");
            e.printStackTrace();
            return null;
        }
    }

  查詢后，在control中打印出來看看效果

 1  // ****查詢信息
 MyUser myUser = this.myservice.searchMyUser(MyUser.class, id);

 System.out.println("******查詢結果******");
 System.out.println("id:" + myUser.getId());
 System.out.println("name:" + myUser.getUserName());
    //自定義字段key-value顯示  7  for (String key : myUser.getCustomPropties.keySet()) {
   System.out.println("" + key + ":"+key+”  value:” + myUser.getValueOfCustomField(key));
 }

② 保存

 /**
     * 保存信息
     * 
     * @param myuser
     */
    public void saveMyUser(MyUser myuser) {
        try {
            Session session = this.sessionFactory.getCurrentSession();

            String sql = "insert into " + myuser.getClass().getSimpleName()
                    + " ";
            int index = 0;
            for (String key : myuser.getCustomProperties().keySet()) {
                if (index == 0) {
                    sql += "(" + key + "";
                } else {
                    if (index == myuser.getCustomProperties().size() - 1) {
                        sql += "," + key + ") ";
                    } else {
                        sql += "," + key + "";
                    }
                }
                index++;
            }

            index = 0;
            for (String key : myuser.getCustomProperties().keySet()) {
                if (index == 0) {
                    sql += "values('" + myuser.getCustomProperties().get(key)
                            + "'";
                } else {
                    if (index == myuser.getCustomProperties().size() - 1) {
                        sql += ",'" + myuser.getCustomProperties().get(key)
                                + "')";
                    } else {
                        sql += ",'" + myuser.getCustomProperties().get(key)
                                + "'";
                    }
                }
                index++;
            }

            System.out.println("保存用戶信息的sql：" + sql);
            Query query = session.createSQLQuery(sql);
            query.executeUpdate();

        } catch (Exception e) {
            System.out.println("保存用戶信息出錯:" + e.getMessage());
            e.printStackTrace();
        }
    }

③  修改

   /**
     * 修改信息
     * 
     * @param myUser
     */
    public void updateMyUser(MyUser myUser) {
        try {
            Session session = this.sessionFactory.getCurrentSession();

            String sql = "update myuser set userName='" + myUser.getUserName()
                    + "'";
            if (myUser.getCustomProperties().size() > 0) {
                for (String key : myUser.getCustomProperties().keySet()) {
                    sql += "," + key + "='"
                            + myUser.getCustomProperties().get(key) + "'";
                }
            }
            sql += " where id=" + myUser.getId();

            System.out.println("修改用戶信息的sql：" + sql);

            Query query = session.createSQLQuery(sql);
            query.executeUpdate();

        } catch (Exception e) {
            System.out.println("修改用戶信息出錯:" + e.getMessage());
            e.printStackTrace();
        }
    }

④ 刪除

     刪除如果是根據ID刪除，那就一點影響都沒有了，如果是根據動態列內容去刪除，那也就是和保存和修改時候處理方式一樣，這里就不列出來了。（哈哈，感覺重復的代碼有點多了）

 

     綜上所述，初步覺得，如果采用這種方式應該可以對項目本身改動的地方不大，同時，表結構基本上能夠很好的維護。在多表聯合查詢的時候，也同樣沒有太復雜的sql代碼。當然，目前沒有運用到大的系統中，不知道可否在后面會遇到問題。

     如果其他童鞋有其他更好的方法，希望可以一起分享！！！！！！