MyBatis代码生成

<dependency>
	<groupId>org.apache.velocity</groupId>
	<artifactId>velocity-engine-core</artifactId>
	<version>2.2</version>
	<scope>test</scope>
</dependency>
<dependency>
	<groupId>org.apache.velocity</groupId>
	<artifactId>velocity</artifactId>
	<version>1.7</version>
</dependency>

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ApplicationMain.class})
public class MainTest {

    @Test
    public void test() {
        Assert.assertTrue(true);
    }
}

@Slf4j
public class MyBatisGenerator extends MainTest {

    @Resource
    private DataSource dataSource;

    private final Map<String, String> fieldTypeMap = Maps.newHashMap();

    @Before
    public void init() {
        fieldTypeMap.put("bigint", "Long");
        fieldTypeMap.put("int", "Integer");
        fieldTypeMap.put("tinyint", "Integer");
        fieldTypeMap.put("decimal", "BigDecimal");
        fieldTypeMap.put("varchar", "String");
        fieldTypeMap.put("date", "Date");
        fieldTypeMap.put("datetime", "Date");
        fieldTypeMap.put("time", "Date");
    }

    @Test
    public void test() {
        try {
            String tableName = "t_wx_pay_record";
            String mapperPackage = "com.go.relax.core.dao";
            String dataObjectPackage = "com.go.relax.core.dao.data";

            Connection connection = dataSource.getConnection();
            // 数据库名称
            String catalog = connection.getCatalog();
            Statement statement = connection.createStatement();

            Map<String, Object> paramMap = Maps.newHashMap();
            paramMap.put("tableName", tableName);
            paramMap.put("mapperPackage", mapperPackage);
            paramMap.put("dataClassName", CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, tableName));
            paramMap.put("dataObjectPackage", dataObjectPackage);
            String dataObjectClassName = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, tableName) + "DO";
            paramMap.put("dataObjectClassName", dataObjectClassName);
            String dataObjectFieldName = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, tableName) + "DO";
            paramMap.put("dataObjectFieldName", dataObjectFieldName);
            String mapperClassName = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, tableName) + "Mapper";
            paramMap.put("mapperClassName", mapperClassName);
            List<Map<String, String>> fields = Lists.newArrayList();
            paramMap.put("fields", fields);

            String sql = String.format("select * from information_schema.COLUMNS where TABLE_SCHEMA = '%s' and TABLE_NAME = '%s'", catalog, tableName);

            ResultSet resultSet = statement.executeQuery(sql);
            while (resultSet.next()) {
                String columnName = resultSet.getString("COLUMN_NAME");
                String dataType = resultSet.getString("DATA_TYPE");
                String columnComment = resultSet.getString("COLUMN_COMMENT");
                log.info("{} {} {}", columnName, dataType, columnComment);

                Map<String, String> fieldMap = Maps.newHashMap();
                fieldMap.put("javaFieldName", CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, columnName));
                fieldMap.put("columnName", columnName);
                fieldMap.put("comment", columnComment);
                fieldMap.put("javaType", fieldTypeMap.get(dataType));
                fields.add(fieldMap);
            }
            String dataObjectContent = VelocityUtil.getTemplateContent("dataObject.vm", paramMap);
            log.info("\n\n{}", dataObjectContent);
            log.info("///------------------------------------------");
            String mapperContent = VelocityUtil.getTemplateContent("mapper.vm", paramMap);
            log.info("\n\n{}", mapperContent);
            log.info("///------------------------------------------");
            String mapperXmlContent = VelocityUtil.getTemplateContent("mapper.xml.vm", paramMap);
            log.info("\n\n{}.xml", mapperClassName);
            log.info("\n\n{}", mapperXmlContent);
            log.info("///------------------------------------------");
            String othersContent = VelocityUtil.getTemplateContent("others.vm", paramMap);
            log.info("\n\n{}", othersContent);
        } catch (Exception e) {
            log.error("exception", e);
        }

    }
}

模板引擎

dataObject.vm

import lombok.Data;

import java.util.Date;

@Data
public class $dataObjectClassName {

    #foreach($field in $fields)

    /**
    * $field.comment
    */
    private $field.javaType $field.javaFieldName;
    #end

}

mapper.vm

import java.util.List;

public interface $mapperClassName {

    int insert($dataObjectClassName $dataObjectFieldName);

    $dataObjectClassName getById(Long id);

    List<$dataObjectClassName> queryList();

    int deleteById(Long id);

    int updateById($dataObjectClassName $dataObjectFieldName);
}

mapper.xml.vm

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://www.mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.go.relax.core.dao.$mapperClassName">
    <resultMap id="BaseResultMap" type="$dataObjectPackage.$dataObjectClassName">
        #foreach($field in $fields)
            <result column="$field.columnName" property="$field.javaFieldName"/>
        #end
    </resultMap>

    <sql id="Base_Column_List">
        #foreach($field in $fields)
            $field.columnName #if($foreach.hasNext),#end
        #end
    </sql>

    <sql id="setField">
        <set>
            #foreach($field in $fields)
            <if test="$field.javaFieldName != null">$field.columnName = #{$field.javaFieldName} #if($foreach.hasNext),#end</if>
            #end
        </set>
    </sql>

    <insert id="insert" useGeneratedKeys="true" keyColumn="id"
            parameterType="$dataObjectPackage.$dataObjectClassName">
        <selectKey resultType="java.lang.Long" order="AFTER" keyProperty="id">
            SELECT @@IDENTITY
        </selectKey>
        INSERT INTO $tableName
        <include refid="setField"/>
    </insert>

    <select id="getById" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List"/>
        from $tableName where id = #{id}
    </select>

    <select id="queryList" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List"/>
        from $tableName order by id desc
    </select>

    <delete id="deleteById" parameterType="java.lang.Long">
        delete from $tableName where id = #{id}
    </delete>

    <update id="updateById" parameterType="$dataObjectPackage.$dataObjectClassName">
        UPDATE $tableName
        <include refid="setField"/>
        WHERE id = #{id}
    </update>

</mapper>

others.vm

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/$dataClassName")
public class $!{dataClassName}Controller {

    @Resource
    private $!{dataClassName}Manager $!{dataClassName}Manager;

    @GetMapping("/test")
    public Object queryList() {
        Map<String, Object> resultMap = Maps.newHashMap();

        return Response.successResult(resultMap);
    }
}



@Slf4j
@Component
public class $!{dataClassName}Manager {

    @Resource
    private $!{dataClassName}Mapper $!{dataClassName}Mapper;


    public List<$!{dataClassName}DTO> queryList() {
        List<$!{dataClassName}DO> courseDOS = $!{dataClassName}Mapper.queryAll();
        List<$!{dataClassName}DTO> resultList = Lists.newArrayList();

        return resultList;
    }
}