IDEA:数据库表生成pojo(lombok版)和service/dao层

最新推荐文章于 2024-05-08 13:25:54 发布
最新推荐文章于 2024-05-08 13:25:54 发布
阅读量706 收藏 1
点赞数
分类专栏： 开发工具 文章标签： intellij idea POJO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28929579/article/details/117638168
版权

springbootJpa生成样板代码

前言

公司自定义的eclipse插件能根据表自动生成mapper\controller\entity\service代码，也就是所谓的样板代码，用IDEA应该也有插件可以生成，不过不能自己定义相关内容，鉴于springBoot JPA对于CRUD来说开发量很少，很契合这种自动生成的样板代码。

方法

1.调出并配置项目所用的表

参考https://blog.csdn.net/sanqianweidu/article/details/106660590

2.找到所在位置并更改文件

  • 在这里插入图片描述
  • 替换文件，代码如下
import com.intellij.database.model.DasTable
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

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

packageName = "com.teacher.manage.demo.bo;"    // 此处指定包路径，也就对应实体类中的package com.topex.admin.entity;
typeMapping = [    // 此处指定对应的类型映射，如下：数据库中bigint对应生成java的Long，int|tinyint生成Integer...
                   (~/(?i)bigint/)                      : "Long",
                   (~/(?i)int|tinyint/)                 : "Integer",
                   (~/(?i)float|double|decimal|real/): "java.math.BigDecimal",
                   (~/(?i)date|datetime|timestamp/)       : "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 }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    new PrintWriter(new OutputStreamWriter(new FileOutputStream( new File(dir, className + ".java")), "utf-8")).withPrintWriter { out -> generate(out, className, fields) }
}

def generate(out, className, fields) {   // 从这里开始，拼实体类的具体逻辑代码
    out.println "package $packageName"
    out.println ""
    out.println "import lombok.Data;"     // 因为我使用了lombok插件，使用到了Data注解，所以在引包时加了这一行
    //out.println "import io.swagger.annotations.ApiModelProperty;"   // 同上，使用了swagger文档，所以引入到需要的注解
    out.println "import org.hibernate.annotations.DynamicUpdate;\n" +
            "\n" +
            "import javax.persistence.Entity;\n" +
            "import org.hibernate.annotations.GenericGenerator;\n" +
            "" +
            "import javax.persistence.Column;\n" +
            "import javax.persistence.GeneratedValue;\n" +
            "import javax.persistence.GenerationType;"

    out.println "import javax.persistence.Id;"  // tk.mybatis插件需用时需要@id注解，所以引入，不需要就去掉
    out.println ""
    out.println "@Entity"
    out.println "@DynamicUpdate"
    out.println "//@Proxy(lazy = false)"
    out.println "@Data"
    out.println "public class $className {"
    out.println ""
    int i = 0
    fields.each() {   // 遍历字段，按下面的规则生成
        // 输出注释，这里唯一的是id特殊判断了一下，如果判断it.name == id, 则多添加一行@Id
        if(i==0 ){
            if (it.type == "Integer") {
                out.println "\t@Id"
                out.println "\t@GeneratedValue(strategy = GenerationType.IDENTITY)"
                out.println "\t@Column(name = \"${it.realname}\")"
            }else if (it.type == "String") {
                out.println "\t@Id"
                out.println "\t@GenericGenerator(name=\"idGenerator\", strategy=\"uuid\") \n" +
                        "    @GeneratedValue(generator=\"idGenerator\")\n" +
                        "    @Column(name=\"${it.realname}\",length = 32)"
            }
        } else {
            if (isNotEmpty(it.commoent)) {
                out.println "\t/**"
                out.println "\t * ${it.commoent}"
                out.println "\t */"
            }
            if (it.annos != "") out.println "  ${it.annos}"
            out.println "\t@Column(name = \"${it.realname}\")"
        }
        out.println "\tprivate ${it.type} ${it.name};"
        out.println ""
        i++
    }
    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,
                           commoent: col.getComment(),
                           annos: "",
                           realname: col.getName()
                   ]]
    }
}

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

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]
}

3.选择所有的表，右键选择这个文件后，会弹窗，选择生成的位置

在这里插入图片描述
所有表的bo就生成啦~
同理 service\serviceImp\dao层的脚本如下

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

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

packageName = "com.teacher.manage.demo"    // 此处指定包路径，也就对应实体类中的package com.topex.admin
typeMapping = [    // 此处指定对应的类型映射，如下：数据库中bigint对应生成java的Long，int|tinyint生成Integer...
                   (~/(?i)bigint/)                      : "Long",
                   (~/(?i)int|tinyint/)                 : "Integer",
                   (~/(?i)float|double|decimal|real/): "java.math.BigDecimal",
                   (~/(?i)date|datetime|timestamp/)       : "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 }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    new PrintWriter(new OutputStreamWriter(new FileOutputStream( new File(dir, className + "Service.java")), "utf-8")).withPrintWriter { out -> generate(out, className, fields) }
}

def generate(out, className, fields) {   // 从这里开始，拼实体类的具体逻辑代码
    out.println "package ${packageName}.service;"
    out.println ""
    out.println "import ${packageName}.bean.*;\n" +
            "import ${packageName}.vo.*;\n"

    out.println "import java.util.List;"
    out.println "public interface ${className}Service {"

    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,
                           commoent: col.getComment(),
                           annos: ""]]
    }
}

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

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]
}
  • serviceImp
import com.intellij.database.model.DasTable
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

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

packageName = "com.teacher.manage.demo"    // 此处指定包路径，也就对应实体类中的package com.topex.admin
typeMapping = [    // 此处指定对应的类型映射，如下：数据库中bigint对应生成java的Long，int|tinyint生成Integer...
                   (~/(?i)bigint/)                      : "Long",
                   (~/(?i)int|tinyint/)                 : "Integer",
                   (~/(?i)float|double|decimal|real/): "java.math.BigDecimal",
                   (~/(?i)date|datetime|timestamp/)       : "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 }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    new PrintWriter(new OutputStreamWriter(new FileOutputStream( new File(dir, className + "ServiceImpl.java")), "utf-8")).withPrintWriter { out -> generate(out, className, fields) }
}

def generate(out, className, fields) {   // 从这里开始，拼实体类的具体逻辑代码
    out.println "package ${packageName}.service.impl;"
    out.println "import org.springframework.beans.BeanUtils;\n" +
            "import org.springframework.beans.factory.annotation.Autowired;\n" +
            "import org.springframework.data.domain.Page;\n" +
            "import org.springframework.data.domain.PageRequest;\n" +
            "import org.springframework.data.domain.Pageable;\n" +
            "import org.springframework.data.domain.Sort;\n" +
            "import org.springframework.stereotype.Service;\n" +
            "import org.springframework.transaction.annotation.Transactional;\n" +
            "import lombok.extern.slf4j.Slf4j;"
    out.println "import ${packageName}.bean.*;\n" +
            "import ${packageName}.vo.*;\n" +
            "import ${packageName}.enums.*;\n" +
            "import ${packageName}.exception.*;\n" +
            "import ${packageName}.dao.${className}Dao;\n" +
            "import ${packageName}.service.${className}Service;"
    out.println "@Service\n" +
            "@Slf4j\n" +
            "//@Transactional"
    out.println "public class ${className}ServiceImpl implements ${className}Service {"
    out.println "   @Autowired"
    out.println "   private ${className}Dao ${Case.LOWER.apply(className[0]) + className[1..-1]}Dao;"
    out.println "   \n" +
            "   /**\n" +
            "   @Override\n" +
            "    public List<UserMsgVo> getAllUserMsgByUserId(Integer pageNum, Integer pageLimit, String userId) {\n" +
            "        Sort sort = new Sort(Sort.Direction.DESC, \"date\");\n" +
            "        Pageable pageable = PageRequest.of(pageNum - 1, pageLimit, sort);\n" +
            "        Page<Message> msgPage = messageDao.findByFromId(userId, pageable);\n" +
            "    }\n" +
            "   */"
    out.println "   //BeanUtils.copyProperties(messageParam, msg);"
    out.println "   //log.info(\"保存/更新用户={}\", user);"
    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,
                       commoent: col.getComment(),
                       annos: ""]]
    }
}

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

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]
}
  • dao
import com.intellij.database.model.DasTable
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

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

packageName = "com.teacher.manage.demo"    // 此处指定包路径，也就对应实体类中的package com.topex.admin
typeMapping = [    // 此处指定对应的类型映射，如下：数据库中bigint对应生成java的Long，int|tinyint生成Integer...
                   (~/(?i)bigint/)                      : "Long",
                   (~/(?i)int|tinyint/)                 : "Integer",
                   (~/(?i)float|double|decimal|real/): "java.math.BigDecimal",
                   (~/(?i)date|datetime|timestamp/)       : "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 }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    new PrintWriter(new OutputStreamWriter(new FileOutputStream( new File(dir, className + "Dao.java")), "utf-8")).withPrintWriter { out -> generate(out, className, fields) }
}

def generate(out, className, fields) {   // 从这里开始，拼实体类的具体逻辑代码
    out.println "package ${packageName}.dao;"
    out.println ""
    out.println "import org.springframework.data.jpa.repository.JpaRepository;\n" +
            "import org.springframework.data.jpa.repository.Query;\n" +
            "import org.springframework.stereotype.Repository;"

    out.println "import org.springframework.data.domain.Page;\n" +
            "import org.springframework.data.domain.Pageable;" +
            "import java.util.List;" +
            "import ${packageName}.bo.${className};"
    out.println "@Repository"
    out.print "public interface ${className}Dao extends JpaRepository<$className, "
    //首列是主键
    if(fields[0].type == "String"){
        out.print "String"
    } else if(fields[0].type == "Integer"){
        out.print "Integer"
    }

    out.println "> {"
    out.println "    /**\n" +
            "  List<${className}> findAll();\n" +
            "  List<${className}> findAll(Sort sort);\n" +
            "  <S extends ${className}> List<S> save(Iterable<S> entities);\n" +
            "  void flush(); \n" +
            "  ${className} saveAndFlush(${className} entity); \n" +
            "  void deleteInBatch(Iterable<${className}> entities);\n" +
            "  void deleteAllInBatch();\n"+
            "  Page<${className}> findAll(Pageable pageable);\n" +
            "  <S extends ${className}> S save(S entity);\n" +
            "  <S extends ${className}> Iterable<S> save(Iterable<S> entities);\n" +
            "  ${className} findOne(ID id);\n" +
            "  boolean exists(ID id);\n" +
            "  Iterable<${className}> findAll();\n" +
            "  Iterable<${className}> findAll(Iterable<ID> ids);\n" +
            "  long count();\n" +
            "  void delete(ID id);\n" +
            "  void delete(${className} entity);\n" +
            "  void delete(Iterable<? extends ${className}> entities);\n" +
            "  void deleteAll();" +
            "  @Query(value = \"select new ${packageName}.dto.xx(jud.teachId, jud.courseId, jud.judgeType, jud.judgeId) from ${className} jud where jud.courseId = :courseId \" +\n" +
            "            \"and jud.teachId = :teacherId and jud.valid = :valid\"\n" +
            "            )\n" +
            "   List<${className}> findByTeachIdAndCourseIdAndValid(String teacherId, String courseId, String valid);\n" +
            "   Page<${className}> findByFromId(String fromId, Pageable pageable);\n" +
            "    @Query(value = \"select info.category_Type, info.answer from judge_info info where info.judge_Id = :judgeId\",\n" +
            "            nativeQuery = true)\n" +
            "    List<Object[]> findCategoryAndAnswerByJudgeId(@Param(\"judgeId\") String judgeId);\n" +
            "    @Query(value = \"update Token set valid = '0' where userId = :userId and valid = '1'\")\n" +
            "    @Modifying\n" +
            "    void updateValidOfUser(@Param(\"userId\") String userId);\n"+
            "*/"

    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,
                           commoent: col.getComment(),
                           annos: ""]]
    }
}

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

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]
}

我的目录结构如下
在这里插入图片描述

tips:

  • 按需更改。但是中文注释乱码没解决。。
  • bo类字段名爆红？没关联上表啦 虽说没关系但是看着不舒服，参考如下博客就行

https://blog.csdn.net/weixin_46822367/article/details/116916643

wqdsb
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
jpa代码自动生成工具-springboot
07-06
jpa代码自动生成工具- 自动生成domain/dao/service/controller
Intellij Idea自动生成实体类
qq_38531706的博客
06-23 5610
目录前言Intellij Idea自动生成jpa实体类1.idea连接数据库2.添加自定义groovy脚本2.1.domain脚本2.1.1 脚本2.1.2.效果2.2.dao脚本2.2.1.脚本2.2.1.效果2.3.service脚本2.3.1.脚本2.3.1.效果2.4.ext脚本2.4.1.脚本2.4.2.效果3.执行groovy脚本 前言 为了提高开发效率，对于简单但纯粹费时的dao，domain，service我们都希望能根据数据库字段自动生成，于是idea提供了能执行自定义groovy脚本的
在IDEA中，通过数据库结构为JPA生成实体类和Repository类
mmaosss的博客
12-19 1924
在IDEA中生成JPA实体类和Repository类
2024年最新java开发插件Lombok，阿里java后端面试
2401_84584238的博客
05-08 416
各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取ums/4f45ff00ff254613a03fab5e56a57acb)收录**需要这份系统化的资料的朋友，可以点击这里获取。
idea 根据数据库表快速生成Spring Data JPA实体类
qq_32814555的博客
03-20 4079
点击打开链接
idea插件EasyCode生成springboot的controller、service、serviceImpl、dao、mapper、entity代码
Meta39的博客
11-12 3324
idea插件EasyCode生成springboot的controller、service、serviceImpl、dao、mapper、entity代码
IDEA连接mysql生成实体类、mapper、service以及service实现类
rt5476238的博客
01-09 1173
生成的 service 和 service实现类分别使用了 Mybatis-plus中的 IService 和 ServiceImpl。点击添加按钮，并找到mysql后点击(这里是因为我最近使用过，所以在最上面，一般第一次使用在中间位置)第一次连接成功后这里可能没有显示数据库中的表，在数据库这里点击右键刷新，就可以看到表结构。生成的实体类使用了 Lombok 中的 @Data 注解，字段注释使用的mysql表中字段的注释。选中需要生成代码的表，点击右键，并点击 MybatisX-Generator。
使用IntelliJ IDEA自动生成Spring Boot代码 根据数据库自动生成Entity、DynamicSql、Dao、Service、Controller各层代码及swagger注解
weixin_44634880的博客
02-22 4474
写项目总是要花很多时间去写实体层，尽管可以直接把变量名一个个拖过去，还是很容易出错，很费神。 这几天发现可以用spring boot生成Entity代码，尝试了一把，发现挺好用的。 后来突发奇想，干脆让它生成所有基础代码算了，说干就干！ 先看看生成效果 生成前的项目目录，配置好项目结构，此时不到一千行Java代码 现在进行所有数据表的意见生成。注意！前方高能！！！！！ 两秒钟过后。。。 瞬间...
IDEA通过数据库表自动生成实体类(EasyCode)
weixin_47390965的博客
03-10 8501
IDEA自动生成实体类插件EasyCode，真香啊~ 只要配置了数据库，就可以通过数据库表格自动生成实体类。详细配置教程
IDEA逆向生成POJO/DAO/MAPPER 《Generate POJOs.groovy》
07-11
dao和mapper 抛弃了mybatis插件生成的一个POJO一个mapper 很冗余的数据，这里直接生成增删改查3个dao/mapper对照，依托于IDEA-DataBase-Tools能够直接选取需要生成POJOS 表模型的选择器。可以很方便的生成pojo/dao/...
table2pojo：为数据库表列生成POJO
02-04
表2 从数据库表/列生成POJO类的简单工具。 ### 支持所有JDBC支持的数据库。 包括以下JDBC驱动程序： OracleMySQL PostgreSQL可以在build.gradle文件中添加/更新JDBC驱动程序。建立使用gradle构建和组装具有依赖性的...
根据数据库自动生成DAO层以及pojo和sql
07-25
在IT行业中，数据库是存储和管理数据的核心工具，而DAO（Data Access Object）层、POJO（Plain Old Java Object）以及SQL（Structured Query Language）则是Java Web开发中的关键概念。本话题将深入探讨如何根据...
IDEA自动生成代码，包括PO层、DAO、SERVICE、SWAGGER注释类
09-04
2. **DAO层（Data Access Object）**：DAO接口和实现类负责与数据库进行交互，它们封装了SQL查询和更新操作。 3. **SERVICE层**：服务层是业务逻辑的承载者，调用DAO层进行数据操作，并处理复杂的业务规则。 4. **...
java术语（PO/POJO/VO/BO/DAO/DTO）
04-14
本文将详细解析"PO/POJO/VO/BO/DAO/DTO"这六个概念，并探讨它们在实际项目开发中的作用和应用场景。 1. PO（Persistent Object，持久化对象） PO是指与数据库表结构一一对应的Java对象，它通常包含了数据库表中的...
idea快速生成entity、dao、service
chuobenggu7592的博客
07-14 2985
经常写一些业务代码，学会快速生成项目上业务代码所需的类entity、dao、service类对我们提高工作效率很有帮助，整理步骤如下： 一、准备工作 在idea中连接数据库 下载idea的CodeMaker插件 二、生成实体类 准备生成实体类的groovy脚本,这里我直接用写好了的脚本，因...
手把手教你在IDEA中如何一键生成MAPPER，ENTITY，DAO，SERVICE，CONTROLLER类及增删改查方法的代码，提高开发效率！
我的青春一去不复返
05-09 4827
转载：https://www.freesion.com/article/75141011937/ 目录 1.准备工作 1.1.安装EasyCode和Lombok插件 1.2.创建一个springboot项目 1.3.准备数据库表 1.4.在IDEA配置连接数据库 2.生成代码 2.1.IDEA中生成代码 2.2.修改pom.xml文件（导入需要的依赖） 2.3.修改application.yml文件 2.4.在dao接口添加@Mapper注解 3.测试 4.常见问题 4.1.“T
Idea 通过数据库表生成实体类详细教程
u010980938的专栏
04-30 8003
Idea 添加数据源 修改生成脚本 可复制直接使用,关键点请看 TODO 说明 import com.intellij.database.model.DasTable import com.intellij.database.util.Case import com.intellij.database.util.DasUtil import java.text....
【低代码】手写模板根据数据库表自动生成后端Controller Service Dao层增删改查相关代码
Circ
09-01 540
随着科技不断演进，我们正逐渐迈向一个前所未有的时代。代码的自动化正成为现实，让人们不得不重新思考其在创造和创新中的角色。过去，编写代码是实现数字化愿景的关键，但随着人工智能和自动化工具的崛起，代码编写变得更加智能、高效，甚至开始自我完善。现在要求对一个绩效平台-福分按照这种思路进行重构。以下是一些可以实现这种功能的工具：MyBatis Generator 可以根据数据库表结构生成基本的 CRUD（增删改查）操作，包括实体类、Mapper 接口和 XML 配置文件。你可以配置生成的方式以及自定义查询方法。Sp
Idea生成Dao、Service、Controller，通过CodeMaker
红桃∩
06-17 2367
目录文章目录前提配置：DaoDaoImplServiceServiceImplController 文章目录 前提配置： Dao package $class.PackageName; import com.bocloud.bsm.cmdb.entity.${class.className}; import com.bocloud.common.model.Param; import com.bocloud.database.core.intf.GenericDao; import java.util
pojo层、dao层、service层、controller层
最新发布
05-11
在Java Web开发中，通常会采用MVC架构模式，将业务逻辑分为多个层次，每个层次各司其职，互相之间相对独立。其中，常用的四个层次是： 1. POJO层（Plain Old Java Object）：POJO 是普通的Java类，主要负责封装数据。POJO的属性通常是私有的，可以提供get/set方法进行访问和修改。POJO不依赖于任何框架，是一个纯净的Java对象，只提供属性的访问和修改方法。 2. DAO层（Data Access Object）：DAO 层主要负责与数据库进行交互，提供对数据库的访问和操作方法。DAO层主要包含增删改查等基本操作方法。DAO层将数据库操作与业务逻辑分离，提高了系统的可维护性。 3. Service层：Service 层主要负责业务逻辑的处理，通过调用 DAO 层提供的数据访问方法来完成业务逻辑的处理。Service 层通常是事务性的，在处理业务逻辑时需要保证数据的一致性和完整性。 4. Controller层：Controller 层主要负责接收用户请求，解析请求参数，调用相应的 Service 层进行业务处理，并将处理结果返回给用户。Controller 层通常是基于 MVC 模式实现的，通过 URL 映射来调用相应的 Controller 方法。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值