Hibernate映射文件生成器by LDDXFS

本文由 http://www.cnblogs.com/LDDXFS/ 原创，转载请注明本文出处。（新版本的代码生成器写好了，新版本设计上更合理，会在近期对其进行相关介绍，打算在工作稳定后开源，本文为旧版本）

关于代码生成器，JBOSS的Hibernate Tool插件也有hbm.xml生成功能，自己写这个生成器的目的是为了代码简洁一些

1作用

它根据.properties文件上定义的参数扫描某文件夹下XXX.java文件, 依据xml模板文件生成Hibernate的映射文件 XXX.hbm.xml

可以提取XXX.java文件中字段上的doc注释到XXX.hbm.xml文件对应的配置上

支持的关联关系有 一对一，一对多Set List，多对一。

最终 生成的hbm.xml文件如下

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.lddxfs.tieba.domain">
    <class name="AdminUser" table="tiebaTB_AdminUser">
<!--id-->
<id name="id" column="id">
    <generator class="native"></generator>
</id>
<!--用户名-->
<property name="name" unique="true"></property>
<!--邮箱，登陆时使用-->
<property name="email" unique="true"></property>
<!--密码-->
<property name="password"></property>
<!--UUID用于激活-->
<property name="uuid"></property>
<!--状态，已经启用，为激活-->
<!-- status属性，表达的是本类AdminUser与DataDictoryValue的多对一 
    class属性：关联的实体类型
    column属性：外键列（引用关联对象的表的主键）
-->
<many-to-one name="status" class="DataDictoryValue" column="statusId"></many-to-one>
<!--居民身份证-->
<property name="idcard"></property>
<!--审核了那些吧-->
<!-- baApply属性，List集合，表达的是本类与BaApply的一对多 
    class属性：关联的实体类型
    key子元素：对方表中的外键列（多方的那个表）
            
    inverse属性:
        默认为false，表示本方维护关联关系。
        如果为true，表示本方不维护关联关系。
        只是影响是否能设置外键列的值（设成有效值或是null值），对获取信息没有影响。
                
    cascade属性：
        默认为none，代表不级联。
        级联是指操作主对象时，对关联的对象也做相同的操作。
        可设为：delete, save-update, all, none ...
                
    lazy属性：懒加载，默认为true。
        true：懒加载，在第一次使用时加载。
        false：立即加载，在获取本对象时就加载这个集合的所有元素。
        extra：增强的懒加载策略。
-->
<set name="baApply">
    <key column="adminUserId"></key>
    <one-to-many class="BaApply"/>
</set>
</class>
</hibernate-mapping>

2依赖的jar文件

3模板文件  src/generator/template/template.xml

<?xml version="1.0" encoding="UTF-8"?>
<beanCache>
    <XMLBeans>
        <XMLBean>
            <type><![CDATA[hbmhead]]></type>
            <note></note>
            <value>
<![CDATA[
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="<%package%>">
    <class name="<%Class%>" table="<%tableprefix%><%Class%>">
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[id]]></type>
            <note></note>
            <value>
<![CDATA[
<id name="<%key%>" column="<%keyColumn%>">
    <generator class="native"></generator>
</id>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[hbmfoot]]></type>
            <note></note>
            <value>
<![CDATA[
    </class>
</hibernate-mapping>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[property]]></type>
            <note></note>
            <value>
<![CDATA[
    <property name="<%field%>"></property>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[picture]]></type>
            <note></note>
            <value>
<![CDATA[
    <property name="<%field%>" length="819200"></property>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[111]]></type>
            <note>
<![CDATA[
<!--<%field%>属性，<%Field%>类型。
    表达的是本类<%Class%>与<%Field%>的一对一。
    采用基于外键的一对一映射方式，本方<%Field%>是有外键方。
-->
]]>
            </note>
            <value>
<![CDATA[
<many-to-one name="<%field%>" class="<%Field%>" column="<%field%>Id" unique="true"></many-to-one>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[110]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，<%Field%>类型。
    表达的是本类<%Class%>与<%Field%>的一对一。
    采用基于外键的一对一映射方式，本方<%Class%>是无外键方。
    property-ref属性：
        写的是对方<%Field%>映射中外键列对应的属性名<%class%>。    
-->
]]>
            </note>
            <value>
<![CDATA[
<one-to-one name="<%field%>" class="<%Field%>" property-ref="<%class%>"/>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[1nSet]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，Set集合，表达的是本类与<%Field%>的一对多 
    class属性：关联的实体类型
    key子元素：对方表中的外键列（多方的那个表）
            
    inverse属性:
        默认为false，表示本方维护关联关系。
        如果为true，表示本方不维护关联关系。
        只是影响是否能设置外键列的值（设成有效值或是null值），对获取信息没有影响。
                
    cascade属性：
        默认为none，代表不级联。
        级联是指操作主对象时，对关联的对象也做相同的操作。
        可设为：delete, save-update, all, none ...
                
    lazy属性：懒加载，默认为true。
        true：懒加载，在第一次使用时加载。
        false：立即加载，在获取本对象时就加载这个集合的所有元素。
        extra：增强的懒加载策略。
-->
]]>
            </note>
            <value>
<![CDATA[
<set name="<%field%>" cascade="all" lazy="true">
    <key column="<%class%>Id"></key>
    <one-to-many class="<%Field%>"/>
</set>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[1nList]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，List集合，表达的是本类与<%Field%>的一对多 
    class属性：关联的实体类型
    key子元素：对方表中的外键列（多方的那个表）
            
    inverse属性:
        默认为false，表示本方维护关联关系。
        如果为true，表示本方不维护关联关系。
        只是影响是否能设置外键列的值（设成有效值或是null值），对获取信息没有影响。
                
    cascade属性：
        默认为none，代表不级联。
        级联是指操作主对象时，对关联的对象也做相同的操作。
        可设为：delete, save-update, all, none ...
                
    lazy属性：懒加载，默认为true。
        true：懒加载，在第一次使用时加载。
        false：立即加载，在获取本对象时就加载这个集合的所有元素。
        extra：增强的懒加载策略。
-->
]]>
            </note>
            <value>
<![CDATA[
<list name="<%field%>">
    <key column="<%class%>Id"></key>
    <list-index column="<%Class%>_<%field%>_idx"></list-index>
    <one-to-many class="<%Field%>"/>
</list>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[n1]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，表达的是本类<%Class%>与<%Field%>的多对一 
    class属性：关联的实体类型
    column属性：外键列（引用关联对象的表的主键）
-->
]]>
            </note>
            <value>
<![CDATA[
<many-to-one name="<%field%>" class="<%Field%>" column="<%field%>Id"></many-to-one>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[nnSet]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，Set集合。
    表达的是本类<%Class%>与<%Field%>的多对多。    
    table属性：中间表（集合表）
    key子元素：集合外键（引用当前表主键的那个外键）
-->
]]>
            </note>
            <value>
<![CDATA[
<set name="<%field%>" table="<%tableprefix%><%centerTable%>" inverse="false">
    <key column="<%class%>Id"></key>
    <many-to-many class="<%Field%>" column="<%field%>Id"></many-to-many>
</set>
]]>
            </value>
        </XMLBean>
        <XMLBean>
            <type><![CDATA[nnList]]></type>
            <note>
<![CDATA[
<!-- <%field%>属性，List集合。
    表达的是本类<%Class%>与<%Field%>的多对多。    
    table属性：中间表（集合表）
    key子元素：集合外键（引用当前表主键的那个外键）
-->
]]>
            </note>
            <value>
<![CDATA[
<list name="<%field%>" table="<%tableprefix%><%centerTable%>" inverse="false">
    <key column="<%class%>Id"></key>
    <list-index column="<%Class%>_<%field%>_idx"></list-index>
    <many-to-many class="<%Field%>" column="<%field%>Id"></many-to-many>
</list>
]]>
            </value>
        </XMLBean>
    </XMLBeans>
</beanCache>

4properties文件  src/generator/generator.properties

#项目名称
project=cn.lddxfs.tieba
#实体所在包名
package=cn.lddxfs.tieba.domain
#实体所在包相对路径
#pathname=src/cn/lddxfs/tieba/domain/
#数据库中表前缀
tableprefix=tiebaTB_
#实体唯一标示符
key=id
#数据库表主键名
keyColumn=id
#中间表
#centerTable=<%Class%>_<%Field%>

5 java文件

src/generator/XMLBean.java

package generator;

public class XMLBean {

    /**
     * <pre>
     * 基本类型 
     * 
     * 本方                                          对方
     * 一对一主键                            一对一外键
     * ClassA key        ClassB
     * 
     * 一对多List                    多对一 
     * List《ClassA》              ClassB
     * 
     * 一对多Set           多对一 
     * Set《ClassA》               ClassB
     * 
     * 多对多List          多对多List
     * List《ClassA》             List《ClassB》
     * 
     * 多对多Set           多对多Set
     * Set《ClassA》               Set《ClassB》
     *  dynamic-update="true"
        dynamic-insert="true"
     * </pre>
     */
    /**
     * 关联关系类型
     */
    private String type;
    /**
     * 注释
     */
    private String note;
    /**
     * 内容，通过type来指定
     */
    private String value;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}

src/generator/XMLBeanCache.java

package generator;

import java.util.HashMap;
import java.util.Map;

public class XMLBeanCache {

    private Map<String, XMLBean> XMLBeanMap = new HashMap<String, XMLBean>();
    private Boolean hasNote;

    public Boolean getHasNote() {
        return hasNote;
    }

    public void setHasNote(Boolean hasNote) {
        this.hasNote = hasNote;
    }

    public Map<String, XMLBean> getXMLBeanMap() {
        return XMLBeanMap;
    }

    public void setXMLBeanMap(Map<String, XMLBean> xMLBeanMap) {
        XMLBeanMap = xMLBeanMap;
    }

    /**
     * 
     * @param key
     *            map的key
     * @return 字符串，hashMap的value 中的XMLBean的内容
     */
    public String getXMLBeanStr(String key) {
        XMLBean xmlBean = this.XMLBeanMap.get(key);
        if (hasNote) {
            if (xmlBean.getNote()==null||"".equals(xmlBean.getNote().trim())) {
                return xmlBean.getNote() + xmlBean.getValue() + '
';
            } else {
                return xmlBean.getNote() + '
' + xmlBean.getValue() + '
';
            }
        }
        return xmlBean.getValue() + '
';
    }

    // 供Digester调用的方法
    public void addXMLBean(XMLBean xMLBean) {
        this.XMLBeanMap.put(xMLBean.getType(), xMLBean);

    }
}

src/generator/XMLBeanDigester.java

package generator;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.apache.commons.digester3.Digester;
import org.xml.sax.SAXException;

public class XMLBeanDigester {
     public XMLBeanCache digester() throws Exception {  
            Digester digester = new Digester();  
            digester.setValidating(false);  
            digester.addObjectCreate("beanCache/XMLBeans", XMLBeanCache.class);  
            // 指明匹配模式和要创建的类   
            digester.addObjectCreate("beanCache/XMLBeans/XMLBean", XMLBean.class);  
            // 设置对象属性,与xml文件对应,不设置则是默认  
            digester.addBeanPropertySetter("beanCache/XMLBeans/XMLBean/type", "type");   
            digester.addBeanPropertySetter("beanCache/XMLBeans/XMLBean/note", "note");   
            digester.addBeanPropertySetter("beanCache/XMLBeans/XMLBean/value", "value");   
  
  
            // 当移动到下一个标签中时的动作  
            digester.addSetNext("beanCache/XMLBeans/XMLBean", "addXMLBean");  
              
            XMLBeanCache bc = null;  
            try {  
                
                InputStream inputStream = new FileInputStream("src/generator/template/template.xml");

                BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(inputStream, "UTF-8"));
                
                bc = (XMLBeanCache) digester.parse(bufferedReader);
//                bc = (BeanCache) digester.parse("beanCache.xml");  
            } catch (IOException e) {  
                throw new Exception(e);  
            } catch (SAXException e) {  
                throw new Exception(e);  
            }  
            return bc;
        }  
}

src/generator/GlobalVar.java

package generator;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

public class GlobalVar {
    /**
     * 基本数据类型
     */
    protected String[] BASE_TYPE = new String[] { "Integer", "Long", "String",
            "Date", "Boolean","Blob","Clob" };
    /**
     * 数组类型
     */
    protected String[] ARRAY_TYPE = new String[] { "byte[]", "Byte[]" };
    /**
     * 集合数据类型
     */
    protected String[] COLLECTION_TYPE = new String[] { "List", "Set" };
    /**
     * 配置文件的路径
     */
    protected String PROPERTIES_LOCATION = "src/generator/generator.properties";
    /**
     * 源码文件夹
     */
    protected String SRC_PATH = "src/";
    /**
     * class文件的文件编码
     */
    protected String CHARSET_NAME = "UTF-8";
    protected String[] DOMAIN_TYPE = new String[] {};
    protected Properties PROPS;
    protected String PACKAGE_Str;
    protected String PATHNAME;

    public GlobalVar() {
        /* 加载资源文件 */
        PROPS = new Properties();
        InputStream is;
        try {
            is = new FileInputStream(PROPERTIES_LOCATION);
            PROPS.load(is);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        // 得到包名
        PACKAGE_Str = PROPS.getProperty("package");
        // 得到路径名 pathname=src/cn/lddxfs/tieba/domain/
        PATHNAME = SRC_PATH + PACKAGE_Str.replace('.', '/') + "/";

        // logger.debug("pathname=" + pathname);
        /* 得到路径名,得到domain类名迭代器 */
        File dir = new File(PATHNAME);
        List<String> classNameList = new LinkedList<String>();
        listClassName(dir, classNameList);
        // Iterator<String> classNameit1 = classNameList.iterator();

        DOMAIN_TYPE = classNameList.toArray(new String[0]);
        for(String name:DOMAIN_TYPE){
            System.out.println(name);
        }

    }

    /**
     * 列出指定目录下的java文件的类名 ，例如 如果有文件“Person.java” ，则列出“Person”
     * 
     * @param file
     *            指定一个目录
     * @param classNameList
     *            返回的类名列表 ,无“.java”后缀
     */
    private void listClassName(File file, List<String> classNameList) {
        if (file == null) {
            return;
        }
        if (file.isDirectory()) {
            File f[] = file.listFiles();
            if (f != null)
                for (int i = 0; i < f.length; i++) {
                    listClassName(f[i], classNameList);
                }
        } else {

            if (file.getName().endsWith(".java")) {
                String str = (file.getName().substring(0, file.getName()
                        .length() - 5));

                classNameList.add(str);
            }
        }
    }

}

一个重点

src/generator/DomainGenerator.java

package generator;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
import org.junit.Test;

import cn.lddxfs.tieba.domain.DataDictory;
import cn.lddxfs.tieba.domain.DataDictoryValue;

public class DomainGenerator extends GlobalVar {

    private Logger logger = Logger.getLogger(DomainGenerator.class);

    /**
     * 设置是否显示注释
     */
    private Boolean HAS_NOTE = true;

    /**
     * 
     * @throws Exception
     */
    @Test
    public void generatorHBMXML() throws Exception {
        /**
         * 遍历
         */
        XMLBeanDigester xmlBeanDigester = new XMLBeanDigester();
        XMLBeanCache xmlBeanCache = xmlBeanDigester.digester();
        xmlBeanCache.setHasNote(HAS_NOTE);
        /**
         * Map<String, XMLBean> xmlBeanMap = xmlBeanCache.getXMLBeanMap();
         * Set<String> beantypeSet = xmlBeanMap.keySet(); Iterator<String>
         * beantypeSetit = beantypeSet.iterator(); while
         * (beantypeSetit.hasNext()) { String beantype = beantypeSetit.next();
         * XMLBean xmlBean = xmlBeanMap.get(beantype);
         * System.out.println(xmlBean.getType());
         * System.out.println(xmlBean.getValue());
         * 
         * }
         */
        /**
         * <pre>
         * 生成hbm.xml文件的思路： 
         *  1 遍历完一个类就直接写出到文件
         *  2 遍历完所有类才写，这种方式实现复杂并且需要消耗较多系统资源，不宜采用
         * 对于1 ，文件的命名为 “实体名.temp”， 存放到properties文件 给出的package下
         * 
         * <pre>
         */
        // 部分 new String[]{"Level","User"} 或全部 DOMAIN_TYPE
        for (String domain_type : DOMAIN_TYPE) {
            // 得到类全限定名
            String className = PACKAGE_Str + "." + domain_type;
            // 得到Class对象
            Class clazz = Class.forName(className);
            // 新建实体对应的Hibernate映射文件.hbm.xml的临时文件.hbm.temp
            File classNamehbmFile = new File(PATHNAME + clazz.getSimpleName()
                    + ".hbm.xml");
            // 存储 .hbm.temp 文件的字符串
            StringBuffer hbmFileSB = new StringBuffer();
            String hbmFileStr = "";

            hbmFileSB.append(xmlBeanCache.getXMLBeanStr("hbmhead"));

            /**
             * 返回 Field 对象的一个数组，这些对象反映此 Class
             * 对象所表示的类或接口所声明的所有字段。包括公共、保护、默认（包）访问和私有字段
             * ，但不包括继承的字段。返回数组中的元素没有排序，也没有任何特定的顺序。如果该类或接口不声明任何字段，或者此 Class
             * 对象表示一个基本类型、一个数组类或 void，则此方法返回一个长度为 0 的数组。
             */
            Field[] fields = clazz.getDeclaredFields();
            logger.debug("className=" + className);
            logger.debug("类" + clazz + "的字段如下========");

            System.out.println("DomainGenerator.name()" + clazz.getName()
                    + "  {");
            for (Field field : fields) {
                // 获得所有Field的类型 不包括泛型Field的 泛型参数
                // 返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型
                Class fieldClazz = field.getType();
                /**
                 * 
                 */
                Class dClazz = null;

                String fieldClazzSimpleName = fieldClazz.getSimpleName();

                if (HAS_NOTE) {
                    String fieldNote = "<!--" + getNote(field) + "-->
";
                    hbmFileSB.append(fieldNote);
                }
                // 获得所有泛型的Field
                // 返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。
                // 如果 Type 是一个参数化类型，则返回的 Type 对象必须准确地反映源代码中使用的实际类型参数。
                // 如果底层字段的类型是一个类型变量或者是一个参数化类型，则创建它。否则将解析它。
                Type fieldGenericType = field.getGenericType();

                /*
                 * System.out.println(fieldGenericType.toString().replaceAll(
                 * "java\.lang\.", ""));
                 */

                /* 如果是类类型 String Byte[] User */
                if (fieldGenericType instanceof Class) {

                    for (String s : BASE_TYPE) {
                        if (fieldClazzSimpleName.equals(s)) {
                            // TODO 直接创建xml
                            if (field.getName()
                                    .equals(PROPS.getProperty("key"))) {
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("id"));
                            } else {
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("property"));
                                break;
                            }
                        }
                    }
                    for (String s : ARRAY_TYPE) {
                        if (fieldClazzSimpleName.equals(s)) {
                            // 设置长度
                            hbmFileSB.append(xmlBeanCache
                                    .getXMLBeanStr("picture"));
                            break;
                        }
                    }

                    for (String s : DOMAIN_TYPE) {
                        if (fieldClazzSimpleName.equals(s)) {
                            // 实体类型
                            dClazz = fieldClazz;
                            // 获得对端是0 1 还是 n
                            String otherString = Other(clazz, fieldClazz);
                            if (otherString.equals("0")) {
                                logger.debug("0对1");// 本方含外键
                                // 多对一
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("n1"));
                                System.out.println("0对1默认为多对1"
                                        + clazz.getName() + " 中Field "
                                        + fieldClazzSimpleName);

                                // 110
                                break;
                            } else if (otherString.equals("1")) {
                                logger.debug("1对1");
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("111"));
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("110"));
                                System.out.println("1对1请手动指定含外键方  "
                                        + clazz.getName() + " 中Field "
                                        + fieldClazzSimpleName);
                                // 111 或110
                                break;
                            } else if (otherString.equals("n")) {
                                logger.debug("n对1");
                                // n1
                                hbmFileSB.append(xmlBeanCache
                                        .getXMLBeanStr("n1"));
                                break;
                            }

                        }
                    }

                } else if (fieldGenericType instanceof ParameterizedType) {

                    /* 如果是参数化类型 List<User> List<Tie> List<String> */
                    // 得到泛型类java.util.List<cn.lddxfs.tieba.domain.Ba>
                    ParameterizedType pt = (ParameterizedType) fieldGenericType;
                    Type t1Type = pt.getActualTypeArguments()[0];

                    Class t1Clazz = null;
                    if (t1Type instanceof Class) {
                        t1Clazz = (Class) t1Type;
                    }

                    dClazz = t1Clazz;

                    String t1SimpleName = t1Clazz.getSimpleName();

                    String otherString = Other(clazz, t1Clazz);

                    // System.out.print(fieldClazzSimpleName);

                    if (otherString.equals("0")) {
                        System.out.println("0对n默认为1对n" + clazz.getName()
                                + " 中Field " + t1Clazz.getSimpleName());

                        logger.debug("0对n");
                        // 1nList或 1nSet
                        hbmFileSB.append(xmlBeanCache.getXMLBeanStr("1n"
                                + fieldClazzSimpleName));
                    } else if (otherString.equals("1")) {
                        logger.debug("1对n");
                        // 1nList 或1nSet
                        hbmFileSB.append(xmlBeanCache.getXMLBeanStr("1n"
                                + fieldClazzSimpleName));
                    } else if (otherString.equals("n")) {
                        logger.debug("n对n");
                        // nnList 或nnSet
                        hbmFileSB.append(xmlBeanCache.getXMLBeanStr("nn"
                                + fieldClazzSimpleName));

                        String centerTableString = "";
                        if (dClazz.getSimpleName().compareTo(
                                clazz.getSimpleName()) > 0) {
                            centerTableString = dClazz.getSimpleName() + "_"
                                    + clazz.getSimpleName();
                        } else {
                            centerTableString = clazz.getSimpleName() + "_"
                                    + dClazz.getSimpleName();
                        }
                        hbmFileStr = hbmFileSB.toString();
                        hbmFileStr = hbmFileStr.replaceAll("<%centerTable%>",
                                centerTableString);

                        hbmFileSB = new StringBuffer(hbmFileStr);
                    }
                }

                logger.debug("fieldClazzSimpleName=" + fieldClazzSimpleName);
                // 字段上的注释

                // 替换Field 替换field
                hbmFileStr = hbmFileSB.toString();

                hbmFileStr = hbmFileStr
                        .replaceAll("<%field%>", field.getName());
                if (dClazz != null) {
                    hbmFileStr = hbmFileStr.replaceAll("<%Field%>",
                            dClazz.getSimpleName());
                }
                hbmFileSB = new StringBuffer(hbmFileStr);
            }
            System.out.println(" }");

            logger.debug("类" + clazz + "的字段如上=====");
            hbmFileStr = hbmFileSB.toString();
            hbmFileStr += xmlBeanCache.getXMLBeanStr("hbmfoot");
            // 替换Class class
            hbmFileStr = hbmFileStr.replaceAll("<%Class%>",
                    clazz.getSimpleName());
            String clazzSimpleString = clazz.getSimpleName().substring(0, 1)
                    .toLowerCase()
                    + clazz.getSimpleName().substring(1);
            hbmFileStr = hbmFileStr.replaceAll("<%class%>", clazzSimpleString);

            // 循环properties文件
            Set<String> keySet = PROPS.stringPropertyNames();
            Iterator<String> keyIterator = keySet.iterator();
            while (keyIterator.hasNext()) {
                String key = (String) keyIterator.next();
                String value = PROPS.getProperty(key);
                // 用properties文件中的键 值替换文件中相应的内容
                hbmFileStr = hbmFileStr.replaceAll("<%" + key + "%>", value);
            }

            if (classNamehbmFile.exists()) {
                classNamehbmFile.delete();
            }

            // 将hbmFileStr写出到文件
            OutputStreamWriter writer = new OutputStreamWriter(
                    new FileOutputStream(classNamehbmFile), CHARSET_NAME);
            writer.write(hbmFileStr);
            writer.flush();
            writer.close();

        }
        /*
         * // BeanInfo表示该Student对象所有的属性情况 BeanInfo bi =
         * Introspector.getBeanInfo(clazz); // 取得Student对象所有属性集合
         * PropertyDescriptor[] pds = bi.getPropertyDescriptors(); for
         * (PropertyDescriptor pd : pds) { System.out.println(pd.getName()); }
         */
        /*
         * 列出文件名 List<File> fileList = new LinkedList<File>(); listFileName(dir,
         * fileList); Iterator<File> fileListiterator = fileList.iterator();
         * while (fileListiterator.hasNext()) { fileListiterator.next(); }
         */
    }

    /**
     * 获取给定Field类型字段上的java注释
     * 
     * @param field
     * @return
     * @throws FileNotFoundException
     */
    public String getNote(Field field) throws Exception {

        Class fieldClazz = field.getType();
        Class clazz = field.getDeclaringClass();

        // System.out.println("fieldClazz=" + fieldClazz.getSimpleName());

        String pathString = SRC_PATH + clazz.getName().replace('.', '/')
                + ".java";

        logger.debug("pathString=" + pathString);// 打印java文件的路径
        InputStream inputStream = new FileInputStream(pathString);

        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(inputStream, CHARSET_NAME));
        String line;
        StringBuffer stringBuffer = new StringBuffer();
        while ((line = bufferedReader.readLine()) != null) {
            // System.out.println(line);
            stringBuffer.append(line);
        }
        // 得到文件的内容
        String fileContent = stringBuffer.toString();

        String REGEX = "\s+/\*\*[,，\s\*0-9A-Za-zu4e00-u9fa5]+(\*/)?\s*private{1}\s*"
                + fieldClazz.getSimpleName().replaceAll("\[\s*\]", "")
                + "((<[A-Za-z]*>)|(\[[A-Za-z]*\]))*"
                + "\s*"
                + field.getName()
                + "\s*"
                + "(=\s*new\s*[A-Za-z]*\s*<[A-Za-z]*>\s*\(\s*\))?"
                + "\s*;{1}";
        // =new LinkedList<Ba>()
        /* 匹配语法 */
        // private Field field;
        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(fileContent); // 获取 matcher 对象
        int count = 0;
        String remarkString = "";
        while (m.find()) {
            count++;
            remarkString = fileContent.substring(m.start(), m.end());
            logger.debug("finded a remark=" + remarkString);
        }
        if (count != 1) {
            System.out.println("匹配不正确，无法找到方法上注释" + clazz.getName() + "   "
                    + fieldClazz.getName() + " " + field.getName());

        }
        bufferedReader.close();

        return remarkString.substring(0, remarkString.lastIndexOf("*/"))
                .replaceAll("\*", "").replaceAll("/", "").trim();
    }

    // //////////////////////
    @Test
    public void initDataDictory() throws Exception {

        for (String domain_type : DOMAIN_TYPE) {
            // 得到类全限定名
            String className = PACKAGE_Str + "." + domain_type;
            // 得到Class对象
            Class clazz = Class.forName(className);
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (field.getType().equals(DataDictoryValue.class)) {

                    
                    DataDictory dataDictory = new DataDictory();
                    dataDictory.setKeyWord(clazz.getSimpleName()+field.getName());
                    dataDictory.setRemark(clazz.getSimpleName()+getNote(field));
                    
                             
                            
                    System.out.println("INSERT into tiebatb_datadictory(keyWord,remark) VALUES('"+clazz.getSimpleName()+"','"+clazz.getSimpleName()+getNote(field)+"');");
                }
                ;
            }
        }
    }

    /**
     * 列出指定目录下的java文件名
     * 
     * @param file
     *            指定一个目录
     * @param fileList
     *            返回的类名列表 ,无“.java”后缀
     */
    @Deprecated
    public void listFileName(File file, List<File> fileList) {
        if (file == null) {
            return;
        }
        if (file.isDirectory()) {
            File f[] = file.listFiles();
            if (f != null)
                for (int i = 0; i < f.length; i++) {
                    listFileName(f[i], fileList);
                }
        } else {

            if (file.getName().endsWith(".java")) {
                System.out.println(file.getName());

                // fileList.add(str);
            }
        }
    }

    /**
     * 判断名称为fieldClazz的实体中含有多少个clazz类型的Field
     * 
     * @param clazz
     *            A类
     * @param fieldClazz
     *            A类中的Field
     * @return
     */
    public String Other(Class clazz, Class fieldClazz) {

        Field[] oFields = fieldClazz.getDeclaredFields();
        // 获得关联实体上所有的Field并遍历
        for (Field ofield : oFields) {
            Class ofieldClazz = ofield.getType();
            String ofieldClazzSN = ofieldClazz.getSimpleName();

            Type ofieldGenericType = ofield.getGenericType();

            /* 如果是类类型 String Byte[] User */
            if (ofieldGenericType instanceof Class) {
                if (clazz.getSimpleName().equals(ofieldClazzSN)) {
                    // 基本类型
                    // System.out.println("1" + ofieldClazzSN);
                    // 一对一主键
                    return "1";
                    // 一对一外键
                }

            }

            else if (ofieldGenericType instanceof ParameterizedType) {
                /* 如果是参数化类型 List<User> List<Tie> */
                // 得到泛型类java.util.List<cn.lddxfs.tieba.domain.Ba>
                ParameterizedType pt = (ParameterizedType) ofieldGenericType;
                Type t1Type = pt.getActualTypeArguments()[0];

                Class t1Clazz = null;
                if (t1Type instanceof Class) {
                    t1Clazz = (Class) t1Type;
                }

                String t1SimpleName = t1Clazz.getSimpleName();
                if (clazz.getSimpleName().equals(t1SimpleName)) {
                    // 基本类型
                    /*
                     * System.out .println("多" + ofieldClazzSN + " " +
                     * t1SimpleName);
                     */
                    // 一对多1nSet 1nList

                    return "n";
                }

            }

        }
        return "0";
    }

}

你需要将类似以下格式的java文件

package cn.lddxfs.tieba.domain;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * 系统管理员
 */
public class AdminUser {

    /**
     * id
     */
    private Long id;

    /**
     * 用户名
     */
    private String name;

    /**
     * 邮箱，登陆时使用
     */
    private String email;

    /**
     * 密码
     */
    private String password;

    /**
     * UUID用于激活
     */
    private String uuid;

    /**
     * 状态，已经启用，为激活
     */
    private DataDictoryValue status;

    /**
     * 居民身份证
     */
    private String idcard;

    /**
     * 审核了那些吧
     */
    private Set<BaApply> baApply=new HashSet<BaApply>();

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }

    public DataDictoryValue getStatus() {
        return status;
    }

    public void setStatus(DataDictoryValue status) {
        this.status = status;
    }

    public String getIdcard() {
        return idcard;
    }

    public void setIdcard(String idcard) {
        this.idcard = idcard;
    }

    public Set<BaApply> getBaApply() {
        return baApply;
    }

    public void setBaApply(Set<BaApply> baApply) {
        this.baApply = baApply;
    }
}

现在只需要通过junit运行src/generator/DomainGenerator.java中的generatorHBMXML()方法就可以生成 hbm.xml文件了，

本文由 http://www.cnblogs.com/LDDXFS/ 原创，转载请注明本文出处。