IDEA的DATABASE自定义生成POJO、MAPPER、DAO（groovy）

最新推荐文章于 2024-09-23 15:22:04 发布
最新推荐文章于 2024-09-23 15:22:04 发布
阅读量851 收藏
点赞数
分类专栏： 职场技能 文章标签： intellij-idea 数据库 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43491743/article/details/126243097
版权

利用表结构自动生成基础代码

众所周知，我是一位很懒 善于发现的程序媛，这个用了很久的脚本自动生成代码，自由度极高，墙裂推荐！！！家人们！！一定要试试！！
在这里插入图片描述

生成POJO

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


packageName = ""
//数据库类型对应java数据类型，可以自己调节，比如tinyint有人喜欢转成boolean
typeMapping = [
        (~/(?i)bigint/)                          : "BigInteger",
        (~/(?i)bool|bit/)                        : "Boolean",
        (~/(?i)tinyint|smallint|mediumint|int/)  : "Integer",
        (~/(?i)decimal/)                         : "BigDecimal",
        (~/(?i)float|double|decimal|real/)       : "Double",
        (~/(?i)datetime|timestamp|date|time/)    : "Date",
        (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
        (~/(?i)/)                                : "String"
]
//复制以下代码，你就能发现我抄的谁的代码(〃'▽'〃)
FILES.chooseDirectoryAndSave("xuan wo!", "look look pojo!!!") { dir ->
  SELECTION.filter { it instanceof DasTable }.each { generate(it, dir) }
}

def generate(table, dir) {
  def className = javaName(table.getName(), true)
  def fields = calcFields(table)
  packageName = getPackageName(dir)
  //可以设置后缀，如Entity.java，加上utf-8防止乱码
  new File(dir, className + ".java").withPrintWriter("UTF-8") { out -> generate(out, className, fields, table) }
}

// 获取包所在文件夹路径
def getPackageName(dir) {
  return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
}

//以下正文要显示的格式内容，都可以自己调整
def generate(out, className, fields, table) {
 // def date = new Date().format("yyyy-MM-dd hh:mm")
  out.println "package $packageName"
  out.println ""
  //这个是我自己要用的注解@Data
  out.println "import lombok.Data;"
  out.println ""
  //这个是我自己要用的序列化，不用的可以不要
  out.println "import java.io.Serializable;"

  Set types = new HashSet()

  fields.each() {
    types.add(it.type)
  }

//如果有特殊一点的类型要导包，当然你也可以后续自动导包
  if (types.contains("Date")) {
    out.println "import java.util.Date;"
  }

  if (types.contains("BigInteger")) {
    out.println "import java.math.BigInteger;"
  }
  if (types.contains("BigDecimal")) {
    out.println "import java.math.BigDecimal;"
  }
  out.println ""
  out.println ""
  out.println "@Data"
  out.println "public class $className implements Serializable {"
  out.println ""
  out.println genSerialID()
  out.println ""
  fields.each() {

    if (it.annos != ""){
      out.println "\t${it.annos}"}

    //输出注释
    if (isNotEmpty(it.comment)) {
    out.println "\t/** ${it.comment} */"}

    out.println "\tprivate ${it.type} ${it.name};"
    out.println ""

  }
  out.println "}"
}

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),
                 type : typeStr,
                 comment: col.getComment(), // 获取注释
                 annos: ""]]
  }
}

// 处理类名（数据库表名要怎么转换成POJO名字，自己看着处理）
// 下面这个方法（javaClassName）好像不需要，但是我不知道为什么还留着。。。
def javaClassName(str, capitalize) {
  def s = str.split(/[^\p{Alnum}]/).collect { def s = Case.LOWER.apply(it).capitalize() }.join("")
  s = s[1..s.size() - 1]
  capitalize ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

//处理字段名
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]
}

def isNotEmpty(content) {
  return content != null && content.toString().trim().length() > 0
}

static String genSerialID()
{
  return "\tprivate static final long serialVersionUID =  "+Math.abs(new Random().nextLong())+"L;"
}

生成DAO

package src

import com.google.common.base.Utf8
import com.intellij.database.model.DasTable
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil


/**********************这里要自己修改*******************/
packageName = "cn.****.****.mapper"
pojoPackageName = "cn.****.****.model" //pojoPackageName 这个要和上一步pojo放的位置一样
/**********************这里要自己修改*******************/


FILES.chooseDirectoryAndSave("xuan wo!", "look look dao!!!") { dir ->
  SELECTION.filter { it instanceof DasTable }.each { generate(it, dir) }
}

def generate(table, dir) {
  def baseName = javaName(table.getName(), true)
  //自定义类名
  new File(dir, "I" + baseName + "Mapper.java").withPrintWriter("utf-8") { out -> generateInterface(out, baseName) }
}

def generateInterface(out, baseName) {
 // def date = new Date().format("yyyy-MM-dd hh:mm")
  out.println "package $packageName;"
  out.println ""
  out.println "import $pojoPackageName.${baseName};" // 需手动配置
  out.println "import org.apache.ibatis.annotations.Param;"
  out.println "import org.springframework.stereotype.Repository;"
  out.println ""
  out.println "import java.math.BigInteger;"
  out.println "import java.util.List;"
  out.println ""
  out.println "@Repository"
  out.println "public interface I${baseName}Mapper {" // 可自定义
  out.println ""
  out.println "\tint insertSingle(${baseName} entity);"
  out.println "\t"
  //想要什么方法自己加
  out.println "}"
}

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

生成MAPPER

package src

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

// tableName(key) : [mapper(imapper),entity(dto)]
typeMapping = [
        (~/(?i)int/)                      : "INTEGER",
        (~/(?i)float|double|decimal|real/): "DOUBLE",
        (~/(?i)datetime|timestamp/)       : "TIMESTAMP",
        (~/(?i)date/)                     : "TIMESTAMP",
        (~/(?i)time/)                     : "TIMESTAMP",
        (~/(?i)/)                         : "VARCHAR"
]

// ***********************包名需手动填写************************
iMapperPackage = "cn.****.****.mapper"
pojoPackage = "cn.****.****.model"
// ************************************************************

FILES.chooseDirectoryAndSave("xuan wo!", "look look mapper!!!") { dir ->
  SELECTION.filter { it instanceof DasTable }.each { generate(it, dir) }
}

def generate(table, dir) {
  def baseName = mapperName(table.getName(), true)
  def fields = calcFields(table)
  new File(dir, baseName + "Mapper.xml").withPrintWriter { out -> generate(table, out, baseName, fields) }
}

def generate(table, out, baseName, fields) {
  def baseResultMap = 'resultMap'
  def base_Column_List = 'Base_Column_List'
  //def date = new Date().format("yyyy/MM/dd")
  def tableName = table.getName()

  def imapper = iMapperPackage + ".I${baseName}Mapper"
  def pojo = pojoPackage + ".${baseName}"

  out.println mappingsStart(imapper)
  out.println ""
  out.println '''   <!-- Database Mapping -->'''
  out.println resultMap(baseResultMap, pojo, fields)
  out.println sql(fields, base_Column_List)
  out.println MyInsert(baseName, tableName, fields, pojo)
  //嘿 下面的代码自己研究吧。。我就不剧透了
 // out.println MySelectById(baseName,tableName, fields, baseResultMap, base_Column_List)
 // out.println MySelectList(baseName,tableName, fields, pojo, base_Column_List, baseResultMap)
 // out.println MyUpdateById(baseName,tableName, fields, pojo)
  out.println mappingsEnd()

}

static def resultMap(baseResultMap, pojo, fields) {

  def inner = ''
  fields.each() {
    inner += '\t\t<result column="' + it.sqlFieldName  + '" property="' + it.name + '"/>\n'
  }

  return '''\t<resultMap id="''' + baseResultMap + '''" type="''' + pojo + '''">\n''' + inner + '''\t</resultMap>'''
}

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 += [[
                       comment     : col.getComment(),
                       name        : mapperName(col.getName(), false),
                       sqlFieldName: col.getName(),
                       type        : typeStr,
                       annos       : ""]]
  }

}

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

// ------------------------------------------------------------------------ mappings
static def mappingsStart(mapper) {
  return '''<?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="''' + mapper + '''">
'''
}

// ------------------------------------------------------------------------ mappings
static def mappingsEnd() {
  return '''</mapper>'''
}


// ------------------------------------------------------------------------ MyInsert
static def MyInsert(baseName, tableName, fields, parameterType) {

  return '''
    <!-- 保存 -->
    <insert id="insertSingle" useGeneratedKeys="true" keyColumn="ID" keyProperty="id">
        INSERT INTO ''' + tableName.toUpperCase() + '''(''' + columnForCommonInsert(fields) + ''')
        VALUES(''' + columnValueForCommonInsert(fields) + ''')
    </insert>
'''

}



// ------------------------------------------------------------------------ sql
static def sql(fields, base_Column_List) {
  def str = '''\t<sql id="''' + base_Column_List + '''">
        @inner@
    </sql> '''

  def inner = ''
  fields.each() {
    inner += ('' + it.sqlFieldName + ',')
  }

  return str.replace("@inner@", inner.substring(0, inner.length() - 1))

}


//下面是一些数据处理的方法
static def testNotNullStrWhereWithoutIdForUpdate(fields) {
  def inner = ''
  fields.each {
    if (it.sqlFieldName.toUpperCase() != "ID"){
      inner += '''\t\t\t<if test="''' + it.name + ''' != null">  ''' + it.sqlFieldName + ''' = #{''' + it.name + '''}, </if>\n'''
    }
  }

  return inner
}

static def testNotNullStrWhereWithoutIdForSelect(fields) {
  def inner = ''
  fields.each {
    if (it.sqlFieldName.toUpperCase() != "ID"){
      inner += '''\t\t\t<if test="''' + it.name + ''' != null">  AND ''' + it.sqlFieldName + ''' = #{''' + it.name + '''} </if>\n'''
    }
  }

  return inner
}

static def testNotNullStrWhere(fields) {
  def inner = ''
  fields.each {
    inner += '''\t\t\t<if test="''' + it.name + ''' != null">  ''' + it.sqlFieldName + ''' = #{''' + it.name + '''}, </if>\n'''
  }

  return inner
}

static def testNotNullStrSet(fields) {
  def inner = ''
  fields.each {
    inner += '''
        <if test="''' + it.name + ''' != null">
            #{''' + it.name + '''},
        </if>\n'''
  }

  return inner
}

static def testNotNullStr(fields) {
  def inner1 = ''
  fields.each {
    inner1 += '''
        <if test = "''' + it.name + ''' != null" >
        \t''' + it.sqlFieldName + ''',
        </if>\n'''
  }

  return inner1
}

static def columnWithoutId(fields) {
  def inner2 = ''
  fields.each {
    if(it.sqlFieldName != "ID" && it.sqlFieldName != "Id" && it.sqlFieldName != "id") {

      inner2 +=
              it.sqlFieldName + (it != fields.last()?''',''':'''''')
    }
  }

  return inner2
}
static def columnForCommonInsert(fields) {
  def inner2 = ''
  fields.each {
    if(it.sqlFieldName != "ID" && it.sqlFieldName != "Id" && it.sqlFieldName != "id"
            && it.sqlFieldName != "create_time"
            && it.sqlFieldName != "update_time"
            && it.sqlFieldName != "update_user") {

      inner2 +=
              it.sqlFieldName + (it.sqlFieldName != "create_user"?''',''':'''''')
    }
  }


  return inner2
}

static def columnValueForCommonInsert(fields) {
  def inner3 = ''
  fields.each {
    if(it.sqlFieldName != "ID" && it.sqlFieldName != "Id" && it.sqlFieldName != "id"
            && it.sqlFieldName != "create_time"
            && it.sqlFieldName != "update_time"
            && it.sqlFieldName != "update_user") {

      inner3 += '''#{''' +
              it.name + (it.sqlFieldName != "create_user"?'''},''':'''}''')
    }
  }

  return inner3
}

然后玩儿去吧！

在这里插入图片描述
后面就不多说了，有手就行！芜湖~~

在这里插入图片描述

Idea 自动生成 Dao,mapper,pojo 类
小小彭
04-09 1476
首先想要自动生成Dao mapper pojo 类 需要两个resources 下面的两个文件 一个是连接数据库使用的 db.properties另一个是生成类的关键generatorConfig.xml 1.db.properties 需要就是连接数据库的路径 ，账号和密码 2.generatorConfig.xml 需要注意的是 pojo mapper.xml Dao 的路径还有就是表的字段 3.双击 4.控制台出现 success 就是成功 然后需要的类就建好了 ...
通过idea连接数据库生成pojo实体对象
qq843033514的博客
02-08 1270
首先先用idea连接数据库，在idea右侧点击Database按钮 2. 选择数据库类型 配置数据库连接信息，填写完信息之后点击ok 成功连接之后会显示连接后的数据库信息，展开数据库后会看到数据表 6.选中要映射生成pojo对象的数据表右键 7.选择保存路径 ...
idea自动生成实体类、mapper代码
最新发布
weixin_43993069的博客
09-23 391
idea自动生成代码，可以生成实体类，以及mapper文件中的实体类代码、insert代码。
idea连接database自动生成po mapper通过mybatis
qq_37781796的博客
11-09 454
使用idea右侧的database自动生成po mapper service impl文件
IDEA 自动生成Mapper
wang845252276的专栏
11-28 5763
还在为数据表太多而烦恼吗? No, 我要偷懒, 让其自动创建。 了解到 maven 有插件可以生成mapper， 但那不是我想要的，我想要的是 @注解方式 通过数据表实体自动创建 我从中得到了启发，那就是 拼接字符串并生成文件，正好可以获取数据表与字段信息 自动生成流程 菜单 首先选择要添加的表，一个或多个， 右键-Scripted Extensions 就有一个脚本选择菜单 从中选择 Gener...
springboot之使用idea时根据数据库表自动生成实体类和mapper
ddjjfff的博客
12-12 1407
1. 根据操作系统检查generatorConfig.xml中src\main\java 中 斜杠问题。2. 检查启动配置Working Directory必须到启动项目。成功---------------------------------------------2. CommentGenerator的全路径地址。1. 实体类和mapper生成的包全路径。点击执行main方法，成功则控制端无输出。
IDEA逆向生成POJO/DAO/MAPPER 《Generate POJOs.groovy》
07-11
IDEA自带的插件Generate POJOs.groovy 比较简陋，不能生成完整的dao/mapper,切生成的POJO没有注解。没有统一格式化，所以在此基础上进行了扩展能够简单的生成pojo/dao/mapper. 使用时选择目录后会在改目录下生成...
mybatis 自动生成 pojo mapper dao 层配置文件
08-09
mybatis 自动生成 pojo mapper dao 层配置文件
mybatis 生成 pojo mapper dao 的工具包
08-09
mybatis 生成 pojo mapper dao 的工具包
mybatis自动生成mapper、pojo、dao文件-附件资源
03-02
mybatis自动生成mapper、pojo、dao文件-附件资源
MyBatis逆向工程自动生成代码
Z_atmosphere的博客
09-20 325
什么是逆向工程 MyBatis的一个主要的特点就是需要程序员自己编写sql，那么如果表太多的话，难免会很麻烦，所以mybatis官方提供了一个逆向工程，可以针对单表自动生成mybatis执行所需要的代码（包括mapper.xml、mapper.java、po..）。一般在开发中，常用的逆向工程方式是通过数据库的表生成代码。 使用逆向工程 使用MyBatis的逆向工程，需要导入逆向工程的jar...
idea 自动生成pojo类
qq_42572322的博客
07-26 391
点击后选择你将要生成的pojo需要保存到哪个文件，然后再次点击，就生成好了，然后自己稍作修改即可使用该pojo类了。找到这个View>Tool Windows>Database配置数据库。配置好后刷新，查看是否连接上表。
IDEA通过数据库生成model和mapper（maven管理jar包）
qq_38018309的博客
12-04 885
本文以记录相关方法为目的，只有最基础的功能，实例代码是由另一个代码生成器项目生成的，作为例子略有简陋。 第一步：准备工作 通过IDEA创建maven工程，不采用模板，并创建项目的基础结构，并在pom.xml中添加依赖的jar包。 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent<
IDEA——mybatis-generator自动生成dao/model/mapper
Adele的专栏
02-23 5183
本文将记录利用mybatis生成器插件自动生成生成实体类model、dao和mapper映射文件。 开发工具：IntelliJ IDEA2017.3.3 项目数据库为springdemo.sql，数据库中有两张表blog和user，将通过mybatis-generator插件来生成blog和user对应的dao、model和mapper。 以下是我的项目结构： 步骤如下： 1.创建M...
IDEA上数据库逆向工程，自动生成bean,dao,mapper文件。
qq_33530266的博客
01-09 1万+
第一步：将项目中的pom.xml文件中的build模块扩展成如下模样             maven 逆向工程--> org.mybatis.generator mybatis-generator-maven-plugin 1.3.5 true true
idea中springboot+mybatis逆向工程自动生成pojo实体类 、mapper
yangjunsc的专栏
05-12 1005
第一步：创建springboot工程，file->new->project,打开下面对话框 第二步：选择Spring Initializr,点击next出现如下对画框 第三步：填写工程相关信息如下，其他信息可以不用管 第四步：点击next出现下图，选择相关依赖 第五步：点击next 第六步：点击finish 第七步：在build中添加自动生成代码插件 <!-- mybatis generator 自动生成代码插件 --> <plugin&
idea中dataBase模板生成
xnian_的博客
09-13 568
【代码】idea中dataBase模板生成。
idea中mybatis自动生成pojo、mapper.xml、接口
qq_27886997的博客
05-08 5512
在maven工程中的resource中创建generatorConfigxml 配置generatorConfigxml的 配置pomxml 生成对象的两种方式 方式一使用idea的maven插件直接快速生成 方式二在Intellij IDEA添加一个Run运行选项使用maven运行mybatis-generator-maven-plugin插件 St...
IDEA中使用mybatis-generator自动生成mapper和pojo文件
热门推荐
你好，我们在哪里见过啊！
01-29 4万+
最近在测试mysql的时候，当我们在数据库当中新建了一个数据表的时候，需要用到mybatis。由于单表的增删改查的mapper文件以及对应的pojo基本上都是一个模式的，或者也是相差不远的，所以研究如何使用mybatis-generator逆向工程生成mapper文件以及pojo。 第一步：在maven工程当中的resource下面，创建generatorConfig.xml文件。 第
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值