使用 SpringBoot3 打造个性化的代码生成器

Spring Boot代码生成器模板 Spring Boot代码生成器是Mybatis-plus提供的逆向生成代码的工具,通过编写生成器,进行数据库及相应生成路径配置,可在指定文件下生成entity、controller、mapper及service层;代码生成器(新) | MyBatis-Plus。 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

1fcabfb3faa251b141353ae185ab97b5.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:blog.youkuaiyun.com/qq_51076413
/article/details/135394070


0 自定义代码生成器

代码基于SpringBoot3、Vue3、highlight实现自定义代码生成功能

SpringBoot3.x、MySQL8、MyBatisPlus3.5.x、velocity2.x、SpringSecurity6.x、Vue3、TypeScript、highlight

demo所需要的依赖及其对应版本号

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>

    <groupId>cn.molu</groupId>
    <artifactId>mgzyf-api</artifactId>
    <version>2.4.1</version>
    <description>Java 17 + SpringBoot3 + SpringSecurity6 </description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.5</version> <!-- lookup parent from repository -->
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <hutool.version>5.8.15</hutool.version>
        <mysql.version>8.0.28</mysql.version>
        <druid.version>1.2.16</druid.version>
        <mybatis-plus.version>3.5.3.1</mybatis-plus.version>
        <mapstruct.version>1.5.3.Final</mapstruct.version>
        <lombok-mapstruct-binding.version>0.2.0</lombok-mapstruct-binding.version>
    </properties>

    <dependencies>
        <!-- velocity -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <!--编译测试环境,不打包在lib-->
            <scope>provided</scope>
        </dependency>
        
        <!-- 允许使用Lombok的Java Bean类中使用MapStruct注解 (Lombok 1.18.20+) -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok-mapstruct-binding</artifactId>
            <version>${lombok-mapstruct-binding.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--    hutool工具包    -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>

  <!-- web支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  
  <!-- security安全支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

  <!-- 连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

  <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!--    阿里druid工具包    -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.40</version>
        </dependency>

  <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

  <!-- 参数验证 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

  <!-- 自定义配置类支持 -->
        <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-configuration-processor</artifactId>
         <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

1 代码生成实现步骤

配置文件

这里是最基础的MySQL的配置信息

application

server:
  port: 8989

spring:
  jackson:
    # 默认序列化时间格式
    date-format: yyyy-MM-dd HH:mm:ss
    # 默认序列化时区
    time-zone: GMT+8
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      master:
        url: jdbc:mysql://127.0.0.1:3306/test01?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true
        username: xxx
        password: 123
        driver-class-name: com.mysql.cj.jdbc.Driver
      initial-size: 15
      min-idle: 15
      max-active: 200
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: ""
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: false
      connection-properties: false


> 基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
>
> * 项目地址:<https://github.com/YunaiV/yudao-cloud>
> * 视频教程:<https://doc.iocoder.cn/video/>

# 配置生成代码的数据库
cn:
  molu:
    generate:
      database: test01
1.1、代码生成器源码目录

这里是代码生成器的源码目录结构,下面会逐一展示这3个类

b1d765e71036442cac837ee644ee681c.png
1.2、自定义模板目录

这里是根据我的项目需要,自定义的代码生成器模板,下面会以Service为例解释

327407867c4e3d193a9a436ee61c1935.png
1.3、代码生成器源码

1.3.1、API接口层

提供数据到Vue页面的API接口,主要功能是将模板解析为代码返回给前台

import cn.molu.system.common.result.Result;
import cn.molu.system.generate.mapper.ColumnDetailMapper;
import cn.molu.system.generate.vo.ColumnDetailVo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.exception.MethodInvocationException;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;
import java.io.IOException;
import java.io.StringWriter;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * @author 陌路
 * @apiNote 数据库表细信息
 * @date 2023/12/31 13:16
 * @tool Created by IntelliJ IDEA
 */
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/gen")
public class ColumnDetailController {

    @Value("${cn.molu.generate.database}")
    private String database; // 这里是数据库的名字,我的数据库是 test01
    private final ColumnDetailMapper columnDetailMapper;

    /**
     * 获取所有表信息数据
     *
     * @return List<ColumnDetailVo>
     */
    @GetMapping("/getAllTables")
    @Cacheable(value = "gen:allTableDetails", key = "#root.methodName")
    public Result<List<ColumnDetailVo>> getAllTables() {
        List<ColumnDetailVo> columnDetailVoList = columnDetailMapper.getColumnDetailMapVo(database);
        return Result.success(columnDetailVoList);
    }

    /**
     * 获取所有表中字段信息数据
     *
     * @param tableName 表名
     * @return List<ColumnDetailVo>
     */
    @GetMapping("/getTableInfo/{tableName}")
    public Result<String> getTableInfo(@PathVariable String tableName,
                                       @RequestParam(value = "delPrefix", required = false) String delPrefix,
                                       @RequestParam(value = "packageName", required = false) String packageName,
                                       @RequestParam(value = "type") String type
    ) {
        List<ColumnDetailVo> columnDetailVoList = columnDetailMapper.getColumnDetailMapVoByTableName(database, tableName);
        try (StringWriter writer = new StringWriter()) {
            // 初始化Velocity引擎
            Properties p = new Properties();
            // 加载classpath目录下的vm文件
            p.setProperty("resource.loader.file.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
            // 定义字符集
            p.setProperty(Velocity.INPUT_ENCODING, "UTF-8");
            // 初始化Velocity引擎,指定配置Properties
            Velocity.init(p);
            // 获取模板
            Template template = Velocity.getTemplate("vm/" + type + ".vm", "UTF-8");
            ColumnDetailVo detailVo = new ColumnDetailVo();
            Map<String, Object> map = detailVo.listToMap(columnDetailVoList, delPrefix); // 去除前缀
            map.put("packageName", packageName); // 文件所在包
            // 创建Velocity上下文
            VelocityContext context = new VelocityContext();
            // 设置模板中的变量
            context.put("map", map);
            // 将模板与上下文数据进行合并
            template.merge(context, writer);
            // 输出结果
            String writerString = writer.toString();
            return Result.success(writerString);
        } catch (IOException | ResourceNotFoundException | ParseErrorException | MethodInvocationException e) {
            log.error("报错了:" + e.getMessage(), e);
        }
        return Result.failed();
    }
}

1.3.2、Mapper

查询数据库,获取表字段信息,以便后面生成代码使用

import cn.molu.system.generate.vo.ColumnDetailVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;

/**
 * @author 陌路
 * @apiNote 数据库表细信息
 * @date 2023/12/31 13:14
 * @tool Created by IntelliJ IDEA
 */
@Mapper
public interface ColumnDetailMapper {

    /**
     * 获取所有表信息数据
     *
     * @return List<ColumnDetailVo>
     */
    public List<ColumnDetailVo> getColumnDetailMapVo(@Param("database") String database);

    /**
     * 获取所有表中字段信息数据
     *
     * @param tableName 表名
     * @return List<ColumnDetailVo>
     */
    public List<ColumnDetailVo> getColumnDetailMapVoByTableName(@Param("database") String database, @Param("tableName") String tableName);
}

1.3.3、对应Mapper的xml

根据application中指定的数据库名,获取数据库中所有的表名以及表中的字段名

<?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="cn.molu.system.generate.mapper.ColumnDetailMapper">

    <resultMap type="cn.molu.system.generate.vo.ColumnDetailVo" id="ColumnDetailMap">
        <result property="tableName" column="table_name" jdbcType="VARCHAR"/>
        <result property="tableComment" column="table_comment" jdbcType="VARCHAR"/>
        <result property="engine" column="engine" jdbcType="VARCHAR"/>
        <result property="tableCollation" column="table_collation" jdbcType="VARCHAR"/>
        <result property="tableRows" column="table_rows" jdbcType="VARCHAR"/>
        <result property="createTime" column="create_time" jdbcType="VARCHAR"/>
    </resultMap>

    <!--  获取所有表信息数据  -->
    <select id="getColumnDetailMapVo" resultMap="ColumnDetailMap">
        select table_name, <!-- 表名 -->
               table_comment, <!-- 表名注释 -->
               engine,  <!-- 表数据引擎 -->
               table_collation,  <!-- 表字符集 -->
               table_rows,  <!-- 表中数据条数 -->
               create_time <!-- 表创建时间 -->
        from information_schema.tables
        where upper(table_schema) = upper(#{database})
    </select>

    <!--  获取所有表中字段信息数据  -->
    <select id="getColumnDetailMapVoByTableName" parameterType="string" resultMap="ColumnDetailMap">
        SELECT TABLE_SCHEMA, <!-- 数据库名 -->
               TABLE_NAME, <!-- 表名 -->
               (select b.table_comment
                  from information_schema.tables b
                 where upper(table_schema) = upper(#{database})
                   and upper(table_name) = upper(#{tableName})
                 limit 1) as TABLE_COMMENT, <!-- 表名注释 -->
               COLUMN_NAME, <!-- 字段名 -->
               COLUMN_DEFAULT, <!-- 默认值 -->
               IS_NULLABLE, <!-- 是否可为空:YES、NO -->
               DATA_TYPE, <!-- 数据类型:int、varchar... -->
               COLUMN_TYPE, <!-- 字段类型:int、varchar(30)... -->
               COLUMN_KEY, <!-- 是否主键:PRI -->
               EXTRA, <!-- 是否自增:auto_increment(自增) -->
               COLUMN_COMMENT <!-- 字段注释 -->
        FROM information_schema.columns a
        WHERE upper(table_schema) = upper(#{database})
          AND upper(table_name) = upper(#{tableName})
    </select>
</mapper>

1.3.4、各字段想起类

对应表中字段和字段信息的实体类

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serial;
import java.io.Serializable;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author 陌路
 * @apiNote 数据库表细信息
 * @date 2023/12/31 13:21
 * @tool Created by IntelliJ IDEA
 */
@Data
@ToString
@NoArgsConstructor
@EqualsAndHashCode
@Accessors(chain = true)
@JsonInclude(value = JsonInclude.Include.NON_NULL, content = JsonInclude.Include.NON_EMPTY)
public class ColumnDetailVo implements Serializable {
    @Serial
    private static final long serialVersionUID = 9196390045041955368L;
//    ====================查询所有表信息====================
    /**
     * 表名
     */
    private String tableName;
    /**
     * 表名注释
     */
    private String tableComment;
    /**
     * 表数据引擎
     */
    private String engine;
    /**
     * 表字符集
     */
    private String tableCollation;
    /**
     * 表中数据条数
     */
    private String tableRows;
    /**
     * 表创建时间
     */
    @JsonFormat(pattern = "YYYY-MM-DD HH:mm:ss")
    @DateTimeFormat(pattern = "YYYY-MM-DD HH:mm:ss")
    private String createTime;

    //        ====================查询指定表中的字段信息====================
    /**
     * 数据库名
     */
    private String tableSchema;
    /**
     * 字段名
     */
    private String columnName;
    /**
     * 默认值
     */
    private String columnDefault;
    /**
     * 是否可为空:YES、NO
     */
    private String isNullable;
    /**
     * 数据类型:int、varchar...
     */
    private String dataType;
    /**
     * 字段类型:int、varchar(30)...
     */
    private String columnType;
    /**
     * 是否主键:PRI
     */
    private String columnKey;
    /**
     * 是否自增:auto_increment(自增)
     */
    private String extra;
    /**
     * 字段注释
     */
    private String columnComment;

    /**
     * 是否主键
     *
     * @param columnKey 字段键
     * @return 是否主键
     */
    public boolean isPrimaryKey(String columnKey) {
        return StrUtil.equalsIgnoreCase(columnKey, "PRI");
    }

    /**
     * 获取主键字段名
     *
     * @param list 字段列表
     * @return 主键字段名
     */
    public String getPrimaryKey(List<ColumnDetailVo> list) {
        return Optional.ofNullable(list)
                .orElseGet(ArrayList::new)
                .stream()
                .filter(item -> isPrimaryKey(item.columnKey))
                .findFirst()
                .orElseGet(ColumnDetailVo::new).columnName;
    }

    /**
     * 列表转Map
     *
     * @param list          列表
     * @param replacePrefix 替换前缀
     * @return Map
     */
    public Map<String, Object> listToMap(List<ColumnDetailVo> list, String replacePrefix) {
        if (Objects.isNull(list) || list.isEmpty()) return null;
        Map<String, Object> map = new HashMap<>(2);
        ColumnDetailVo detailVo = list.get(0);
        String voTableName = detailVo.getTableName().toLowerCase();
        String subTableName = voTableName.replace(replacePrefix, "");
        String className = toUpperFirst(subTableName);
        map.put("tableName", voTableName); // 表名
        map.put("tableComment", detailVo.getTableComment()); // 表名注释
        map.put("className", StrUtil.upperFirst(className)); // Java类名
        map.put("subClassName", className); // Java类名
        map.put("path", voTableName.replace("_", "/")); // 生成路径
        map.put("prem", voTableName.replace("_", ":")); // 权限标识
        map.put("currTime", DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN)); // 日期时间
        AtomicReference<String> pk = new AtomicReference<>();
        AtomicReference<String> pkType = new AtomicReference<>();
        AtomicReference<String> getterPk = new AtomicReference<>();
        AtomicReference<String> pkColumn = new AtomicReference<>();
        List<Map<String, String>> fields = new ArrayList<>(2);
        List<Map<String, String>> otherColumn = new ArrayList<>(2);
        list.forEach(vo -> {
            Map<String, String> field = new HashMap<>(2);
            field.put("columnName", vo.getColumnName()); // 字段名
            field.put("javaField", toUpperFirst(vo.getColumnName())); // 字段对应的Java字段
            field.put("columnComment", vo.getColumnComment()); // 字段注释
            String javaType = getJavaType(vo.getDataType());
            field.put("javaType", javaType); // java字段类型
            field.put("jdbcType", vo.getDataType().toUpperCase());
            field.put("jdbcTypeXml", getJdbcTypeXml(vo.getDataType().toLowerCase()));
            field.put("type", getType(vo.getDataType()));
            field.put("getter", StrUtil.upperFirst(toUpperFirst(vo.getColumnName())));
            if (isPrimaryKey(vo.getColumnKey())) {
                if (StrUtil.equalsIgnoreCase(javaType, "Integer")) {
                    javaType = "Long";
                }
                field.put("javaType", javaType); // java字段类型
                field.put("pkColumn", vo.getColumnName()); // 主键
                pk.set(toUpperFirst(vo.getColumnName()));
                pkColumn.set(vo.getColumnName());
                pkType.set(javaType);
                getterPk.set(StrUtil.upperFirst(toUpperFirst(vo.getColumnName())));
            } else {
                otherColumn.add(field);
            }
            fields.add(field);
        });
        map.put("columns", fields);
        map.put("otherColumn", otherColumn);
        map.put("pk", pk);
        map.put("pkColumn", pkColumn);
        map.put("pkType", pkType);
        map.put("getterPk", getterPk);
        return map;
    }

    /**
     * @title 获取字段类型
     * @author 陌路
     * @date 2023/12/31 21:01
     */
    private String getJdbcTypeXml(String dataType) {
        return switch (dataType) {
            case "int", "tinyint" -> "INTEGER";
            case "char" -> "CHAR";
            case "mediumint" -> "MEDIUMINT";
            case "bigint" -> "BIGINT";
            case "float" -> "FLOAT";
            case "double" -> "DOUBLE";
            case "bit" -> "BIT";
            case "datetime", "date", "time", "timestamp" -> "TIMESTAMP";
            default -> "VARCHAR";
        };
    }

    /**
     * @title 获取字段类型
     * @author 陌路
     * @date 2023/12/31 21:01
     */
    private String getType(String dataType) {
        String javaType = getJavaType(dataType);
        String type = "java.lang." + dataType;
        if (StrUtil.equals(javaType, "Date")) {
            type = "java.util.Date";
        }
        return type;
    }

    /**
     * @title 获取字段类型
     * @author 陌路
     * @date 2023/12/31 21:01
     */
    private String getJavaType(String dataType) {
        return switch (dataType) {
            case "bigint" -> "Long";
            case "datetime", "date", "time", "timestamp" -> "Date";
            case "decimal", "double" -> "Double";
            case "float" -> "Float";
            case "int", "tinyint", "integer" -> "Integer";
            default -> "String";
        };
    }

    /**
     * 首字母转大写
     *
     * @param field 字段
     * @return 首字母大写
     */
    public String toUpperFirst(String field) {
        // 表名转驼峰命名
        StringBuilder string = new StringBuilder();
        if (StrUtil.isNotEmpty(field) && field.contains("_")) {
            for (String str : field.split("_")) {
                string.append(StrUtil.upperFirst(str));
            }
        } else {
            string = new StringBuilder(StrUtil.upperFirst(field));
        }
        return StrUtil.lowerFirst(string.toString());
    }
}
1.4、自定义模板

自定义的模板,通过模板生成所需要的代码

package $!{map.packageName}.service;

import $!{map.packageName}.entity.$!{map.className};
import com.baomidou.mybatisplus.core.metadata.IPage;
import $!{map.packageName}.params.$!{map.className}Params;
import java.lang.*;

/**
 * @apiNote $!{map.tableComment}($!{map.className})表服务接口
 * @author 陌路
 * @date $!{map.currTime}
 * @tool Created by IntelliJ IDEA
 */
public interface $!{map.className}Service /* extends IService<$!{map.className}> */{

    /**
     * 通过ID查询单条数据
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param $!{map.pk} 主键
     * @return $!{map.subClassName} 实例对象
     */
    $!{map.className} queryById($!{map.pkType} $!{map.pk});

    /**
     * 分页查询
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param $!{map.subClassName}Params 筛选条件
     * @return IPage<$!{map.className}> 查询结果
     */
    IPage<$!{map.className}> queryByPage($!{map.className}Params $!{map.subClassName}Params);

    /**
     * 新增数据
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param $!{map.subClassName} 实例对象
     * @return $!{map.subClassName} 实例对象
     */
    $!{map.className} insert($!{map.className} $!{map.subClassName}));

    /**
     * 修改数据
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param $!{map.subClassName} 实例对象
     * @return $!{map.subClassName} 实例对象
     */
    $!{map.className} update($!{map.className} $!{map.subClassName}));

    /**
     * 通过主键作废(逻辑删除)
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param ids 主键
     * @return boolean 是否成功
     */
    boolean deleteByIds(String ids);

    /**
     * 通过主键删除(物理删除)
     *
     * @author 陌路
     * @date $!{map.currTime}
     * @param ids 主键
     * @return boolean 是否成功
     */
    boolean removeByIds(String ids);
}
1.5、页面预览代码

后台生成代码返回给vue页面,vue渲染,并使用语法高亮展示完整代码

<script setup lang="ts">
defineOptions({
  name: "Code",
  inheritAttrs: false,
});

import { ColumnDetailQuery, ColumnDetailVo } from "@/api/generate/types";
import { getAllTables, getTableInfo } from "@/api/generate";
import { ref, onMounted, reactive } from "vue";

import "highlight.js/styles/atom-one-light.css";
import "highlight.js/lib/common";
import hljs from "highlight.js";

const queryParams = reactive<ColumnDetailQuery>({});
const queryFormRef = ref(ElForm);
const dialog = reactive<DialogOption>({
  visible: false,
  title: "",
});
// 选择表格行的数据ID
const loading = ref(false); // 加载状态
const columnDetailVoList = ref<ColumnDetailVo[]>([]); // 记录列表数据
const dataType = ref(0); // 数据类型
const params = ref({
  tableName: "", // 表名
  delPrefix: "", // 删除前缀
  packageName: "cn.molu.system", // 所在包
  type: "java/entity.java", // 数据类型
});
const result = ref({});
const codeCache = new Map();
const tableName = ref("");
const preview = ref({
  activeName: "entity",
  data: [],
  title: "",
  open: false,
  code: null,
  vmName: "entity.java",
});
// 这里可以从后台获取,我这里为了直观的展示就写死了这几种
const tabPaneData = reactive<any[]>([
  {
    label: "entity.java",
    name: "entity",
    path: "java/entity.java",
  },
  {
    label: "controller.java",
    name: "controller",
    path: "java/controller.java",
  },
  {
    label: "service.java",
    name: "service",
    path: "java/service.java",
  },
  {
    label: "serviceImpl.java",
    name: "scopeImpl",
    path: "java/serviceImpl.java",
  },
  {
    label: "mapper.java",
    name: "mapper",
    path: "java/mapper.java",
  },
  {
    label: "mapperXml.xml",
    name: "mapperXml",
    path: "xml/mapper.xml",
  },
  {
    label: "params.java",
    name: "params",
    path: "java/params.java",
  },
  {
    label: "api.ts",
    name: "api",
    path: "vue3/api.ts",
  },
  {
    label: "page.vue",
    name: "page",
    path: "vue3/page.vue",
  },
  {
    label: "types.ts",
    name: "types",
    path: "vue3/types.ts",
  },
  {
    label: "sql.sql",
    name: "sql",
    path: "sql/sql.sql",
  },
]);

/**
 * 查询按钮点击事件
 */
const handleQuery = () => {
  getAllTables()
    .then(({ data }) => {
      columnDetailVoList.value = data;
    })
    .finally(() => {
      loading.value = false;
    });
};

/**
 * 重置按钮点击事件
 */
const resetQuery = () => {
  queryFormRef.value.resetFields();
  handleQuery();
};
/** 关闭弹窗 */
const closeDialog = () => {
  dialog.visible = false;
};

/**
 * 显示弹框
 */
const openDialog = (row: ColumnDetailVo) => {
  dialog.visible = true;
  dialog.title = "代码预览";
  console.log(row);
  params.value.tableName = row.tableName || "";
  if (!params.value.delPrefix && row.tableName?.includes("_")) {
    params.value.delPrefix = row.tableName?.split("_")[0] + "_";
  }
  tableName.value = row.tableName || "";
  generateCode();
};

/**
 * 选择列表
 */
const changeSelect = (value: string) => {
  console.log(value);
  params.value.tableName = value;
  if (!params.value.delPrefix && value?.includes("_")) {
    params.value.delPrefix = value?.split("_")[0] + "_";
  }
  tableName.value = value || "";
  generateCode();
};

/**
 * 生成代码
 */
const generateCode = () => {
  let obj = codeCache.get(tableName.value) || {};
  let activeName = preview.value.activeName;
  if (obj && obj[activeName]) {
    let code = obj[activeName] || "";
    result.value = code;
    return;
  }
  getTableInfo(tableName.value, params.value).then((response) => {
    const data = response.data;
    preview.value.code = data;
    const vmName = preview.value.vmName || "";
    let language = vmName.substring(vmName.indexOf(".") + 1, vmName.length).toLowerCase();
    language =  ["vue", "html", "xml"].includes(language) ? "html" : language;
    language = language === 'js' ? "javascript": language;
    result.value = hljs.highlight(data || "", {
      language: language,
      ignoreIllegals: true,
    }).value;
    obj[activeName] = result.value || "";
    codeCache.set(tableName.value, obj);
    return result.value || "&nbsp;";
  });
};

/**
 * tab切换事件
 */
const tabChange = (tabPaneName: any) => {
  console.log(tabPaneName);
  preview.value.activeName = tabPaneName;
  const tabPane = tabPaneData.find((item) => item.name == tabPaneName);
  console.log(tabPane);
  preview.value.vmName = tabPane.label;
  params.value.type = tabPane.path;
  generateCode();
};
/**
 * 复制代码
 */
const clipboardSuccess = () => {
  ElMessage.success("复制成功");
};

/**
 * 选择页码,分页查询
 */
const updateCurrentPage = (page?: number) => {
  queryParams.page = page;
  handleQuery();
};

/**
 * 页面加载完成后执行
 */
onMounted(() => {
  handleQuery();
});
</script>

<template>
  <div class="app-container">
    <div class="search-container">
      <el-form ref="queryFormRef" :model="params" :inline="true">
        <!-- 表名 -->
        <el-form-item label="表名" prop="tableName">
          <el-input v-model="params.tableName" placeholder="表名" disabled />
        </el-form-item>
        <!-- 删除前缀 -->
        <el-form-item label="删除前缀" prop="delPrefix" v-if="false">
          <el-input
            v-model="params.delPrefix"
            placeholder="删除前缀"
            clearable
          />
        </el-form-item>
        <!-- 所在包 -->
        <el-form-item label="所在包" prop="packageName" v-if="false">
          <el-input
            v-model="params.packageName"
            placeholder="所在包"
            clearable
          />
        </el-form-item>
        <el-form-item>
          <el-button class="filter-item" type="primary" @click="handleQuery">
            <i-ep-search />
            搜索
          </el-button>
          <el-button @click="resetQuery"> <i-ep-refresh />重置 </el-button>
        </el-form-item>
      </el-form>
    </div>

    <el-card shadow="never" class="table-container">
      <el-scrollbar style="height: 400px">
        <el-table
          v-loading="loading"
          :data="columnDetailVoList"
          row-key="id"
          default-expand-all
          :tree-props="{ children: 'children', hasChildren: 'hasChildren' }"
        >
          <!-- 复选款 -->
          <el-table-column type="selection" width="55" align="center" />
          <!-- 序号 -->
          <el-table-column
            type="index"
            width="55"
            align="center"
            label="序号"
          />
          <!-- 数据库名 -->
          <el-table-column
            label="数据库名"
            align="center"
            prop="tableSchema"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.tableSchema }}
            </template>
          </el-table-column>
          <!-- 表名 -->
          <el-table-column label="表名" align="center" prop="tableName">
            <template #default="scope">
              {{ scope.row.tableName }}
            </template>
          </el-table-column>
          <!-- 表注释 -->
          <el-table-column
            label="表注释"
            align="center"
            prop="tableComment"
            v-if="dataType == 0"
          >
            <template #default="scope">
              {{ scope.row.tableComment }}
            </template>
          </el-table-column>
          <!-- 表数据引擎 -->
          <el-table-column
            label="表引擎"
            align="center"
            prop="engine"
            v-if="dataType == 0"
          >
            <template #default="scope">
              {{ scope.row.engine }}
            </template>
          </el-table-column>
          <!-- 表字符集 -->
          <el-table-column
            label="字符集"
            align="center"
            prop="tableCollation"
            v-if="dataType == 0"
          >
            <template #default="scope">
              {{ scope.row.tableCollation }}
            </template>
          </el-table-column>
          <!-- 表中数据条数 -->
          <el-table-column
            label="数据量"
            align="center"
            prop="tableRows"
            v-if="dataType == 0"
          >
            <template #default="scope">
              {{ scope.row.tableRows }}
            </template>
          </el-table-column>
          <!-- 表创建时间 -->
          <el-table-column
            label="创建时间"
            align="center"
            prop="createTime"
            v-if="dataType == 0"
          >
            <template #default="scope">
              {{ scope.row.createTime }}
            </template>
          </el-table-column>

          <!-- 字段名 -->
          <el-table-column
            label="字段名"
            align="center"
            prop="columnName"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.columnName }}
            </template>
          </el-table-column>
          <!-- 默认值 -->
          <el-table-column
            label="默认值"
            align="center"
            prop="columnDefault"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.columnDefault }}
            </template>
          </el-table-column>
          <!-- 是否可为空:YES、NO -->
          <el-table-column
            label="可为空"
            align="center"
            prop="isNullable"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.isNullable }}
            </template>
          </el-table-column>
          <!-- 数据类型:int、varchar... -->
          <el-table-column
            label="数据类型"
            align="center"
            prop="dataType"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.dataType }}
            </template>
          </el-table-column>
          <!-- 字段类型:int、varchar(30)... -->
          <el-table-column
            label="字段类型"
            align="center"
            prop="columnType"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.columnType }}
            </template>
          </el-table-column>
          <!-- 是否主键:PRI -->
          <el-table-column
            label="是否主键"
            align="center"
            prop="columnKey"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.columnKey }}
            </template>
          </el-table-column>
          <!-- 是否自增:auto_increment(自增) -->
          <el-table-column
            label="是否自增"
            align="center"
            prop="extra"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.extra }}
            </template>
          </el-table-column>
          <!-- 字段注释 -->
          <el-table-column
            label="字段注释"
            align="center"
            prop="columnComment"
            v-if="dataType == 1"
          >
            <template #default="scope">
              {{ scope.row.columnComment }}
            </template>
          </el-table-column>
          <!-- 操作 -->
          <el-table-column
            label="操作"
            fixed="right"
            align="left"
            width="200"
            v-if="dataType == 0"
          >
            <template #default="scope">
              <el-button
                type="primary"
                link
                size="small"
                @click.stop="openDialog(scope.row)"
              >
                <i-ep-view />预览
              </el-button>
            </template>
          </el-table-column>
        </el-table>
      </el-scrollbar>
      <div
        style="
          margin: 15px auto;
          display: flex;
          align-items: center;
          justify-content: center;
        "
      >
        <!-- 这里是分页插件 -->
        <!-- <el-pagination
          background
          layout="prev, pager, next"
          :total="queryParams.total"
          :default-page-size="10"
          v-model:page-size="queryParams.size"
          v-model:current-page="queryParams.page"
          @update:current-page="updateCurrentPage"
        /> -->
      </div>
    </el-card>

    <!-- 预览弹窗 -->
    <el-dialog
      v-model="dialog.visible"
      :title="dialog.title"
      destroy-on-close
      append-to-body
      align-center
      lock-scroll
      width="80%"
      @close="closeDialog"
      top="3vh"
    >
      <el-form ref="queryFormRef" :model="params" :inline="true">
        <!-- 表名 -->
        <el-form-item label="表名" prop="tableName">
          <el-select
            v-model="params.tableName"
            placeholder="表名"
            @change="changeSelect"
          >
            <el-option
              v-for="(item, i) in columnDetailVoList"
              :key="i"
              :label="item.tableName"
              :value="item.tableName"
            />
          </el-select>
        </el-form-item>
        <!-- 删除前缀 -->
        <el-form-item label="删除前缀" prop="delPrefix">
          <el-input v-model="params.delPrefix" placeholder="删除前缀" />
        </el-form-item>
        <!-- 所在包 -->
        <el-form-item label="所在包" prop="packageName">
          <el-input v-model="params.packageName" placeholder="所在包" />
        </el-form-item>
        <el-form-item>
          <el-button class="filter-item" type="primary" @click="generateCode">
            生成
          </el-button>
        </el-form-item>
      </el-form>

      <el-tabs
        v-model="preview.activeName"
        class="demo-tabs"
        @tab-change="tabChange"
      >
        <el-scrollbar max-height="420px">
          <el-tab-pane
            v-for="(item, key) in tabPaneData"
            :label="item.label"
            :name="item.name"
            :key="key"
          >
            <!-- <el-link :underline="false" 
              icon="el-icon-document-copy" 
              v-clipboard:copy="preview.code" 
              v-clipboard:success="clipboardSuccess" 
              style="float:right">复制</el-link> -->
            
            <pre class="hljs-container">
              <code class="hljs" v-html="result"></code>
            </pre>
          </el-tab-pane>
        </el-scrollbar>
      </el-tabs>
    </el-dialog>
  </div>
</template>

<style lang="scss" scoped>
/* 语法高亮 */
.hljs-container {
  position: relative;
  display: block;
  // width: 600px;
  padding: 30px 5px 2px;
  overflow-x: hidden;
  line-height: 20px;
  text-align: left;
  background: #21252b;
  box-shadow: 0 10px 30px 0 rgb(0 0 0 / 40%);
}

/** 3个点 */
.hljs-container::before {
  position: absolute;
  top: 10px;
  left: 15px;
  width: 12px;
  height: 12px;
  overflow: visible;
  font-weight: 700;
  font-size: 16px;
  line-height: 12px;
  white-space: nowrap;
  text-indent: 75px;
  background-color: #fc625d;
  border-radius: 16px;
  box-shadow: 20px 0 #fdbc40, 40px 0 #35cd4b;
  content: attr(codetype);
}

/** 滚动条 */
:deep(.hljs) {
  overflow-x: auto;
  color: #4887b8;
  background-color: #21252b;
  // background-color: #dddddd;
}

:deep(.hljs::-webkit-scrollbar) {
  width: 12px !important;
  height: 12px !important;
}

:deep(.hljs::-webkit-scrollbar-thumb) {
  height: 30px !important;
  background: #d1d8e6;
  background-clip: content-box;
  border: 2px solid transparent;
  border-radius: 19px;
  opacity: 0.8;
}

:deep(.hljs::-webkit-scrollbar-thumb:hover) {
  background: #a5b3cf;
  background-clip: content-box;
  border: 2px solid transparent;
}

:deep(.hljs::-webkit-scrollbar-track-piece) {
  width: 30px;
  height: 30px;
  background: #333;
}

::-webkit-scrollbar-button {
  display: none;
}
</style>
1.6、代码生成器的使用
  • 选择需要生成代码的表

  • 根据个人需求是否去除表前缀

  • 生成的代码所在的包路径

点击生成即可生成代码,并可以直接复制使用

572b5d46b3258e45940948e4450b9406.png
1.7、效果展示

1.7.1、菜单SQL

生成的菜单SQL语句,包含权限代码

bba940ac599eb9a31962083a2254d652.png

1.7.2、生成的vue3页面

可以生成vue3的语法支持的前端页面

431b6072bd4d6e4026bc129030cf6c2c.png

1.7.3、生成的xml文件

可以生成我们需要的mapper.xml文件

里面包含对数据库的增删改查的语句

04c18e706c3f57ea0ce7029642fc4ebb.png

1.7.4、生成的Service代码

这里可以生成对Service的代码实现类

e79bce3a7b15668190c79cd5c9633398.png

1.7.5、生成的controller

生成对外提供的接口层,包含所需要的权限,接口问道的doc解释等

c1294b39a86bf850bb9c08c9a8344bb0.png

以上就是使用SpringBoot3、JDK17、Vue3、SpringSecurity6等实现的代码生成器了,其他页面就不一一展示了

优点:

  • 可扩展性高,可以根据自己不同的需求调整代码生成器以及生成逻辑

  • 可自定义生成内容,支持范围广

  • 可个自定义性化代码,按照自己喜欢的风格来自定义生成器


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

7480c59c7706b5c240e9224cec3b5b73.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

e5876da7c18da838e442cf115f2de6c5.png

68e27d69de8e059cddeeb7cd782edbcd.png4890958a9f65d26aa220e493f9ab4b71.pngd9ccc99c83de81d65e9c2ea7e6e1d775.png2b67e9613fd4054c0ae0c12f27303e1b.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
SpringBoot动态Banner实现:从原理到实战,打造个性化启动动画 在软件开发中,启动界面不仅是应用的门面,更是开发者体验的重要环节。SpringBoot通过其Banner机制,将启动过程可视化,体现了框架“约定优于配置”的设计理念。其核心原理基于Banner接口的扩展,允许开发者自定义启动时的输出内容。这一机制的技术价值在于,它提供了一种轻量级、非侵入式的项目个性化方案,同时作为理解SpringBoot扩展机制的切入点。在实际应用场景中,动态Banner能有效解决微服务架构下的服务识别问题,并可根据不同环境(如开发、测试、生产)配置差异化展示。通过集成环境感知与元数据展示 阅读详情

相关推荐

Dify工作流自动化:如何用Trae AI助手10倍提升你的开发效率(含避坑指南)

本文详细介绍了如何利用Trae AI助手自动化生成Dify工作流,实现开发效率的10倍提升。通过构建DSL示例库、精准需求描述和四步实战法,开发者可将重复的配置工作交给AI,快速生成可运行的工作流,并提供了关键的避坑指南。

weixin_29062865的博客 372

springboot项目中代码生成器保姆级教程

在选择的时候选择下述三个即可,springboot版本选择较低的即可。

qq_62403061的博客 2311

oh-my-zsh详细安装与主题插件配置

使用Linux的小伙伴都知道默认shell是bash,但是对于喜欢折腾,喜欢酷炫的我们bash怎能够用。zsh的作为一种shell,功能更强大,但是配置复杂。后来,有大佬创建了一个名为oh-my-zsh的开源项目,使用方便,功能强大。 下面就去oh-my-zsh的配置。 ①安装zsh 想要安装oh-my-zsh,首先得安装zsh,输入命令 sudo apt-get install zsh 界面如下 ②查看是否安装成功 输入命令 zsh --version 可以查看安装zsh的版本..

惜洛-Jankin的博客 2万+

如何自动生成SpringBoot项目代码

已经工作一段时间啦!首先是从后端开发开始入手的,前端也是在自学阶段(边学边问我身边的同事大佬),努力是往全栈积极靠拢。其实在我们写后端接口代码,像本人之前所写的文章中的那样,controller、entity、mapper、service、mapping各个层的所写代码和数据库配置文件都是固定的写法,基本的业务逻辑都是实现相关的增删查改。如果要实现实际项目中的多个接口,这些功能代码都是重复性的工作,并不会提升我们的工作效率。...

Fish_Vast的博客 6219

YOLO系列训练时出现loss出现nan值或者测试时P\R\map全部为0值的解决办法(GTX16xx系列显卡大坑)

YOLO系列训练时出现loss出现nan值或者测试时P\R\map全部为0值的解决办法(GTX16xx系列显卡大坑)

weixin_55249340的博客 3万+

批量导入经纬度点到奥维地图中

随便说说 最近出来出差,天天东奔西跑的,跑完了回到酒店还得整理一天的成果,基本上晚上9点才能整理完,累的基本上倒头就睡,没时间鼓捣自己喜欢的东西了。但想着也得写点啥吧,想来想去就那最近工作中用到的东西吧。因为我们现在的工作内容呢,基本上就是按照着上面给的地理位置找到地方开始检查。所以呢,就需要批量的把手上的经纬点信息导入到地图中,安排好路线,利用导航高效的找到地方。给的坐标就是gps点,wgs-84的,使用奥维地图最方便了,不用做坐标转换直接能用。所以作为组里的gis担(苦)当(力),这个导坐标的活就由我来

lionhenryzxxy的博客 3万+

35款优秀的 SpringBoot/SpringCloud 开源项目,开发脚手架,总有一款适合你!

简介SpringBoot 是一个非常流行的 Java 框架,它可以帮助开发者快速构建应用程序。他不仅继承了 Spring 框架原有的优秀特性,而且还通过简化配置来进一步简化了 Spring 应用的整个搭建和开发过程。最近,小编蹲点各大开源网站、社区等,终于被我找到了35款基于 SpringBoot/ SpringCloud 技术体系的一些开源框架。这些项目大都具备一些很完善的功能,并且均采用了当下...

田维常 5036

【无人机编队】基于matlab虚拟leader无人机编队仿真【含Matlab源码 3279期】

虚拟leader无人机编队仿真 完整代码,包运行;可提供运行操作视频!适合小白!

订阅付费专栏Matlab(奶茶价版),可赠送奶茶价版付费专栏指定代码1份; 837

【Spring实战】31 Spring Boot3 集成 Gateway 微服务网关

Spring Cloud Gateway 是一个基于 Spring Framework 的开源网关服务,用于构建微服务架构中的 API 网关。它提供了一种灵活的方式来路由请求、过滤请求以及对请求进行各种操作,从而实现对微服务的集中控制、安全性、监控等功能。Spring Cloud Gateway 提供了一个强大而灵活的工具,用于构建微服务架构中的 API 网关。通过合理配置,你可以实现路由、过滤、负载均衡等功能,为微服务架构提供了更好的可维护性和可扩展性。

好久不见的流星 6884

[特殊字符] RK3588 平台上基于 Panfrost 的 Mesa 驱动编译全过程

摘要: 本文详细记录了在RK3588平台(Ubuntu 20.04 aarch64)上编译基于Panfrost的Mesa驱动的全过程。内容包括:1)系统依赖安装;2)libdrm编译;3)Mesa配置参数优化;4)LLVM 15与SPIRV工具链的安装方法;5)SPIRV-Tools版本问题的解决方案;6)最终编译命令及常见错误处理。关键点在于正确设置工具链路径(PKG_CONFIG_PATH)和版本匹配(LLVM 15对应SPIRV-LLVM-Translator v15.0.0),推荐将组件安装在/op

梁俊星的博客 941

华为OD技术面真题 - Python开发 - 2

汇总华为OD技术面八股Python八股,高频技术真题并提供详细解答。

qq_45776114的博客 912

使用 SpringBoot 3 打造个性化的代码生成器

代码基于SpringBoot3、Vue3、highlight实现自定义代码生成功能demo所需要的依赖及其对应版本号pom<parent></parent>--编译测试环境,不打包在lib-->-- 允许使用Lombok的Java Bean类中使用MapStruct注解 (Lombok 1.18.20+) -->-- hutool工具包 -->-- web支持 -->-- security安全支持 -->-- 连接池 -->-- MySQL驱动 -->

2501_92606851的博客 487

k8s上分离集群seatunnel部署(生产推荐)

k8s上分离集群seatunnel部署(生产推荐)

寂夜了无痕的博客 891

手把手教你如何使用SpringBoot3打造一个个性化的代码生成器

SpringBoot3自定义代码生成器;自定义代码生成器;MyBatisPlus实现自定义代码生成器;可视化代码生成器;自定义可视化代码生成器;MyBatisPlus可视化代码生成器;SpringBoot3 + SpringSecurity6 + Vue3 可视化代码生成器;手把手教你如何打造属于自己的个性化代码生成器;

qq_51076413的博客 1687

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

SpringBoot代码生成器mapper model

Spring Boot 提供了一套默认配置,包括 Spring、Spring MVC、Spring Data JPA 等常用的基础框架,使得开发者能够轻松地将这些技术应用于项目中。代码生成器的原理主要是通过提取公共的代码部分,将其封装成可复用的模块或函数,避免重复编写相似的代码,从而提高开发效率。:这是一个可以帮助你快速创建Spring Boot项目的工具,你可以选择你需要的依赖并生成项目代码。:通过代码生成器生成的代码,一般具有较强的可读性和规范性,降低了因人工编写代码导致的错误。

ejinxian的专栏 378

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

3分钟用快马AI打造专属SpringBoot艺术Banner生成器

生成后,点击部署按钮就直接获得可访问的在线工具,还能把成品代码导出到本地项目。我测试时从输入需求到看到预览效果,整个过程比泡面熟得还快。每次启动SpringBoot项目时,那个默认的绿色横幅是不是有点单调?其实只需3分钟,你就能用。下次启动SpringBoot应用时,让同事对你的专业度刮目相看吧!下载按钮生成banner.txt。这个项目最爽的是——在。

SnowflakeJaguar14的博客 971

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

用Java+SpringBoot打造个性化手写体生成器(附完整源码)

本文详细介绍了如何利用Java和SpringBoot框架开发一个智能手写体生成系统。通过核心算法实现印刷体转手写体的自然效果,包括字形变异、笔画抖动和压力感应模拟等技术。文章还提供了完整的工程实现细节和高级功能扩展方案,帮助开发者快速构建个性化手写体生成器。

rice5的博客 739

毕业设计:基于SpringBoot3+Vue3的学习测评与反馈系统(源码)

本项目开发了一款基于SpringBoot3和Vue3的学习测评与反馈系统,旨在解决传统教学评价模式缺乏过程性跟踪的问题。系统采用前后端分离架构,后端使用SpringBoot3+MyBatis-Plus+JWT+SpringSecurity,前端采用Vue3+Element-Plus+Pinia+Vite,数据库选用MySQL8。主要功能包括:多角色用户管理、班级管理、考试管理、成绩分析与可视化展示、评语管理、家校沟通等。系统实现了学习过程的动态监测与量化评估,为教师提供教学决策支持,为学生提供个性化学习指导

鑫鑫源码工作室的博客 1599

SpringBoot动态Banner全攻略:从原理到实战,打造个性化启动界面

在Java应用开发中,启动界面是项目给用户的第一印象。SpringBoot框架提供了高度可定制的Banner模块,允许开发者通过简单的配置实现启动信息的个性化展示。其核心原理基于SpringBoot的启动扩展机制,通过加载特定格式的资源文件(如banner.txt、banner.gif)并调用相应的处理器,将静态或动态内容渲染到控制台。这一功能不仅提升了项目的专业感和品牌辨识度,更在内部工具、演示场景中增强了用户体验。从技术实现层面,开发者可以基于ANSI转义序列实现彩色文本效果,利用图像转换算法生成ASC

weixin_30475039的博客 519
上一篇: 推荐一款免费好用的远程桌面软件
下一篇: 如何在SpringBoot中优雅地重试调用第三方API?
公众号-芋道源码
博客等级 码龄10年 1638粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值