寫一個工具生成數據庫實體類

寫一個java工具從數據庫生成實體類

開始寫之前的說明

​ 這只是一個簡單的解析數據庫建表語句之后，根據解析結果生成java文件的一個簡單工具。寫的原因有兩個。

​ 1：項目中沒有人寫實體類的注釋，字段的注釋，現有的工具也沒法根據數據庫的注釋自動添加到class文件上。

​ 2：自己寫一個也似乎不是很難。

​ 所以就自己寫了一個。

這里在生成java文件的時候用的是freemarker。用了jdbc作為執行sql的工具。

這個項目已經放在github上了，地址：https://github.com/hjx601496320/entityMaker 。

用到的依賴：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

<dependency>
	<groupId>org.freemarker</groupId>
	<artifactId>freemarker</artifactId>
	<version>2.3.28</version>
</dependency>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
</dependency>

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.45</version>
</dependency>

<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>

獲取數據庫中的所有的表名稱

想要根據數據庫中的建表語句來創建java文件首先要先知道數據庫中都有那些表。so，開始。

配置數據庫的相關信息

在獲取數據庫鏈接前，我們先寫一個文件用來保存數據庫鏈接的各種信息。

新建文件config.xml

<xml>
    <jdbc.url></jdbc.url>
    <jdbc.username></jdbc.username>
    <jdbc.password></jdbc.password>
</xml>

jdbc.url：鏈接數據庫的url。例如：jdbc:mysql://127.0.0.1:3306/demo?useSSL=true

jdbc.username：數據庫的用戶名。

jdbc.password：數據庫的密碼。

這樣就配置好了。

寫一個工具類讀取xml：XmlUtils.java

import org.w3c.dom.Document;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Scanner;

/**
 * 讀取xml
 */
public class XmlUtils {

    /**
     * 讀取 Document
     *
     * @param xmlPath
     * @return
     */
    public static Document getConfigDocument(String xmlPath) {
        try {
            InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(xmlPath);
            Scanner scanner = new Scanner(resourceAsStream);
            StringBuilder stringBuilder = new StringBuilder();
            while (scanner.hasNextLine()) {
                stringBuilder.append(scanner.nextLine()).append("\n");
            }
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilde = documentBuilderFactory.newDocumentBuilder();
            Document document = documentBuilde.parse(new ByteArrayInputStream(stringBuilder.toString().getBytes()));
            return document;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

打開數據庫鏈接

//獲取數據庫配置信息
Document configXml = XmlUtils.getConfigDocument(CONFIG_PATH);
Element element = configXml.getDocumentElement();
String jdbcUrl = element.getElementsByTagName("jdbc.url").item(0).getTextContent();
String username = element.getElementsByTagName("jdbc.username").item(0).getTextContent();
String password = element.getElementsByTagName("jdbc.password").item(0).getTextContent();
//打開數據庫鏈接
Connection conn = (Connection) DriverManager.getConnection(jdbcUrl, username, password);

獲取到鏈接之后，下一步就是要讀取數據庫中的表數據了。

獲取數據庫中的表

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SHOW TABLES;");
while (resultSet.next()) {
	//這里就獲取到了數據庫中的所有的表的名稱了。
	String tableName = resultSet.getString(1);
}

這里拿到表名稱后就可以依次得到建表語句，並解析建表語句了。

這里之所以使用解析建表語句的方法是因為這樣可以比較完整的得到注釋信息。用另一種方法的時候表的注釋一直獲取不到（另一種方法我忘記怎么說了～）。

得到建表語句

這里就是拼接sql，然后執行就好了。下面是代碼：

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("show CREATE TABLE 表名稱");
while (resultSet.next()) {
	//這里就得到了表的建表語句
	String createTableSql = resultSet.getString(2);
}

做到這一步，我們就完整的得到了數據庫中的所有的建表語句了。接下來就是要分析建表語句並且用來生成實體類了。

建表語句分析

建表sql

下面是執行 sql show create table user 的結果：

CREATE TABLE `user` (                                                            
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用戶id',                         
  `name` varchar(225) DEFAULT NULL COMMENT '用戶名',                             
  `create_date` datetime DEFAULT NULL,                                           
  `status` int(11) DEFAULT NULL,                                                 
  `age` int(11) DEFAULT NULL COMMENT '年齡',                                     
  `mark` varchar(225) DEFAULT NULL,                                              
  PRIMARY KEY (`id`)                                                             
) ENGINE=InnoDB AUTO_INCREMENT=2104778081 DEFAULT CHARSET=latin1 COMMENT='用戶表'          

這里可以看出，要創建的實體類的名稱就在第一行的CREATE TABLE 后的兩個`符號中間，這樣我們就可以通過正則將表的名稱取出來，然后轉換成為我們需要的class名稱。首先我們先寫一個通過正則提取數據的方法，下面是代碼：

正則代碼

    /**
     * 根據正則查找
     *
     * @param sql
     * @param pattern
     * @param group
     * @return
     */
    static String getByPattern(String sql, String pattern, int group) {
        Pattern compile = Pattern.compile(pattern);
        Matcher matcher = compile.matcher(sql);
        while (matcher.find()) {
            return matcher.group(group);
        }
        return null;
    }

現在開始從建表語句中提取table的名稱（雖然在獲得數據庫所有表的時候就已經知道了，但是在寫一次也沒有什么問題不是嗎 ~~~），下面是代碼：

獲取表的名稱

    /**
     * 獲得表的名稱
     *
     * @param sql
     * @return
     */
    public static String getTableName(String sql) {
        return getByPattern(sql, "CREATE TABLE `(.*)`", 1);
    }

這里就已經將表的名稱取出來了。
接下來是獲取表上的注釋，這里我們取表的注釋。下面是代碼：

提取表注釋

    public static String getTableComment(String sql) {
        return getByPattern(sql, "\\) .* COMMENT='(.*)'", 1);
    }

現在開始獲取id信息。

獲取id

獲取id依然是使用正則就好了，代碼如下：

public static String getId(String sql) {
    return getByPattern(sql, "PRIMARY KEY \\(`(.*)`\\)", 1);
}

因為原本語句中有一對括號，所以在這里對外面的括號做了轉義處理。接下來開始提取數據庫中的字段，字段類型，字段注釋。

字段，字段類型，字段注釋

先取出來建表語句中的和字段相關的sql

2019年01月21日，修改：

沒想到有的表里沒有id，就導致下面的代碼執行后出錯了，修改一下結束的判斷。

    /**
     * 獲取建表語句中和字段相關的sql
     *
     * @param sql
     * @return
     */
    public static List<String> getColumnSqls(String sql) {
        List<String> lines = new ArrayList<>();
        Scanner scanner = new Scanner(sql);
        boolean start = false;
        while (scanner.hasNextLine()) {
            String nextLine = scanner.nextLine();
            if (nextLine.indexOf("CREATE TABLE") != -1) {
                start = true;
                continue;
            }
            //沒想到有的表沒有id /(ㄒoㄒ)/~~
            if (nextLine.indexOf("PRIMARY KEY") != -1 || nextLine.indexOf("ENGINE=") != -1) {
                start = false;
                continue;
            }
            if (start) {
                lines.add(nextLine);
            }
        }
        return lines;
    }

這里的運行結果是：

  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用戶id',                         
  `name` varchar(225) DEFAULT NULL COMMENT '用戶名',                             
  `create_date` datetime DEFAULT NULL,                                           
  `status` int(11) DEFAULT NULL,                                                 
  `age` int(11) DEFAULT NULL COMMENT '年齡',                                     
  `mark` varchar(225) DEFAULT NULL, 

這也就取到了table中所有的字段相關信息了，接下來我們來獲取字段名稱：

獲取列名，注釋，數據類型

List<String> columns = SqlUtils.getColumnSqls(sql);
for (String oneLine : columns) {
    System.out.println(oneLine);
    String columnName = SqlUtils.getByPattern(oneLine, "`(.*)`", 1);
    String comment = SqlUtils.getByPattern(oneLine, "COMMENT '(.*)'", 1);
    String columnType = SqlUtils.getByPattern(oneLine, "`" + columnName + "` ([A-Za-z]*)", 1);
    System.out.printf("名稱：%-20s 類型：%-20s 注釋：%-20s \n", columnName, columnType, comment);
}

輸出結果：

  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用戶id',                         
名稱：id                   類型：int                  注釋：用戶id                 
  `name` varchar(225) DEFAULT NULL COMMENT '用戶名',                             
名稱：name                 類型：varchar              注釋：用戶名                  
  `create_date` datetime DEFAULT NULL,                                           
名稱：create_date          類型：datetime             注釋：null                 
  `status` int(11) DEFAULT NULL,                                                 
名稱：status               類型：int                  注釋：null                 
  `age` int(11) DEFAULT NULL COMMENT '年齡',                                     
名稱：age                  類型：int                  注釋：年齡                   
  `mark` varchar(225) DEFAULT NULL,                                              
名稱：mark                 類型：varchar              注釋：null

到了這，我就就已經從建表語句里拿到了所有需要的數據了，下面就開始使用這些數據來生成java文件了。

根據上面獲取的數據開始創建java文件

終於開始要創建java文件了。

但是～在創建java文件的時候要先吧之前獲取的數稍微處理一下，將sql中的格式轉換為java中的格式。比如屬性名稱，數據類型，class名稱之類的，現在開始～

將表名稱轉換為合適的class名稱

就是首字母大寫，駝峰式的命名規范。例如將user_log或者USER_LOG轉換為UserLog。

我們可以這么寫：

    /**
     * 類名稱轉換
     *
     * @param tableName
     * @return
     */
    public static String entityName(String tableName) {
        String lowerCaseName = tableName.toLowerCase();
        StringBuilder newName = new StringBuilder();
        char[] chars = lowerCaseName.toCharArray();
        boolean change = false;
        for (int i = 0; i < chars.length; i++) {
            char aChar = chars[i];
            if (aChar == '_' && !change) {
                change = true;
                continue;
            }
            //首字母大寫
            if (i == 0) {
                aChar = Character.toUpperCase(aChar);
            }
            if (change) {
                aChar = Character.toUpperCase(aChar);
                change = false;
            }
            newName.append(aChar);
        }
        return newName.toString();
    }

這樣就得到了我們需要的class的名稱了。

將字段名稱轉換為java中的屬性名稱

這里就是將上一步操作的首字母大寫去掉就好了，下面是代碼：

    /**
     * 屬性名稱轉換
     *
     * @param name
     * @return
     */
    public static String fieldName(String name) {
        name = name.toLowerCase();
        StringBuilder newName = new StringBuilder();
        char[] chars = name.toCharArray();
        boolean change = false;
        for (int i = 0; i < chars.length; i++) {
            char aChar = chars[i];
            if (aChar == '_' && !change) {
                change = true;
                continue;
            }
            if (change) {
                aChar = Character.toUpperCase(aChar);
                change = false;
            }
            newName.append(aChar);
        }
        return newName.toString();
    }

接下來是將sql中的數據類型轉換為java中的數據類型。

sql數據類型轉換

這里用map做了一個映射，有自己特定要求的可以自己修改。

public class ColumnFieldTypeMapping {

    private Map<String, Class> sqlFieldTypeMapping = new HashMap<>();

    {
        sqlFieldTypeMapping.put("VARCHAR", String.class);
        sqlFieldTypeMapping.put("CHAR", String.class);
        sqlFieldTypeMapping.put("TEXT", String.class);
        sqlFieldTypeMapping.put("MEDIUMTEXT", String.class);
        sqlFieldTypeMapping.put("LONGTEXT", String.class);
        sqlFieldTypeMapping.put("TINYTEXT", String.class);
        sqlFieldTypeMapping.put("BIT", Boolean.class);

        sqlFieldTypeMapping.put("INT", int.class);
        sqlFieldTypeMapping.put("BIGINT", long.class);
        sqlFieldTypeMapping.put("DOUBLE", double.class);
        sqlFieldTypeMapping.put("TINYINT", int.class);
        sqlFieldTypeMapping.put("FLOAT", float.class);
        sqlFieldTypeMapping.put("DECIMAL", BigDecimal.class);

        sqlFieldTypeMapping.put("INT UNSIGNED", int.class);
        sqlFieldTypeMapping.put("BIGINT UNSIGNED", int.class);
        sqlFieldTypeMapping.put("DECIMAL UNSIGNED", BigDecimal.class);

        sqlFieldTypeMapping.put("DATETIME", Date.class);
        sqlFieldTypeMapping.put("TIME", Date.class);
        sqlFieldTypeMapping.put("DATE", Date.class);
        sqlFieldTypeMapping.put("TIMESTAMP", Date.class);
    }

    /**
     * 根據sql數據類型獲取Java數據類型
     *
     * @param columnType
     * @return
     */
    public Class getFieldType(String columnType) {
        Class aClass = sqlFieldTypeMapping.get(columnType);
        if (aClass == null) {
            return sqlFieldTypeMapping.get(columnType.toUpperCase());
        }
        return null;
    }
}

寫到這里，所有參與生成java文件的信息就已經獲取完成了。

這時候我們需要把他們組裝起來，用來放進freemarker中來解析並生成java文件中的內容。

組裝參數

這里可能我以后用這個代碼干別的事情所以我建了兩個類，一個是ClassModel.java，一個是EntityModel.java。

EntityModel繼承了ClassModel。我們主要用的是EntityModel.java。下面是代碼：

import java.util.*;

/**
 * 用於生成java Entity文件的類
 */
public class ClassModel {

    /**
     * java 中不需要引包的類型
     */
    private static List<Class> baseClass = Arrays.asList(
            int.class,
            double.class,
            float.class,
            long.class,
            short.class,
            byte.class,
            char.class,
            boolean.class,
            String.class
    );

    /**
     * 類注釋
     */
    private String classDoc;

    /**
     * 類名
     */
    private String className;

    /**
     * 類 包名
     */
    private String packageName;

    /**
     * K:屬性名稱
     * V:屬性類型
     */
    private Map<String, Class> fields = new HashMap<>();

    /**
     * 屬性的注釋
     */
    private Map<String, String> fieldDoc = new HashMap<>();
    ;

    private List<Class> imports = new ArrayList<>();

    /**
     * 添加需要導入的包
     *
     * @param importClass
     */
    public void addImport(Class importClass) {
        if (baseClass.indexOf(importClass) != -1) {
            return;
        }
        if (imports.indexOf(importClass) == -1) {
            imports.add(importClass);
        }
    }

    /**
     * 添加屬性
     *
     * @param fieldName  屬性名稱
     * @param fieldClass 屬性類型
     */
    public void addfield(String fieldName, Class fieldClass) {
        if (!fields.containsKey(fieldName)) {
            fields.put(fieldName, fieldClass);
        }
    }

    /**
     * 添加屬性注釋
     *
     * @param fieldName 屬性名稱
     * @param fieldDoc  屬性注釋
     */
    public void addfieldDoc(String fieldName, String fieldDoc) {
        if (!this.fieldDoc.containsKey(fieldName)) {
            this.fieldDoc.put(fieldName, fieldDoc);
        }
    }

    public List<Class> getImports() {
        return imports;
    }

    public void setImports(List<Class> imports) {
        this.imports = imports;
    }

    public String getClassDoc() {
        return classDoc;
    }

    public void setClassDoc(String classDoc) {
        this.classDoc = classDoc;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getPackageName() {
        return packageName;
    }

    public void setPackageName(String packageName) {
        this.packageName = packageName;
    }

    public Map<String, Class> getFields() {
        return fields;
    }

    public void setFields(Map<String, Class> fields) {
        this.fields = fields;
    }

    public Map<String, String> getFieldDoc() {
        return fieldDoc;
    }

    public void setFieldDoc(Map<String, String> fieldDoc) {
        this.fieldDoc = fieldDoc;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("{");
        sb.append("            \"classDoc\"=\"").append(classDoc).append('\"');
        sb.append(",             \"className\"=\"").append(className).append('\"');
        sb.append(",             \"packageName\"=\"").append(packageName).append('\"');
        sb.append(",             \"fields\"=").append(fields);
        sb.append(",             \"fieldDoc\"=").append(fieldDoc);
        sb.append(",             \"imports\"=").append(imports);
        sb.append('}');
        return sb.toString();
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 數據庫映射
 */
public class EntityModel extends ClassModel {

    /**
     * 數據庫名稱
     */
    private String tableName;

    /**
     * 數據庫中的Id字段名稱
     */
    private List<String> idColumnNames = new ArrayList<>();

    /**
     * 類屬性名對應數據庫字段映射
     * key: class 屬性名稱
     * value：數據庫字段名
     */
    private Map<String, String> fieldSqlName = new HashMap<>();

    /**
     * 添加class 屬性映射和 數據庫 字段映射
     *
     * @param fieldName
     * @param sqlName
     */
    public void addfieldSqlName(String fieldName, String sqlName) {
        if (!fieldSqlName.containsKey(fieldName)) {
            fieldSqlName.put(fieldName, sqlName);
        }
    }

    /**
     * 添加id字段名
     *
     * @param idColumnName
     */
    public void addIdColumnName(String idColumnName) {
        idColumnNames.add(idColumnName);
    }

    public String getTableName() {
        return tableName;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    public Map<String, String> getFieldSqlName() {
        return fieldSqlName;
    }

    public void setFieldSqlName(Map<String, String> fieldSqlName) {
        this.fieldSqlName = fieldSqlName;
    }

    public List<String> getIdColumnNames() {
        return idColumnNames;
    }

    public void setIdColumnNames(List<String> idColumnNames) {
        this.idColumnNames = idColumnNames;
    }
}

在這里將從數據庫中得到的數據都組裝好，就可以使用freemarker來生成Java文件的內容了。下面是代碼：

/**
 * 根據建表語句組裝EntityModel
 *
 * @param createTableSql
 * @return
 */
EntityModel makeModelBySql(String createTableSql) {
    Formatter formatter = new Formatter();
    EntityModel model = new EntityModel();
    String tableComment = SqlUtils.getTableComment(createTableSql);
    String tableName = SqlUtils.getTableName(createTableSql);
    String id = SqlUtils.getId(createTableSql);
    model.addIdColumnName(id);
    model.setClassName(NameConvert.entityName(tableName));
    model.setTableName(tableName);
    //注釋是null的時候用數據庫表名作為注釋
    model.setClassDoc(tableComment == null ? tableName : tableComment);
    List<String> line = SqlUtils.getColumnSqls(createTableSql);
    for (String oneLine : line) {
        String columnName = SqlUtils.getByPattern(oneLine, "`(.*)`", 1);
        String comment = SqlUtils.getByPattern(oneLine, "COMMENT '(.*)'", 1);
        String columnType = SqlUtils.getByPattern(oneLine, "`" + columnName + "` ([A-Za-z]*)", 1);
        String fieldName = NameConvert.fieldName(columnName);
        Class fieldClass = columnFieldTypeMapping.getFieldType(columnType);
        if (fieldClass == null) {
            formatter.format("table:%s columnName:%s sql類型:%s 沒有映射類型", tableName, columnName, columnType);
            throw new UnsupportedOperationException(formatter.toString());
        }
        model.addfield(fieldName, fieldClass);
        //字段注釋是null的時候用數據庫字段名作為注釋
        model.addfieldDoc(fieldName, comment == null ? columnName : comment);
        model.addfieldSqlName(fieldName, columnName);
        model.addImport(fieldClass);
    }
    return model;
}

這樣一個我們需要的參數就組裝好了。現在開始編寫freemarker用的代碼。

freemarker工具類

用來加載freemarker模板和處理模板中的參數。FreeMarkerUtils.java,代碼如下：

import freemarker.cache.StringTemplateLoader;
import freemarker.template.Configuration;
import freemarker.template.DefaultObjectWrapper;
import freemarker.template.Template;

import java.io.StringWriter;
import java.io.Writer;
import java.util.Locale;
import java.util.Scanner;

public class FreeMarkerUtils {

    /**
     * freemarker工具，
     *
     * @param subjectParams
     * @param templetPath
     * @return
     * @throws Exception
     */
    public static String getJavaClass(Object subjectParams, String templetPath) throws Exception {
        StringTemplateLoader loader = new StringTemplateLoader();
        Scanner scanner = new Scanner(Thread.currentThread().getContextClassLoader().getResourceAsStream(templetPath));
        StringBuilder builder = new StringBuilder();
        while (scanner.hasNext()) {
            builder.append(scanner.nextLine()).append("\n");
        }
        String name = System.currentTimeMillis() + "";
        loader.putTemplate(name, builder.toString());
        //第一步：實例化Freemarker的配置類
        Configuration conf = new Configuration();
        conf.setObjectWrapper(new DefaultObjectWrapper());
        conf.setLocale(Locale.CHINA);
        conf.setDefaultEncoding("utf-8");
        conf.setTemplateLoader(loader);
        //處理空值為空字符串
        conf.setClassicCompatible(true);
        Template template = conf.getTemplate(name);
        Writer out = new StringWriter(2048);
        template.process(subjectParams, out);
        String javaClass = out.toString();
        return javaClass;
    }
}

現在有了工具類之后，還不能立即開始生成java文件，因為還要繼續設置java的package和生成文件的路徑，這時候我們可以修改之前寫的config.xml

修改config.xml

<xml>
    <jdbc.url></jdbc.url>
    <jdbc.username></jdbc.username>
    <jdbc.password></jdbc.password>
    <basePath>/home/hjx/work/demo/src/main/java</basePath>
    <entityPackage>top.hejiaxuan.demo.entity</entityPackage>
</xml>

這里添加了兩個參數：basePath和entityPackage。一個是要生成java的文件的路徑，一個是java文件的包名。

然后我們再寫一個寫出文件的工具類FileUtils.java

編寫FileUtils.java

import java.io.*;

public class FileUtils {

    /**
     * 寫入文件
     *
     * @param path    文件路徑
     * @param content 文件內容
     */
    public static void write(String path, String content) {
        File file = new File(path);
        File parentFile = file.getParentFile();
        try {
            if (!parentFile.exists()) {
                parentFile.mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fileWriter = new FileWriter(file);
            fileWriter.write(content);
            fileWriter.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

這樣就萬事具備，就差生成文件啦。下面就開始啦～～～

開始生成java文件

在生成文件前，我們還需要把basePath，entityPackage從配置文件里取出來，這一步我就不寫了～～

static final String DOT = ".";

static final String FILE_TYPE = ".java";

static final String ENTITY_TEMPLET_PATH = "EntityTemp.ftl";

/**
 * 用於生成一個類文件
 *
 * @param entityModel
 * @return
 */
boolean makeOneClass(EntityModel entityModel) {
    entityModel.setPackageName(entityPackage);
    String filePath = basePath + "/" + entityPackage.replace(DOT, "/") + "/" + entityModel.getClassName() + FILE_TYPE;
    try {
        String javaClassString = FreeMarkerUtils.getJavaClass(entityModel, ENTITY_TEMPLET_PATH);
        FileUtils.write(filePath, javaClassString);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

好啦～～～大功告成。

額～～～

好像少點啥～～～

模板文件沒有放出來～～～

編寫EntityTemp.ftl

package ${packageName};

<#--導入的包-->
<#list imports as import>
import ${import.name};
</#list>

<#--類名-->
<#if classDoc?length gt 0>
/**
 * ${classDoc}
 * @author hejiaxuan
 */
</#if>
public class ${className} {

<#--屬性名稱-->
<#list fields?keys as key>
    <#assign  fieldDocStr = fieldDoc[key]>
    <#if fieldDocStr?length gt 0>
    /**${fieldDocStr}*/
    </#if>
    <#if idColumnNames?seq_contains(fieldSqlName[key])>
    </#if>
    private ${fields[key].simpleName} ${key};

</#list>
<#list fields?keys as key>
    <#assign  fieldClass = fields[key].simpleName>
<#--setter-->
    public void set${key?cap_first}(${fieldClass} ${key}) {
        this.${key} = ${key};
    }

<#--getter-->
    public ${fieldClass} <#if fieldClass="boolean">is<#else>get</#if>${key?cap_first}() {
        return this.${key};
    }

</#list>

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("[");
<#list fields?keys as key>
        sb.append("${key}:").append(${key}).append(";    ");
</#list>
        sb.append("]");
        return sb.toString();
    }
}

最后

​ 這里面我只是貼出來了一些要用到的代碼片段，沒有將所有的代碼全部寫出來。其實寫工具就是一個慢慢實現自己思路的過程，有思路的話一切都很簡單。

​ 如果有人需要項目全部代碼的話請到 https://github.com/hjx601496320/entityMaker 自行查看。

完