IDEA 根据模板生成代码Generate POJOs.groovy

官方的Generate POJOs.groovy无法定制, 基于官方脚本进行了修改, 支持自定义Volocity模板生成代码, 无需额外增加任何依赖。

最新示例和脚本参考GitHub项目:

https://github.com/lile1991/IDEA-Database-Tools

1.放置脚本

Generate Template POJOs.groovy

import com.intellij.database.model.DasTable
import com.intellij.database.model.ObjectKind
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

import java.io.StringWriter
import java.util.HashSet

import org.apache.velocity.VelocityContext
import org.apache.velocity.Template
import org.apache.velocity.app.VelocityEngine
import org.apache.velocity.app.Velocity
import org.apache.velocity.exception.ResourceNotFoundException
import org.apache.velocity.exception.ParseErrorException
import org.apache.velocity.exception.MethodInvocationException
import org.apache.velocity.runtime.RuntimeConstants

/*
 * Available context bindings:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */

typeMapping = [
        (~/(?i)bigint/)                   : "Long",
        (~/(?i)tinyint/)                  : "Byte",
        (~/(?i)int/)                      : "Integer",
        (~/(?i)float|double|decimal|real/): "java.math.BigDecimal",
        (~/(?i)datetime|timestamp/)       : "java.util.Date",
        (~/(?i)date/)                     : "java.util.Date",
        (~/(?i)time/)                     : "java.sql.Time",
        (~/(?i)/)                         : "String"
]

FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
    SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
}


VelocityEngine velocityEngine() {
    // 初始化模版引擎
    VelocityEngine ve = new VelocityEngine()
    // 这两个属性可以从RuntimeConstants常量中找到, 引用常量有些版本报错, 就直接写死了
    ve.setProperty("runtime.log", PROJECT.getBaseDir().path + "/dbTools.log") // 对应RuntimeConstants.RUNTIME_LOG
    ve.setProperty("file.resource.loader.path", PROJECT.getBaseDir().path)
    // 对应RuntimeConstants.FILE_RESOURCE_LOADER_PATH
    ve.init()
    ve
}

List<File> listVmFiles(File dir) {
    return listVmFiles0(dir, new ArrayList<>());
}

List<File> listVmFiles0(File dir, List<File> fileList) {
    File[] files = dir.listFiles();
    if(files == null) {
        return fileList;
    }

    for(File file: files) {
        if(file.isDirectory()) {
            listVmFiles0(file, fileList);
        } else {
            String fileName = file.getName();
            if(fileName.startsWith("Generate_POJO_") && fileName.endsWith(".vm")) {
                fileList.add(file);
            }
        }
    }
    return fileList;
}

def generate(table, dir) {
    // 转驼峰, 如t_user转换为TUser
    def className = javaName(table.getName(), true)

    // 读取所有模板文件
    List<File> templateFileList = listVmFiles(dir)
    if(templateFileList == null || templateFileList.isEmpty()) {
        return
    }

    String templateEncoding = "UTF-8"
    VelocityEngine ve = velocityEngine()

    // 根据模板循环生成代码
    for(File templateFile: templateFileList) {
        def templatePath = templateFile.getAbsolutePath().substring(PROJECT.getBaseDir().path.length() + 1)
        Template template = ve.getTemplate(templatePath, templateEncoding)

        VelocityContext ctx = new VelocityContext()
        // 设置变量
        setContextProperty(ctx, table, className, dir)

        // 输出
        StringWriter sw = new StringWriter()
        template.merge(ctx, sw)
        String generateContent = sw.toString()

        // 默认生成的文件名
        String fileName = className + ".java";

        // 读取属性定义
        def lines = generateContent.split("\n")

        // 存储正文(去除属性定义)
        sw = new StringWriter()

        boolean isDefinedReading = true
        for(int i = 0; i < lines.length; i ++){
            def line = lines[i]
            if(isDefinedReading) {
                // 先读取属性定义
                if(line.startsWith("#fileName=")) {
                    fileName = line.substring("#filename=".length()).trim()
                    continue
                }

                isDefinedReading = false
            }
            // 再读取正文
            sw.append(line)
        }

//        new File(new File("D:\\"), fileName).append(fileName)

        new File(templateFile.getParentFile(),  fileName).withPrintWriter("UTF-8") { out -> out.print sw }
    }
}

def setContextProperty(ctx, table, className, dir) {
    // 首字母小写
    def memberName = String.valueOf(Character.toLowerCase(className.charAt(0))) + className.substring(1)

    // 将类信息放入模板变量
    ctx.put("class", [
            "name"   : className,   // 类名
            "comment": table.comment    // 表注释
    ])

    ctx.put("memberName", memberName)
    ctx.put("table", [
            "name": table.getName()
    ])

    def cmbFields = calcFields(table)
    // 将字段信息放入模板变量
    ctx.put("imports", cmbFields.imports)
    ctx.put("fields", cmbFields.fields)
}

def calcFields(table) {
    def imports = [] as HashSet
    def fields = DasUtil.getColumns(table).reduce([]) { fields, col ->
        def spec = Case.LOWER.apply(col.getDataType().getSpecification())
        def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value

        if (typeStr.contains(".")) {
            imports << typeStr
            typeStr = typeStr.substring(typeStr.lastIndexOf(".") + 1)
        }

        def jdbcType = Case.UPPER.apply(col.getDataType().typeName)
        fields += [[
                           name   : javaName(col.getName(), false),
                           type   : typeStr,
                           colName: col.getName(),
//                           jdbcType: Case.LOWER.apply(col.getDataType().getSpecification()),
                           jdbcType: jdbcType == "INT" ? "INTEGER" : jdbcType,
                           comment: col.comment,
                           annos  : ""]]

    }
    ["fields": fields, "imports": imports]
}

def javaName(str, capitalize) {
    def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
            .collect { Case.LOWER.apply(it).capitalize() }
            .join("")
            .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
    capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

放到schema目录:
image.png

2. 定义模板

在POJO同目录下创建Volocity模板文件, 定义生成模板
image.png

文件模板命名规则: Generate_POJO_{自定义}.vm, 必须按指定前缀命名
示例模板Generate_POJO_ReqDTO.vm

#fileName=${class.name}ReqDTO.java
package com.woo.service.dto.req;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import com.woo.dao.entity.${class.name};

#foreach($imp in $imports)
import $imp;
#end

/**
* $class.comment
*/
@ToString
@Getter
@Setter
public class ${class.name}ReqDTO extends ${class.name} {

}

其中第一行#fileName=${class.name}ReqDTO.java表示生成后的文件名, 可以是任意文件,如.java、.xml等

3. 生成POJO

选中需要生成POJO的表, 支持多选
image.png

4. 指定模块路径

在上一步弹框中, 选择模块路径
image.png
可以指定根路径, 会自动查找下级路径的模板; 也可以指定到子路径, 灵活控制生成的代码范围

脚本将自动搜索指定目录下所有的模板定义Generate_POJO_{自定义}.vm, 并在模板定义目录下生成对应的POJO:
image.png
我选中了两张表, 所以生成了两个POJO

模板中可使用的变量:

### 类名(表明转驼峰,首字母大写)
${class.name}

### 表注释
${class.comment}

### 表字段需要import的类, 如java.math.BigDecimal
${imports}
### 示例
#foreach($imp in $imports)
import $imp;
#end

### 字段名(列名转驼峰,首字母小写)
${fields}
### 示例
#foreach($field in $fields)
/** ${field.comment} */
private ${field.type} ${field.name};
#end

# 表名
${table.name}

模板示例

最新示例和模板代码参考GitHub项目:

https://github.com/lile1991/IDEA-Database-Tools

生成实体模板: Generate_POJO_Entity.vm

#fileName=${class.name}.java
package com.woo.product.dao.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

#foreach($imp in $imports)
import $imp;
#end

/**
* $class.comment
*/
@ToString
@Getter
@Setter
public class ${class.name} {
#foreach($field in $fields)
    private ${field.type} ${field.name};
#end
}

生成ReqDTO模板: Generate_POJO_ReqDTO.vm

#fileName=${class.name}ReqDTO.java
package com.woo.product.service.dto.req;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import com.woo.product.dao.entity.${class.name};

#foreach($imp in $imports)
import $imp;
#end

/**
* $class.comment
*/
@ToString
@Getter
@Setter
public class ${class.name}ReqDTO extends ${class.name} {

}

生成RespDTO模板: Generate_POJO_ReqDTO.vm

#fileName=${class.name}RespDTO.java
package com.woo.product.service.dto.resp;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import com.woo.product.dao.entity.${class.name};

#foreach($imp in $imports)
import $imp;
#end

/**
* $class.comment
*/
@ToString
@Getter
@Setter
public class ${class.name}RespDTO extends ${class.name} {

}

生成Mapper接口模板: Generate_POJO_Mapper.vm

#fileName=${class.name}Mapper.java
package com.woo.product.dao.mapper;

import com.facebook.common.dao.MapperExt;
import com.woo.product.dao.entity.${class.name};
import com.woo.product.service.dto.req.${class.name}ReqDTO;
import com.woo.product.service.dto.resp.${class.name}RespDTO;

#foreach($imp in $imports)
import $imp;
#end

public interface ${class.name}Mapper extends MapperExt<${class.name}, ${fields[0].type}, ${class.name}ReqDTO, ${class.name}RespDTO> {
}

生成MapperExt接口模板: Generate_POJO_MapperExt.vm

#fileName=${class.name}MapperExt.java
package com.woo.product.dao.mapper.ext;

import com.facebook.common.service.dto.request.PageReqDTO;
import com.woo.product.dao.mapper.${class.name}Mapper;
import com.woo.product.service.dto.req.${class.name}ReqDTO;
import com.woo.product.service.dto.resp.${class.name}RespDTO;

#foreach($imp in $imports)
import $imp;
#end
import java.util.List;

public interface ${class.name}MapperExt extends ${class.name}Mapper {
    Long selectCountManage(PageReqDTO<${class.name}ReqDTO> pageReqDTO);
    List<${class.name}RespDTO> selectListManage(PageReqDTO<${class.name}ReqDTO> pageReqDTO);
}

生成Service模板: Generate_POJO_Service.vm

#fileName=${class.name}Service.java
package com.woo.product.service;

import com.facebook.common.service.dto.request.PageReqDTO;
import com.facebook.common.service.dto.response.PageRespDTO;
import com.woo.product.dao.entity.${class.name};
import com.woo.product.dao.mapper.ext.${class.name}MapperExt;
import com.woo.product.service.dto.req.${class.name}ReqDTO;
import com.woo.product.service.dto.resp.${class.name}RespDTO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class ${class.name}Service extends ProductBaseService<${class.name}, ${fields[0].type}, ${class.name}ReqDTO, ${class.name}RespDTO, ${class.name}MapperExt> {
    @Transactional(transactionManager = TRANSACTION_MANAGER, readOnly = true)
    public PageRespDTO<${class.name}RespDTO> selectPageManage(PageReqDTO<${class.name}ReqDTO> pageReqDTO) {
        return selectPage(pageReqDTO, mapperEx::selectCountManage, mapperEx::selectListManage);
    }
}

生成Mapper.xml模板: Generate_POJO_MapperXml.vm

#fileName=${class.name}Mapper.xml
<?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="com.woo.product.dao.mapper.${class.name}Mapper">
    <resultMap id="BaseResultMap" type="com.woo.product.dao.entity.${class.name}">
#foreach($field in $fields)
#if($foreach.index == 0)
        <id column="${field.colName}" jdbcType="${field.jdbcType}" property="${field.name}" />
#else
        <result column="${field.colName}" jdbcType="${field.jdbcType}" property="${field.name}" />
#end
#end
    </resultMap>
    <sql id="Base_Column_List">
#foreach($field in $fields)
        ${field.colName}#if(${foreach.index} < ${fields.size()} - 1),
#end
#end

    </sql>
    <select id="selectByPrimaryKey" parameterType="java.lang.$fields[0].type" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from ${table.name}
        where $fields[0].colName = #{$fields[0].name,jdbcType=$fields[0].jdbcType}
    </select>
    <delete id="deleteByPrimaryKey" parameterType="java.lang.$fields[0].type">
        delete from ${table.name}
        where $fields[0].colName = #{$fields[0].name,jdbcType=$fields[0].jdbcType}
    </delete>
    <insert id="insert" parameterType="com.woo.product.dao.entity.${class.name}">
        insert into ${table.name} (
#foreach($field in $fields)
            ${field.colName}#if(${foreach.index} < ${fields.size()} - 1),
#end
#end

        )
        values (
#foreach($field in $fields)
            #{${field.name},jdbcType=${field.jdbcType}}#if(${foreach.index} < ${fields.size()} - 1),
#end
#end

        )
    </insert>
    <insert id="insertSelective" parameterType="com.woo.product.dao.entity.${class.name}">
        insert into ${table.name}
        <trim prefix="(" suffix=")" suffixOverrides=",">
#foreach($field in $fields)
            <if test="${field.name} != null">
                ${field.colName},
            </if>
#end
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
#foreach($field in $fields)
            <if test="${field.name} != null">
                #{${field.name},jdbcType=${field.jdbcType}},
            </if>
#end
        </trim>
    </insert>
    <update id="updateByPrimaryKeySelective" parameterType="com.woo.product.dao.entity.${class.name}">
        update ${table.name}
        <set>
#foreach($field in $fields)
#if(${foreach.index} > 0)
            <if test="${field.name} != null">
                ${field.colName} = #{${field.name},jdbcType=${field.jdbcType}},
            </if>
#end
#end
        </set>
        where ${fields[0].colName} = #{${fields[0].name},jdbcType=${fields[0].jdbcType}}
    </update>
    <update id="updateByPrimaryKey" parameterType="com.woo.product.dao.entity.${class.name}">
        update ${table.name}
        set
#foreach($field in $fields)
#if(${foreach.index} > 0)
            ${field.colName} = #{${field.name},jdbcType=${field.jdbcType}}#if(${foreach.index} < ${fields.size()} - 1),
#end
#end
#end

        where ${fields[0].colName} = #{${fields[0].name},jdbcType=${fields[0].jdbcType}}
    </update>
</mapper>

生成MapperExt.xml模板: Generate_POJO_MapperExtXml.vm

#fileName=${class.name}MapperExt.xml
<?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="com.woo.product.dao.mapper.ext.${class.name}MapperExt">
    <resultMap id="BaseResultMap" type="com.woo.product.service.dto.resp.${class.name}RespDTO" extends="com.woo.product.dao.mapper.${class.name}Mapper.BaseResultMap">
    </resultMap>
    <sql id="Base_Column_List">
        <include refid="com.woo.product.dao.mapper.${class.name}Mapper.Base_Column_List" />
    </sql>
    <select id="selectCount" parameterType="com.facebook.common.service.dto.request.PageReqDTO" resultType="java.lang.Long">
        select
        count(*)
        from ${table.name}
        <where>
            <include refid="where" />
        </where>
    </select>
    <select id="selectList" parameterType="com.facebook.common.service.dto.request.PageReqDTO" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from ${table.name}
        <where>
            <include refid="where" />
        </where>
        limit #{offset,jdbcType=INTEGER}, #{pageSize,jdbcType=INTEGER}
    </select>

    <sql id="where">
        #foreach($field in $fields)
            #if(${foreach.index} > 0 && $field.colName != 'created_at' && $field.colName != 'updated_at')
                #if(${foreach.index} > 1)

                #end
                #if($field.jdbcType == 'VARCHAR')
                    <if test="params.${field.name} != null and params.${field.name} != ''">
                        and ${field.colName} = #{params.${field.name},jdbcType=${field.jdbcType}}
                    </if>
                #else
                    <if test="params.${field.name} != null">
                        and ${field.colName} = #{params.${field.name},jdbcType=${field.jdbcType}}
                    </if>
                #end
            #end
        #end
    </sql>


    <resultMap id="ManageResultMap" type="com.woo.product.service.dto.resp.${class.name}RespDTO" extends="BaseResultMap">
    </resultMap>
    <select id="selectCountManage" parameterType="com.facebook.common.service.dto.request.PageReqDTO" resultType="java.lang.Long">
        select
        count(*)
        from ${table.name}
        <where>
            <include refid="whereManage" />
        </where>
    </select>
    <select id="selectListManage" parameterType="com.facebook.common.service.dto.request.PageReqDTO" resultMap="ManageResultMap">
        select
        <include refid="Base_Column_List" />
        from ${table.name}
        <where>
            <include refid="whereManage" />
        </where>
        limit #{offset,jdbcType=INTEGER}, #{pageSize,jdbcType=INTEGER}
    </select>

    <sql id="whereManage">
        <if test="params.tenantId != null">
            and tenant_id = #{params.tenantId,jdbcType=BIGINT}
        </if>
    </sql>

    <insert id="batchInsert" parameterType="list">
        insert into ${table.name} (#foreach($field in $fields)${field.colName}#if(${foreach.index} < ${fields.size()} - 1),
        #end#end)
        VALUES
        <foreach collection="list" separator="," item="item">
            (#foreach($field in $fields)#{item.${field.name},jdbcType=${field.jdbcType}}#if(${foreach.index} < ${fields.size()} - 1),
        #end#end)
        </foreach>
    </insert>
</mapper>

以上模板相关的类

MapperExt

package com.facebook.common.dao;

import com.facebook.common.service.dto.request.PageReqDTO;
import org.springframework.web.bind.annotation.RequestParam;

import java.io.Serializable;
import java.util.List;

public interface MapperExt<E, ID extends Serializable, ReqDTO, RespDTO> {
    int deleteByPrimaryKey(ID id);

    int insert(E record);

    int insertSelective(E record);

    E selectByPrimaryKey(ID id);

    int updateByPrimaryKeySelective(E record);

    int updateByPrimaryKey(E record);


    long selectCount(PageReqDTO<ReqDTO> reqDTO);

    List<RespDTO> selectList(PageReqDTO<ReqDTO> reqDTO);

    int batchInsert(@RequestParam("list") List<? extends E> eList);
}

BaseService

package com.facebook.common.service;

import com.facebook.common.dao.MapperExt;
import com.facebook.common.service.dto.request.PageReqDTO;
import com.facebook.common.service.dto.response.PageRespDTO;
import com.facebook.common.utils.ConvertUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

@Slf4j
public abstract class BaseService<E, ID extends Serializable, ReqDTO, RespDTO, MapperEx extends MapperExt<E, ID, ReqDTO, RespDTO>>/* implements ApplicationListener<ContextRefreshedEvent>*/ {

//    protected Mapper mapper;
    @Autowired
    protected MapperEx mapperEx;

    /*public void onApplicationEvent(ContextRefreshedEvent e) {
        Class<?> mapperExClass = mapperEx.getClass().getInterfaces()[0];
        Class<?>[] mapperSupperInterfaces = mapperExClass.getInterfaces();
        for(Class<?> mapperSupperInterface: mapperSupperInterfaces) {
            if(mapperExClass.getSimpleName().equals(mapperSupperInterface.getSimpleName() + "Ext")) {
                e.getApplicationContext().getBeansOfType(mapperSupperInterface);
                break;
            }
        }
    }*/

    @Transactional
    public int deleteByPrimaryKey(ID id) {
        return mapperEx.deleteByPrimaryKey(id);
    }

    @Transactional
    public int insertIfAbsent(E record) {
        try {
            return mapperEx.insert(record);
        } catch (Exception e) {
            if(e instanceof org.springframework.dao.DuplicateKeyException || e.getMessage().contains("Duplicate entry")) {
                log.debug("DuplicateKeyException", e);
                return -1;
            }
            throw e;
        }
    }

    @Transactional
    public int insert(E record) {
        return mapperEx.insert(record);
    }

    @Transactional
    public int insertSelective(E record) {
        return mapperEx.insertSelective(record);
    }

    @Transactional(readOnly = true)
    public E selectByPrimaryKey(ID id) {
        return mapperEx.selectByPrimaryKey(id);
    }

    @Transactional
    public int updateByPrimaryKeySelective(E record) {
        return mapperEx.updateByPrimaryKeySelective(record);
    }

    @Transactional
    public int updateByPrimaryKey(E record) {
        return mapperEx.updateByPrimaryKey(record);
    }


    // MapperEx中新增的方法
    @Transactional(readOnly = true)
    public long selectCount(PageReqDTO<ReqDTO> reqDTO) {
        PageReqDTO<ReqDTO> clonePageReqDTO = new PageReqDTO<>(reqDTO.getParams());
        clonePageReqDTO.setPage(1);
        clonePageReqDTO.setPageSize(1);
        return mapperEx.selectCount(clonePageReqDTO);
    }

    @Transactional(readOnly = true)
    public List<RespDTO> selectList(ReqDTO params, int size) {
        PageReqDTO<ReqDTO> pageReqDTO = new PageReqDTO<>(params);
        pageReqDTO.setPageSize(size);
        return mapperEx.selectList(pageReqDTO);
    }

    public List<RespDTO> selectList(ReqDTO params) {
        return selectList(params, 1000);
    }

    @Transactional(readOnly = true)
    public List<RespDTO> selectList(PageReqDTO<ReqDTO> pageReqDTO) {
        if(pageReqDTO.getPageSize() == null) {
            pageReqDTO.setPageSize(25);
        }

        if(pageReqDTO.getOffset() == null) {
            pageReqDTO.setPage(1);
        }

        return mapperEx.selectList(pageReqDTO);
    }

    public PageRespDTO<RespDTO> selectPage(PageReqDTO<ReqDTO> pageReqDTO) {
        return selectPage(pageReqDTO, this::selectCount, this::selectList);
    }

    public static <ReqDTO, RespDTO> PageRespDTO<RespDTO> selectPage(PageReqDTO<ReqDTO> pageReqDTO, Function<PageReqDTO<ReqDTO>, Long> selectCount, Function<PageReqDTO<ReqDTO>, List<RespDTO>> selectList) {
        Long count = ConvertUtils.defaultValue(selectCount.apply(pageReqDTO), 0L);
        PageRespDTO<RespDTO> pageRespDTO = new PageRespDTO<>(pageReqDTO.getPage(), pageReqDTO.getPageSize());
        pageRespDTO.setTotalRecord(count.intValue());
        if(count > 0) {
            List<RespDTO> respDTOS = selectList.apply(pageReqDTO);
            pageRespDTO.setData(respDTOS);
        }
        return pageRespDTO;
    }

    @Transactional(readOnly = true)
    public RespDTO selectOne(ReqDTO reqDTO) {
        PageReqDTO<ReqDTO> pageReqDTO = new PageReqDTO<>();
        pageReqDTO.setParams(reqDTO);
        pageReqDTO.setPage(1);
        pageReqDTO.setPageSize(1);
        List<RespDTO> respDTOS = selectList(pageReqDTO);
        return CollectionUtils.isEmpty(respDTOS) ? null : respDTOS.get(0);
    }


    // 本Service中新增的方法
    @Transactional
    public int insertAll(List<? extends E> eList) {
        if(eList == null || eList.isEmpty()) {
            return 0;
        }

        int count = 0;
        for(E e: eList) {
            count += insert(e);
        }
        return count;
    }

    // 本Service中新增的方法
    @Transactional
    public int batchInsert(List<? extends E> eList) {
        if(eList == null || eList.isEmpty()) {
            return 0;
        }

        return mapperEx.batchInsert(eList);
    }

    /**
     * 批量保存
     * @param eList 数据
     * @param batchSize 批次提交的事务大小
     */
    @Transactional
    public int batchInsert(List<? extends E> eList, int batchSize) {
        if(eList == null || eList.isEmpty()) {
            return 0;
        }

        if(eList.size() <= batchSize) {
            return batchInsert(eList);
        }

        int insertCnt = 0;
        List<E> oneBatch = new ArrayList<>(batchSize);
        for(int i = 0; i < eList.size(); i ++) {
            E e = eList.get(i);
            oneBatch.add(e);
            if(oneBatch.size() >= batchSize || i >= eList.size() - 1) {
                insertCnt += batchInsert(oneBatch);
                oneBatch.clear();
            }
        }
        return insertCnt;
    }
}

评论

暂无评论