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

时间 2019-11-17

标签一个工具生成数据库实体栏目 SQL 繁體版

原文原文链接

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

开始写以前的说明

这只是一个简单的解析数据库建表语句以后，根据解析结果生成java文件的一个简单工具。写的缘由有两个。java

1：项目中没有人写实体类的注释，字段的注释，现有的工具也无法根据数据库的注释自动添加到class文件上。mysql

2：本身写一个也彷佛不是很难。git

因此就本身写了一个。github

这里在生成java文件的时候用的是freemarker。用了jdbc做为执行sql的工具。sql

这个项目已经放在github上了，地址：github.com/hjx60149632… 。数据库

用到的依赖：

<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，开始。bash

配置数据库的相关信息

在获取数据库连接前，咱们先写一个文件用来保存数据库连接的各类信息。mvc

新建文件config.xmlapp

<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();
    }
}
复制代码

最后

这里面我只是贴出来了一些要用到的代码片断，没有将全部的代码所有写出来。其实写工具就是一个慢慢实现本身思路的过程，有思路的话一切都很简单。

若是有人须要项目所有代码的话请到 github.com/hjx60149632… 自行查看。

完

其余的

以为我写的还行的话请看看其余的文章吧^_^

本身写一个mvc框架吧