SpringBoot使用JPA以及反向生成

#pom文件添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

 

#配置文件

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
#数据库连接超时时间,默认30秒，即30000
spring.datasource.hikari.connection-timeout=30000
#空闲连接存活最大时间，默认600000（10分钟）
spring.datasource.hikari.idle-timeout=600000
#此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.connection-test-query=SELECT 1
#连接池最小空闲连接，默认值与maximumPoolSize相同
spring.datasource.hikari.minimum-idle=5
#连接池最大连接数，默认是10
spring.datasource.hikari.maximum-pool-size=10
#连接池名称
spring.datasource.hikari.pool-name=HikariCP

 

#groovy脚本

所在位置：C:\Users\Administrator\AppData\Roaming\JetBrains\IntelliJIdea2020.2\extensions\com.intellij.database\schema\Generate 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
 
config = [
        impSerializable  : true,
        extendBaseEntity : false,
        extendBaseService: true,
        useLombok        : true, // 使用注解，不生成get、set方法
        ModelNotNULL     : true, // 空值不返回注解
        ModelDate        : true, // 日期类格式注解
        baseMethods      : true, // ServiceImpl生成基础方法
 
        generateItem     : [
                "Entity",
                "Service",
                "ServiceImpl",
                "Repository",
                "RepositoryCustom",
                "RepositoryImpl",
        ]
]
 
 
baseEntityProperties = ["id", "createDate", "lastModifiedDate", "version"]
 
typeMapping = [
        (~/(?i)bool|boolean|tinyint/)     : "Boolean",
        (~/(?i)bigint/)                   : "Long",
        (~/int/)                          : "Integer",
        (~/(?i)float|double|decimal|real/): "Double",
        (~/(?i)datetime|timestamp/)       : "java.util.Date",
        (~/(?i)date/)                     : "java.sql.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)
    }
}
 
// 生成对应的文件
def generate(table, dir) {
 
    def entityPath = "${dir.toString()}\\entity",
        servicePath = "${dir.toString()}\\service",
        serviceImplPath = "${dir.toString()}\\service\\impl",
        repPath = "${dir.toString()}\\repository"
 
    mkdirs([entityPath, servicePath, serviceImplPath, repPath])
 
    System.out.println(table.getName())
    def entityName = javaName(table.getName(), true)
    def fields = calcFields(table)
    def basePackage = clacBasePackage(dir)
 
    if (isGenerate("Entity")) {
        genUTF8File(entityPath, "${entityName}.java").withPrintWriter { out -> genEntity(out, table, entityName, fields, basePackage) }
    }
    if (isGenerate("Service")) {
        genUTF8File(servicePath, "${entityName}Service.java").withPrintWriter { out -> genService(out, table, entityName, fields, basePackage) }
    }
    if (isGenerate("ServiceImpl")) {
        genUTF8File(serviceImplPath, "${entityName}ServiceImpl.java").withPrintWriter { out -> genServiceImpl(out, table, entityName, fields, basePackage) }
    }
    if (isGenerate("Repository")) {
        genUTF8File(repPath, "${entityName}Repository.java").withPrintWriter { out -> genRepository(out, table, entityName, fields, basePackage) }
    }
 
}
 
// 是否需要被生成
def isGenerate(itemName) {
    config.generateItem.contains(itemName)
}
 
// 指定文件编码方式，防止中文注释乱码
def genUTF8File(dir, fileName) {
    new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, fileName)), "utf-8"))
}
 
// 生成每个字段
def genProperty(out, field) {
 
    out.println ""
    out.println "\t/**"
    out.println "\t * ${field.comment}"
    out.println "\t */"
    // 默认表的第一个字段为主键
    if (field.position == 1) {
        out.println "\t@Id"
        out.println "\t@GeneratedValue(strategy = GenerationType.IDENTITY)"
    }
    // 日期类加上注解
    if (field.dataType == "datetime" || field.dataType == "timestamp") {
        if (config.ModelDate) {
            out.println "\t@JsonFormat(pattern = \"yyyy-MM-dd HH:mm:ss\")"
        }
    }
    // 枚举不需要长度
    out.println "\t@Column(name = \"${field.colum}\")"
    out.println "\tprivate ${field.type} ${field.name};"
}
 
// 生成get、get方法
def genGetSet(out, field) {
 
    // get
    out.println "\t"
    out.println "\tpublic ${field.type} get${field.name.substring(0, 1).toUpperCase()}${field.name.substring(1)}() {"
    out.println "\t\treturn this.${field.name};"
    out.println "\t}"
 
    // set
    out.println "\t"
    out.println "\tpublic void set${field.name.substring(0, 1).toUpperCase()}${field.name.substring(1)}(${field.type} ${field.name}) {"
    out.println "\t\tthis.${field.name} = ${field.name};"
    out.println "\t}"
}
 
// 生成实体类
def genEntity(out, table, entityName, fields, basePackage) {
    out.println "package ${basePackage}.entity;"
    out.println ""
    if (config.extendBaseEntity) {
        out.println "import $baseEntityPackage;"
    }
    if (config.useLombok) {
        out.println "import lombok.Data;"
        out.println ""
    }
    if (config.impSerializable) {
        out.println "import java.io.Serializable;"
        out.println ""
    }
 
    out.println "import javax.persistence.*;"
    out.println "import org.hibernate.annotations.DynamicInsert;"
    out.println "import org.hibernate.annotations.DynamicUpdate;"
    if (config.ModelNotNULL) {
        out.println "import com.fasterxml.jackson.annotation.JsonInclude;"
    }
    if (config.ModelDate) {
        out.println "import com.fasterxml.jackson.annotation.JsonFormat;"
    }
    out.println ""
    out.println "/**"
    out.println " * @author Shichao.Lu"
    out.println " * ${table.getComment()}"
    out.println " */"
    if (config.useLombok) {
        out.println "@Data"
    }
    if (config.ModelNotNULL) {
        out.println "@JsonInclude(JsonInclude.Include.NON_NULL)"
    }
    out.println "@Entity"
    out.println "@Table(name = \"${table.getName()}\")"
    out.println "@DynamicInsert"
    out.println "@DynamicUpdate"
    out.println "public class $entityName${config.extendBaseEntity ? " extends BaseEntity" : ""}${config.impSerializable ? " implements Serializable" : ""} {"
 
    if (config.extendBaseEntity) {
        fields = fields.findAll { it ->
            !baseEntityProperties.any { it1 -> it1 == it.name }
        }
    }
 
    fields.each() {
        genProperty(out, it)
    }
 
    if (!config.useLombok) {
        fields.each() {
            genGetSet(out, it)
        }
    }
    out.println "}"
}
 
// 生成Service
def genService(out, table, entityName, fields, basePackage) {
    out.println "package ${basePackage}.service;"
    out.println ""
    if (config.extendBaseService) {
        out.println "import ${basePackage}.entity.$entityName;"
    }
    out.println ""
    out.println ""
    out.println "/**"
    out.println "@author Shichao.Lu"
    out.println "*/"
    out.println "public interface ${entityName}Service${config.extendBaseService ? " extends BaseService<$entityName, ${fields[0].type}>" : ""} {"
    out.println ""
    out.println "}"
}
// 生成ServiceImpl
def genServiceImpl(out, table, entityName, fields, basePackage) {
    out.println "package ${basePackage}.service.impl;"
    out.println ""
    out.println "import ${basePackage}.repository.${entityName}Repository;"
    out.println "import ${basePackage}.service.${entityName}Service;"
    out.println "import ${basePackage}.entity.$entityName;"
    if (config.baseMethods) {
        out.println "import java.util.List;"
//        out.println "import org.springframework.transaction.annotation.Transactional;"
        out.println "import org.springframework.data.domain.*;"
        out.println "import java.util.Optional;"
    }
    out.println "import org.springframework.stereotype.Service;"
    out.println ""
    out.println "import javax.annotation.Resource;"
    out.println ""
    out.println "/**"
    out.println "@author Shichao.Lu"
    out.println "*/"
    out.println "@Service"
    //out.println "public class ${entityName}ServiceImpl  implements ${entityName}Service<$entityName, ${fields[0].type}>  {"
    out.println "public class ${entityName}ServiceImpl implements ${entityName}Service {"
    out.println ""
    out.println "\t@Resource"
    out.println "\tprivate ${entityName}Repository rep;"
    out.println ""
    if (config.baseMethods) {
        //基础方法 save
        out.println "\t@Override"
        out.println "\tpublic ${entityName} save(${entityName} obj) {"
        out.println "\t\treturn rep.save(obj);"
        out.println "\t}"
        out.println ""
        //基础方法 saveList
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> saveAll(Iterable<${entityName}> list) {"
        out.println "\t\treturn rep.saveAll(list);"
        out.println "\t}"
        out.println ""
        //基础方法 getOne
        out.println "\t@Override"
        out.println "\tpublic ${entityName} getOne(${fields[0].type} id) {"
        out.println "\t\treturn rep.getOne(id);"
        out.println "\t}"
        out.println ""
        //基础方法 findById
        out.println "\t@Override"
        out.println "\tpublic ${entityName} findById(${fields[0].type} id) {"
        out.println "\t\tOptional<${entityName}> obj = rep.findById(id);"
        out.println "\t\treturn obj.orElse(null);"
        out.println "\t}"
        out.println ""
        //基础方法 deleteById
        out.println "\t@Override"
        out.println "\tpublic void deleteById(${fields[0].type} id) {"
        out.println "\t\trep.deleteById(id);"
        out.println "\t}"
        out.println ""
        //基础方法 deleteAll
        out.println "\t@Override"
        out.println "\tpublic void deleteAll(List list) {"
        out.println "\t\trep.deleteAll(list);"
        out.println "\t}"
        out.println ""
        //基础方法 delete
        out.println "\t@Override"
        out.println "\tpublic void delete(${entityName} obj) {"
        out.println "\t\trep.delete(obj);"
        out.println "\t}"
        out.println ""
        //基础方法 existsById
        out.println "\t@Override"
        out.println "\tpublic boolean existsById(${fields[0].type} id) {"
        out.println "\t\treturn rep.existsById(id);"
        out.println "\t}"
        out.println ""
        //基础方法 count
        out.println "\t@Override"
        out.println "\tpublic long count() {"
        out.println "\t\treturn rep.count();"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAll() {"
        out.println "\t\treturn rep.findAll();"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAll(${entityName} obj) {"
        out.println "\t\treturn rep.findAll(Example.of(obj));"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAll(Sort sort) {"
        out.println "\t\treturn rep.findAll(sort);"
        out.println "\t}"
        out.println ""
        //基础方法 findAllById
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAllById(Iterable<${fields[0].type}> ids) {"
        out.println "\t\treturn rep.findAllById(ids);"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAll(Example<${entityName}> e) {"
        out.println "\t\treturn rep.findAll(e);"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic List<${entityName}> findAll(Example<${entityName}> e, Sort sort) {"
        out.println "\t\treturn rep.findAll(e,sort);"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic Page<${entityName}> findAll(Pageable page) {"
        out.println "\t\treturn rep.findAll(page);"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic Page<${entityName}> findAll(Example<${entityName}> e, Pageable page) {"
        out.println "\t\treturn rep.findAll(e,page);"
        out.println "\t}"
        out.println ""
        //基础方法 findAll
        out.println "\t@Override"
        out.println "\tpublic Page<${entityName}> findAll(${entityName} obj, Pageable page) {"
        out.println "\t\treturn rep.findAll(Example.of(obj),page);"
        out.println "\t}"
        out.println ""
    }
    out.println "}"
}
 
// 生成Repository
def genRepository(out, table, entityName, fields, basePackage) {
    out.println "package ${basePackage}.repository;"
    out.println ""
    out.println "import ${basePackage}.entity.$entityName;"
    out.println "import org.springframework.data.jpa.repository.JpaRepository;"
    out.println ""
    out.println "/**"
    out.println "@author Shichao.Lu"
    out.println "*/"
    out.println "public interface ${entityName}Repository extends JpaRepository<$entityName, ${fields[0].type}> {"
    out.println ""
    out.println "}"
}
 
// 生成文件夹
def mkdirs(dirs) {
    dirs.forEach {
        def f = new File(it)
        if (!f.exists()) {
            f.mkdirs()
        }
    }
}
 
def clacBasePackage(dir) {
    dir.toString()
            .replaceAll("^.+\\\\src\\\\main\\\\java\\\\", "")
            .replaceAll("\\\\", ".")
}
 
def isBaseEntityProperty(property) {
    baseEntityProperties.find { it == property } != null
}
 
// 转换类型
def calcFields(table) {
    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
        fields += [[
                           name     : javaName(col.getName(), false),
                           colum    : col.getName(),
                           type     : typeStr,
                           dataType : col.getDataType().toString().replaceAll(/\(.*\)/, "").toLowerCase(),
                           len      : col.getDataType().toString().replaceAll(/[^\d]/, ""),
                           default  : col.getDefault(),
                           comment  : col.getComment(),
                           isNotNull: col.isNotNull(),
                           position : col.getPosition(),
                   ]]
 
    }
}
 
def javaName(str, capitalize) {
    def s = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }
            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_").replaceAll(/_/, "")
    capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

 

#反向生成

idea中点击database栏，右击表，选择Scripted Extensions，点击Generate POJOs.groovy脚本，选择个生成路径，即可