写一个工具生成数据库实体类

写一个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("
");
            }
            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 
", 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("
");
        }
        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 自行查看。

完