IDEA插件Easy code逆向工程模板使用

chancui9673

已于 2022-03-04 10:51:04 修改

阅读量2.2k

点赞数 2

分类专栏：开发工具使用常见功能积累文章标签： intellij-idea java intellij idea

于 2021-10-22 11:30:53 首次发布

本文链接：https://blog.csdn.net/chancui9673/article/details/120901369

版权

常见功能积累同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

开发工具使用

3 篇文章 0 订阅

订阅专栏

第一步：idea安装EasyCode

ctrl+alt+s --> 选择Plugins --> 安装Easy Code插件 --> 安装之后注意重启idea！

第二步：配置数据库添加数据源

连接数据库，注意下面的Database要么不填写，要么就必须填写你数据库中对应的数据库名哦！！

ps

如果连接mysql失败,切换mysql版本为5.1即可

之后等待idea最下面的显示加载完成

最后就把数据源添加好了哦~~

第三步：配置代码生成器

ctrl+alt+s --> 设置模板 , 先自定义一个分组存放自己需要设置的模板

添加所需要设置的模板块类型名

右边部分就是我们需要设置的模板代码内容

设置完之后生成模板

首先选中所有的表，然后右键单击，选择 Easy Code->Generate Code，如下：

生成模板的的路径

模板的帮助文档(根据下面的规则配置模板)

说明文档：
属性
$author 设置中的作者 java.lang.String
$encode 设置的编码 java.lang.String
$modulePath 选中的module路径 java.lang.String
$projectPath 项目绝对路径 java.lang.String

对象
$tableInfo 表对象
obj 表原始对象 com.intellij.database.model.DasTable
name 表名（转换后的首字母大写）java.lang.String
comment 表注释 java.lang.String
fullColumn 所有列 java.util.List<ColumnInfo>
pkColumn 主键列 java.util.List<ColumnInfo>
otherColumn 其他列 java.util.List<ColumnInfo>,除主键以外的列
savePackageName 保存的包名 java.lang.String
savePath 保存路径 java.lang.String
saveModelName 保存的model名称 java.lang.String
columnInfo 列对象
obj 列原始对象 com.intellij.database.model.DasColumn
name 列名（首字母小写） java.lang.String
comment 列注释 java.lang.String
type 列类型（类型全名） java.lang.String
shortType 列类型（短类型） java.lang.String
custom 是否附加列 java.lang.Boolean
ext 附加字段（Map类型） java.lang.Map<java.lang.String, java.lang.Object>
$tableInfoList java.util.List<TableInfo>所有选中的表
$importList 所有需要导入的包集合 java.util.Set<java.lang.String>

回调
&callback setFileName(String) 设置文件储存名字
setSavePath(String) 设置文件储存路径，默认使用选中路径

工具
$tool
firstUpperCase(String name) 首字母大写方法
firstLowerCase(String name) 首字母小写方法
getClsNameByFullName(String fullName) 通过包全名获取类名
getJavaName(String name) 将下划线分割字符串转驼峰命名(属性名)
getClassName(String name) 将下划线分割字符串转驼峰命名(类名)
hump2Underline(String str) 将驼峰字符串转下划线字符串
append(Object... objs) 多个数据进行拼接
newHashSet(Object... objs) 创建一个HashSet对象
newArrayList(Object... objs) 创建一个ArrayList对象
newLinkedHashMap() 创建一个LinkedHashMap()对象
newHashMap() 创建一个HashMap()对象
getField(Object obj, String fieldName) 获取对象的属性值,可以访问任意修饰符修饰的属性.配合debug方法使用.
call(Object... objs) 空白执行方法,用于调用某些方法时消除返回值
debug(Object obj) 调式方法,用于查询对象结构.可查看对象所有属性与public方法
serial() 随机获取序列化的UID
service(String serviceName, Object... param)远程服务调用
parseJson(String) 将字符串转Map对象
toJson(Object, Boolean) 将对象转json对象，Boolean：是否格式化json，不填时为不格式化。
toUnicode(String, Boolean) 将String转换为unicode形式，Boolean：是否转换所有符号，不填时只转换中文及中文符号。
$time
currTime(String format) 获取当前时间，指定时间格式（默认：yyyy-MM-dd HH:mm:ss）
$generateService
run(String, Map<String,Object>) 代码生成服务，参数1：模板名称，参数2：附加参数。

自己配置的常用模板如下

dao.java模板

##定义初始变量
#set($tableName = $tool.append($tableInfo.name, "Dao"))
##设置回调
$!callback.setFileName($tool.append($tableName, ".java"))
$!callback.setSavePath($tool.append($tableInfo.savePath, "/dao"))


##拿到主键
#if(!$tableInfo.pkColumn.isEmpty())
    #set($pk = $tableInfo.pkColumn.get(0))
#end

#if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}dao;

import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * $!{tableInfo.comment}($!{tableInfo.name})表数据库访问层service
 *
 * @author lyz
 * @since 创建时间 $!time.currTime()
 */
 
@Component
public interface $!{tableName} {
   /**
     * 通过Id查询单个
     * @param $!pk.name
     * @return
     */
    $!{tableInfo.name} getById($!pk.shortType $!pk.name);
    
   /**
     * 通过实体不为空的属性作为筛选条件查询列表,实体为null(为空)则查询当前表的所有数据出来
     * ps:
     *      list列表多条数据,用list集合装
     *      可以根据实体里的全部属性活某个属性作为筛选调教查询列表
     * @param $!tool.firstLowerCase($!{tableInfo.name})
     * @return
     */
    List<$!{tableInfo.name}> listByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

   /**通过实体不为空的属性作为筛选条件查询单个
     * ps:
     *  实体只能有一条数据,所以不能查询出多条数据,要不然会报错
     *   实体不能为空,要不然就把当前表的所有数据查询出来了,因为实体为null所有查询出多条数据,然后一个实体装不下导致报错,
     * @param $!tool.firstLowerCase($!{tableInfo.name})
     * @return
     */
    $!{tableInfo.name} getByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

   /**
     * 通过Id列表作为筛选条件批量查询列表，列表长度不为0
     * ps:
     *  传入list集合到mybatis进行批量查询
     * @param list
     * @return
     */

    List<$!{tableInfo.name}> listByIds(List<$!pk.shortType> list);


   /**
     * 查询指定行数据
     *  简单的分页数据看查询
     * @param offset 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<$!{tableInfo.name}> queryAllByLimit(@Param("offset") int offset, @Param("limit") int limit);
    
   /**
     * 新增实体属性不为null的数据,进数据库里
     * ps:
     *      单条数的插入
     * @param $!tool.firstLowerCase($!{tableInfo.name})
     * @return
     */
    int insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
   /**
     * 批量新增所有列，列表长度不能为0，且列表id统一为null或者统一不为null-
     * ps:
     *      多条数据的插入
     *      缺点:
     *      数据量大的话拼接成一条sql语句,会出现就会很长,导致执行数据库差
     *      列如:1,2,3,,4,5拼接成一条sql的insert执行
     * @param list
     * @return
     */

    int insertBatch(List<$!{tableInfo.name}> list);
    
    
    
   /**
     * 分批批量新增数据
     * ps:
     *      把数据分成几个insert,几个insert执行
     *      列如:1,2,3,4,5进行分成两个数据批操作第一次insert里执行1,2两条数据,第二次insert里执行3,4两条数据,
     *      第三次insert里不满两条数据就只执行5这一条数据
     * @param list
     * @return
     */
    int insertPartial(List<$!{tableInfo.name}> list);
    
   /**
     * 通过主键id作为筛选条件进行修改该id对应的实体属性数据
     * @param $!tool.firstLowerCase($!{tableInfo.name})
     * @return
     */

    int update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
   /**
     * 以where对象里的属性作为筛选条件,修改当前表的set里的每个属性对应的表字段
     * @param where
     * @param set
     * @return
     */
    int updateByField(@Param("where") $!{tableInfo.name} where, @Param("set") $!{tableInfo.name} set);
   /**
     * 以id作为筛选条件,进行批量修改数据
     * 根据list集合里的id为筛选条件,进行修改该id对应的实体属性数据
     * @param list
     * @return
     */
    int updateBatch(List<$!{tableInfo.name}> list);
   /**
     * 通过主键删除
     * @param $!pk.name
     * @return
     */
    int deleteById($!pk.shortType $!pk.name);
    
    /**
     *   以实体非空属性作为条件,删除实体属性对应的表字段
     * @param $!tool.firstLowerCase($!{tableInfo.name})
     * @return
     */
    int deleteByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  
   /**
     * 通过ids集合作为筛选条件,批量删除,和id对应每一行数据
     * @param list
     * @return
     */
    int deleteByIds(List<$!pk.shortType> list);
   /**
     * 当前表有多少条数据
     * @return
     */
    int countAll();
   /**
     * 以当前实体不为空的数据作为筛选条件,统计有多少条数据,
     *  ps:
     *  如果想一某一个属性作为统计条件的话,那就在xml中删除掉不需要的属性即可
     * @param a
     * @return
     */
    int countByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
    
}

mapper.xml模板

##引入mybatis支持
$!mybatisSupport

##设置保存名称与保存位置
$!callback.setFileName($tool.append($!{tableInfo.name}, "Mapper.xml"))
$!callback.setSavePath($tool.append($modulePath, "/src/main/resources/mapper"))

##拿到主键
#if(!$tableInfo.pkColumn.isEmpty())
    #set($pk = $tableInfo.pkColumn.get(0))
#end

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="$!{tableInfo.savePackageName}.dao.$!{tableInfo.name}Dao">

    <resultMap type="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}" id="$!{tableInfo.name}ResultMap">
#foreach($column in $tableInfo.fullColumn)
        <result property="$!column.name" column="$!column.obj.name" jdbcType="$!column.ext.jdbcType"/>
#end
    </resultMap>

    <sql id="table_field">
      #allSqlColumn()
      
    </sql>
       
    <!--通过Id查询单个-->
    <select id="getById" resultMap="$!{tableInfo.name}ResultMap" parameterType="$pk.type">
        select
          <include refid="table_field" />
        from $!tableInfo.obj.name
        where $!pk.obj.name = #{$!pk.name,jdbcType=$!pk.ext.jdbcType}
    </select>


    <!--通过实体不为空的属性作为筛选条件查询列表-->
    <select id="listByEntity" resultMap="$!{tableInfo.name}ResultMap" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}">
        select
          <include refid="table_field" />
        from $!tableInfo.obj.name
        <where>
#foreach($column in $tableInfo.fullColumn)
            <if test="$!column.name != null">
                and $!column.obj.name = #{$!column.name,jdbcType=$!column.ext.jdbcType}
            </if>
#end
        </where>
    </select>

    <!--通过实体不为空的属性作为筛选条件查询单个-->
    <select id="getByEntity" resultMap="$!{tableInfo.name}ResultMap" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}">
        select
          <include refid="table_field" />
        from $!tableInfo.obj.name
        <where>
#foreach($column in $tableInfo.fullColumn)
            <if test="$!column.name != null">
                and $!column.obj.name = #{$!column.name,jdbcType=$!column.ext.jdbcType}
            </if>
#end
        </where>
    </select>

    <!--通过Id列表作为筛选条件查询列表，列表长度不为0-->
    <select id="listByIds" resultMap="$!{tableInfo.name}ResultMap" parameterType="list">
        select
          <include refid="table_field" />
        from $!tableInfo.obj.name
        where $!pk.obj.name in
        <foreach item="item" collection="list" separator="," open="(" close=")" index="index">
            #{item}
        </foreach>
    </select>
    
    
    
    xml


        <!--查询指定行数据   简单的分页数据查询-->
    <select id="queryAllByLimit" resultMap="BaseResultMap">
        select
          #allSqlColumn()

        from $!{tableInfo.obj.parent.name}.$!tableInfo.obj.name
        limit #{offset}, #{limit}
    </select>




    <!--新增实体属性不为null的列-->
    <insert id="insert" keyProperty="$!pk.name" useGeneratedKeys="true" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}">
        insert into $!{tableInfo.obj.name}
        <trim prefix="(" suffix=")" suffixOverrides=",">
#foreach($column in  $tableInfo.fullColumn)
          <if test="$!column.name != null">
             $!column.obj.name,
          </if>
#end          
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
#foreach($column in  $tableInfo.fullColumn)
          <if test="$!column.name != null">
             #{$!column.name,jdbcType=$!column.ext.jdbcType},
          </if>
#end
        </trim>
    </insert>

    <!--批量新增所有列，列表长度不能为0，且列表id统一为null或者统一不为null-->
    <insert id="insertBatch" keyProperty="$!pk.name" useGeneratedKeys="true" parameterType="list">
        insert into $!{tableInfo.obj.name}
         (#foreach($column in $tableInfo.fullColumn)$!{column.obj.name}#if($velocityHasNext), #end#end)
        values
        <foreach item="item" collection="list" separator="," open="" close="" index="index">
         (#foreach($column in $tableInfo.fullColumn)#{item.$!{column.name}}#if($velocityHasNext), #end#end)
        </foreach>
    </insert>
    
    <insert id="insertPartial" parameterType="java.util.List">
                insert into $!{tableInfo.obj.name}
         (#foreach($column in $tableInfo.fullColumn)$!{column.obj.name}#if($velocityHasNext), #end#end)
        values
        <foreach collection="list" item="item" separator=",">
         (#foreach($column in $tableInfo.fullColumn)#{item.$!{column.name}}#if($velocityHasNext), #end#end)
        </foreach>
    </insert>

    <!--通过主键修改实体属性不为null的列-->
    <update id="update" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}">
        update $!{tableInfo.obj.name}
        <set>
#foreach($column in $tableInfo.otherColumn)
            <if test="$!column.name != null#if($column.type.equals("java.lang.String")) and $!column.name != ''#end">
                $!column.obj.name = #{$!column.name,jdbcType=$!column.ext.jdbcType},
            </if>
#end
        </set>
        where $!pk.obj.name = #{$!pk.name,jdbcType=$!pk.ext.jdbcType}
    </update>

    <!--通过表字段修改实体属性不为null的列-->
    <update id="updateByField">
        update $!{tableInfo.obj.name}
        <set>
#foreach($column in $tableInfo.otherColumn)
            <if test="where.$!{column.name} == null and set.$!{column.name} != null#if($column.type.equals("java.lang.String")) and set.$!{column.name} != ''#end">
                $!column.obj.name = #{set.$!{column.name},jdbcType=$!column.ext.jdbcType},
            </if>
#end
        </set>
        <where>
#foreach($column in $tableInfo.fullColumn)
            <if test="where.$!{column.name} != null">
                and $!column.obj.name = #{where.$!{column.name},jdbcType=$!column.ext.jdbcType}
            </if>
#end
        </where>
    </update>

    <!--通过主键修改实体列表，列表长度不能为0，注意：当实体属性为null时，对应的列也会别更新为null-->
    <update id="updateBatch" parameterType="list">
        update $!{tableInfo.obj.name}
        <trim prefix="set" suffixOverrides=",">
#foreach($column in $tableInfo.otherColumn)
            <trim prefix="$!{column.obj.name} = case" suffix="end,">
                 <foreach collection="list" item="item" index="index">
                  when $!pk.obj.name = #{item.$!pk.name} then #{item.$!column.name}
                 </foreach>
            </trim>
#end
        </trim>
        where $!pk.obj.name in
        <foreach collection="list" index="index" item="item" separator="," open="(" close=")">
            #{item.$!pk.name,jdbcType=$!pk.ext.jdbcType}
        </foreach>
    </update>
    
    <!--通过主键删除-->
    <delete id="deleteById" parameterType="$pk.type">
        delete from $!{tableInfo.obj.name} where $!pk.obj.name = #{$!pk.name,jdbcType=$!pk.ext.jdbcType}
    </delete>

    <!--通过实体非空属性删除-->
    <delete id="deleteByEntity" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}">
        delete from $!{tableInfo.obj.name}
        <where>
#foreach($column in $tableInfo.otherColumn)
            <if test="$!column.name != null">
                and $!column.obj.name = #{$!column.name,jdbcType=$!column.ext.jdbcType}
            </if>
#end
        </where>
    </delete>
    
    <!--通过主键列表删除，列表长度不能为0-->
    <delete id="deleteByIds" parameterType="list">
        delete from $!{tableInfo.obj.name} where $!pk.obj.name in
        <foreach item="item" collection="list" separator="," open="(" close=")" index="index">
            #{item}
        </foreach>
    </delete>
    
    <select id="countAll" resultType="int">
        select count(*) from $!{tableInfo.obj.name}
    </select>
    
    <select id="countByEntity" parameterType="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}" resultType="int">
        select count(*) from $!{tableInfo.obj.name}
        <where>
#foreach($column in $tableInfo.fullColumn)
            <if test="$!column.name != null">
                and $!column.obj.name = #{$!column.name,jdbcType=$!column.ext.jdbcType}
            </if>
#end
        </where>
    </select>
</mapper>

entity模板（使用lombok）

##引入宏定义
$!define

##使用宏定义设置回调（保存位置与文件后缀）
##"/entity",放实体类的包名
#save("/entity", ".java")

##使用宏定义设置包后缀
#setPackageSuffix("entity")

##使用全局变量实现默认包导入
$!autoImport
import lombok.Data;
#foreach($column in $tableInfo.fullColumn)
    #if($column.type.equals("java.util.Date"))
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
#break
    #end
#end
/**
 * $!{tableInfo.name}表($!{tableInfo.comment}表)的实体类
 *
 * @author lyz
 * @since $!time.currTime()
 */
@Data 
public class $!{tableInfo.name} {
#foreach($column in $tableInfo.fullColumn)
    #if(${column.comment})/**
    * $!{tableInfo.name}表($!{column.name}字段)的注释${column.comment}
    */#end

    #if($column.type.equals("java.util.Date"))
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
#end
    private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
#end

}

service模板

##定义初始变量
#set($tableName = $tool.append($tableInfo.name, "Service"))
##设置回调
$!callback.setFileName($tool.append($tableName, ".java"))
##"/service",放service接口的包名
$!callback.setSavePath($tool.append($tableInfo.savePath, "/service"))

##拿到主键
#if(!$tableInfo.pkColumn.isEmpty())
    #set($pk = $tableInfo.pkColumn.get(0))
#end

#if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}service;

import $!{tableInfo.savePackageName}.dao.$!{tableInfo.name}Dao;
import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};

import java.util.List;

/**
 * $!{tableInfo.comment}($!{tableInfo.name})表服务层service接口
 *
 * @author lyz
 * @since 创建时间 $!time.currTime()
 */

public interface $!{tableName} {
    
    $!{tableInfo.name}Dao get$!{tableInfo.name}Dao();
   
    $!{tableInfo.name} getById($!pk.shortType $!pk.name);

    $!{tableInfo.name} getByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

    List<$!{tableInfo.name}> listByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

    List<$!{tableInfo.name}> listByIds(List<$!pk.shortType> ids);

    /**
     * 查询多条数据
     *简单的数据库分页查询
     * @param offset 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<$!{tableInfo.name}> queryAllByLimit(int offset, int limit);

    int insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

    int insertBatch(List<$!{tableInfo.name}> list);
    
    int insertPartial(List<$!{tableInfo.name}>  list);

    int insertLambdaPartial(List<$!{tableInfo.name}> list);

    int update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));

    int updateBatch(List<$!{tableInfo.name}> list);

    int deleteById($!pk.shortType $!pk.name);

    int deleteByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  
    int deleteByIds(List<$!pk.shortType> list);
    
    int countAll();
    
    int countByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
}

serviceImpl模板

##定义初始变量
#set($tableName = $tool.append($tableInfo.name, "ServiceImpl"))
##设置回调
$!callback.setFileName($tool.append($tableName, ".java"))
$!callback.setSavePath($tool.append($tableInfo.savePath, "/service/impl"))

##拿到主键
#if(!$tableInfo.pkColumn.isEmpty())
    #set($pk = $tableInfo.pkColumn.get(0))
#end

#if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}service.impl;

import $!{tableInfo.savePackageName}.dao.$!{tableInfo.name}Dao;
import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import java.util.List;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;

/**
 * $!{tableInfo.comment}($!{tableInfo.name})表服务层service接口实现类
 *
 * @author lyz
 * @since 创建时间 $!time.currTime()
 */

@Service
public class $!{tableName} implements $!{tableInfo.name}Service {

 /** logger:日志文件 */
    private Logger logger = LoggerFactory.getLogger($!{tableName}.class);

    @Resource(type = $!{tableInfo.name}Dao.class)
    private $!{tableInfo.name}Dao $!tool.firstLowerCase($!{tableInfo.name})Dao;

    @Override
    public $!{tableInfo.name}Dao get$!{tableInfo.name}Dao() {
        return $!tool.firstLowerCase($!{tableInfo.name})Dao;
    }

    public $!{tableInfo.name} getById($!pk.shortType $!pk.name) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.getById($!{pk.name});
    }

    public $!{tableInfo.name} getByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
            if ($!tool.firstLowerCase($!{tableInfo.name}) ==null){
            //a不能为空
            return null;
        }
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.getByEntity($!{tool.firstLowerCase($!{tableInfo.name})});
    }

    public List<$!{tableInfo.name}> listByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.listByEntity($!{tool.firstLowerCase($!{tableInfo.name})});
    }

    public List<$!{tableInfo.name}> listByIds(List<$!pk.shortType> ids) {
    
    /*
        ids传入的参数是1,2,3,4需要这个几个参数进行批量的查询,
        public List<A> listByIds(String ids) {
            List<Integer> integers=new ArrayList<>();
            for (String Id : ids.split(",")) {//截取,逗号,然后把截取到的数据放到list里
                integers.add(Integer.valueOf(Id));
            }
            return aDao.listByIds(integers);
    */

        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.listByIds(ids);
    }
    
    
    /**
     * 查询多条数据
     *  简单分页的数据查询你
     * @param offset 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    @Override
    public List<$!{tableInfo.name}> queryAllByLimit(int offset, int limit) {
        return this.$!{tool.firstLowerCase($!{tableInfo.name})}Dao.queryAllByLimit(offset, limit);
    }

    public int insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insert($!{tool.firstLowerCase($!{tableInfo.name})});
    }

    public int insertBatch(List<$!{tableInfo.name}> list) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
    }
    
     /**
     * 测试分批操作
     * @param args
     */
    public static void main(String[] args) {

        A a = new A();
                a.setAd("1");
        A a2 = new A();
                a2.setAd("2");
        A a3 = new A();
                a3.setAd("3");
        A a4 = new A();
                a4.setAd("4");
        A a5 = new A();
                a5.setAd("5");
        A a6 = new A();
        a6.setAd("6");
        A a7 = new A();
        a7.setAd("7");
        List<A>  list = new ArrayList<>();
        list.add(a);
        list.add(a2);
        list.add(a3);
        list.add(a4);
        list.add(a5);
        list.add(a6);
        list.add(a7);
        List<List<A>> partslist = Lists.partition(list, 2);
        int i=0;
        for (List<A> as : partslist) {
            i=i+1;//参数引用
            System.out.println(JSONObject.toJSONString("测试分批"+as));
        }
        System.out.println(JSONObject.toJSONString("测试参数引用"+i));

        //lambda表达式有局限性,不能进行参数引用,使用参数引用则保持
        partslist.stream().forEach(e ->{
          //  i=i+1; lambda表达式的局限性,不能使用参数引用
            // TODO 可以在这里操作数据库,达到分批操作数据,可以截取出partslist前面三条list的数据(相当于分批2次,一次三条list数据),一共两条
            System.out.println(JSONObject.toJSONString(e));
        });

        /**分批打印结果
         [{"ad":"1"},{"ad":"2"}]
         [{"ad":"3"},{"ad":"4"}]
         [{"ad":"5"},{"ad":"6"}]
         [{"ad":"7"}]
         */

    }
    
        /**
     * 分批批量新增数据
     * ps:
     *      把数据分成几个insert,几个insert执行
     *      列如:1,2,3,4,5进行分成两个数据批操作第一次insert里执行1,2两条数据,第二次insert里执行3,4两条数据,
     *      第三次insert里不满两条数据就只执行5这一条数据
     * @param list
     * @return
     */
    public int insertPartial(List<$!{tableInfo.name}> list) {
        //限制条数,限制每次只插入两条,如果有五条数据的话,会拼接成三条sql每条sql语句是由两条数据拼接而成的
        int pointsDataLimit = 2;
        Integer size = list.size();
        int shengyu = 0;   //初始化变量
        //判断是否有必要分批
        if (pointsDataLimit < size) {
            //分批数
            int part = size / pointsDataLimit;//list总数除以分批数,就等于要分批插入的数量,然后for循环这个计算出来的分批数,这样就可以达到每几次插入一次了,剩下的集for外面的一次性插入就行了
            for (int i = 0; i < part; i++) {
                //2条插入一次
                List<A> listPage = list.subList(0, pointsDataLimit);
                $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
                //剔除已经插入的
                list.subList(0, pointsDataLimit).clear();
            }
            if (list.size() > 0) {
                //新增最后剩下的
                shengyu = $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
                return shengyu;
            }
        } else {
            //当list数据小于一次分批数据的时候直接插入,不进行分批插入了
            shengyu = $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
        }
        return shengyu;
    }
    
        /**
     * 使用lambda表达式进行分批插入操作
     * @param list
     * @return
     */
    public int insertLambdaPartial(List<$!{tableInfo.name}> list) {

        List<List<A>> partslist = Lists.partition(list, 2);
        int i=0;   //初始化变量

        for (List<A> as : partslist) {
            i=$!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
        }
/*        partslist.stream().forEach(e ->{
            // TODO 可以在这里操作数据库,达到分批操作数据,可以截取出partslist前面三条list的数据(相当于分批2次,一次三条list数据),一共两条
            //TODO lambda表达式的局限性,不能使用参数引用
        i=$!{tool.firstLowerCase($!{tableInfo.name})}Dao.insertBatch(list);
            System.out.println(JSONObject.toJSONString(e));
        });*/
        return i;
    }

    public int update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.update($!{tool.firstLowerCase($!{tableInfo.name})});
    }

    public int updateBatch(List<$!{tableInfo.name}> list) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.updateBatch(list);
    }

    public int deleteById($!pk.shortType $!pk.name) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.deleteById($!pk.name);
    }

    public int deleteByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.deleteByEntity($!{tool.firstLowerCase($!{tableInfo.name})});
    }
  
    public int deleteByIds(List<$!pk.shortType> list) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.deleteByIds(list);
    }

    public int countAll() {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.countAll();
    }
    
    public int countByEntity($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
        return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.countByEntity($!tool.firstLowerCase($!{tableInfo.name}));
    }

}

controller模板

##定义初始变量
#set($tableName = $tool.append($tableInfo.name, "Controller"))
##设置回调
$!callback.setFileName($tool.append($tableName, ".java"))
$!callback.setSavePath($tool.append($tableInfo.savePath, "/controller"))
##拿到主键
#if(!$tableInfo.pkColumn.isEmpty())
    #set($pk = $tableInfo.pkColumn.get(0))
#end

#if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}controller;

import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;

/**
 * $!{tableInfo.comment}($!{tableInfo.name})表控制层
 *
 * @author lyz
 * @since 创建时间 $!time.currTime()
 */

@RestController
@RequestMapping("/$!tool.firstLowerCase($tableInfo.name)")
public class $!{tableName} {
    
    @Autowired
    private $!{tableInfo.name}Service $!tool.firstLowerCase($tableInfo.name)Service;

    @GetMapping("/get/{$!pk.name}")
    public $!{tableInfo.name} getById(@PathVariable $!pk.shortType $!pk.name) {
        $tableInfo.name $!tool.firstLowerCase($tableInfo.name) = $!{tool.firstLowerCase($tableInfo.name)}Service.getById(id);
        return $!tool.firstLowerCase($tableInfo.name)!=null?$!tool.firstLowerCase($tableInfo.name):new $!{tableInfo.name}();
    }

    @GetMapping("/get")
    public $!{tableInfo.name} getByEntity($tableInfo.name $!tool.firstLowerCase($tableInfo.name)) {
        return $!{tool.firstLowerCase($tableInfo.name)}Service.getByEntity($!{tool.firstLowerCase($!{tableInfo.name})});
    }

    @GetMapping("/list")
    public List<$!{tableInfo.name}> list($tableInfo.name $!tool.firstLowerCase($tableInfo.name)) {
        List<$tableInfo.name> $!{tool.firstLowerCase($tableInfo.name)}List = $!{tool.firstLowerCase($tableInfo.name)}Service.listByEntity($!{tool.firstLowerCase($!{tableInfo.name})});
        return $!{tool.firstLowerCase($tableInfo.name)}List;
    }

    @PostMapping("/insert")
    public $tableInfo.name insert(@RequestBody $tableInfo.name $!tool.firstLowerCase($tableInfo.name)){
        $!{tool.firstLowerCase($tableInfo.name)}Service.insert($!tool.firstLowerCase($tableInfo.name));
        return $!tool.firstLowerCase($tableInfo.name);
    }

    @PutMapping("/update")
    public int update(@RequestBody $tableInfo.name $!tool.firstLowerCase($tableInfo.name)){
        return $!{tool.firstLowerCase($tableInfo.name)}Service.update($!tool.firstLowerCase($tableInfo.name));
    }

    @DeleteMapping("/delete/{$!pk.name}")
    public int deleteOne(@PathVariable $!pk.shortType $!pk.name){
        return $!{tool.firstLowerCase($tableInfo.name)}Service.deleteById($!pk.name);
    }

    @DeleteMapping("/delete")
    public int deleteBatch(@RequestBody List<$!pk.shortType> $!{pk.name}s){
        int result = 0;
        if ($!{pk.name}s!=null&&$!{pk.name}s.size()>0) result = $!{tool.firstLowerCase($tableInfo.name)}Service.deleteByIds($!{pk.name}s);
        return result;
    }

}

其他的模板(不需要生成的,只需要做为参考的)

application.properties配置文件


#server.jsp-servlet.init-parameters.development=true
server.servlet.jsp.init-parameters.development=true
############################################################
#
# 配置数据源相关	使用阿里巴巴的 druid 数据源
#
############################################################
#spring.datasource.url=jdbc:mysql://localhost:3306/mybatisdemo?useUnicode=true&characterEncoding=UTF-8
#因为mysql连接的依赖包是高版本的情况,会爆时区的错误,使用改成下面这样
spring.datasource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#上面那个不适合用于jdk8以上的了,改成这个,,不该的话虽然对程序没啥影响,但是会出现一个红色警告,就是下面这个错误
#红色警告在控制台Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# mybatis 配置
mybatis.type-aliases-package=com.example.demo.pojo
mybatis.mapper-locations=classpath:mapper/*.xml
logging.level.com.example.demo.dao=debug

pom.xml文件(下载项目的常用jar)

<!-- 这个是pom文件,不自动生成,就是做个参考而已 -->

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>
            <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>4.3</version>
    </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!--mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <!--pagehelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>

        <!--Mysql / DataSource -->
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--swagger依赖-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
        </dependency>
        <!--slf4j日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

springboot的启动类Application.java

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan(basePackages = "com.example.demo.dao")//扫描 mybatis mapper 包路径
public class DemoApplication {

        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    }

对应上面的模板文件下载地址

https://download.csdn.net/download/chancui9673/33766670

chancui9673

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
IDEA插件Easy code逆向工程模板使用

第一步：idea安装EasyCodectrl+alt+s --> 选择Plugins --> 安装Easy Code插件 --> 安装之后注意重启idea！第二步：配置数据库添加数据源连接数据库，注意下面的Database要么不填写，要么就必须填写你数据库中对应的数据库名哦！！ps如果连接mysql失败,切换mysql版本为5.1即可之后等待idea最下面的显示加载完成最后就把数据源添加好了哦~~第三...
复制链接

扫一扫