MyBatisGenerator修改源码实现model类增加Lombok注解及实现数据库注释

最新推荐文章于 2024-03-18 17:17:45 发布
最新推荐文章于 2024-03-18 17:17:45 发布
阅读量770 收藏
点赞数
分类专栏： Java MyBatis MyBatisGenerator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014653854/article/details/105364902
版权
Java 同时被 3 个专栏收录
144 篇文章 0 订阅
订阅专栏
MyBatis
9 篇文章 0 订阅
订阅专栏
MyBatisGenerator
1 篇文章 0 订阅
订阅专栏

MyBatisGenerator修改源码实现model类增加Lombok注解及实现数据库注释

1. 增加自定义Lombok插件类

/**
 *    Copyright 2006-2020 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.mybatis.generator.plugins;

import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.PluginAdapter;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
import org.mybatis.generator.api.dom.java.Interface;
import org.mybatis.generator.api.dom.java.Method;
import org.mybatis.generator.api.dom.java.TopLevelClass;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Properties;

/**
 * @author 2356999674@qq.com
 */
public class LombokPlugin extends PluginAdapter {

    private final Collection<Annotations> annotations;

    /**
     * LombokPlugin constructor
     */
    public LombokPlugin() {
        annotations = new LinkedHashSet<Annotations>(Annotations.values().length);
    }

    /**
     * @param warnings list of warnings
     * @return always true
     */
    @Override
    public boolean validate(List<String> warnings) {
        return true;
    }

    /**
     * Intercepts base record class generation
     *
     * @param topLevelClass     the generated base record class
     * @param introspectedTable The class containing information about the table as
     *                          introspected from the database
     * @return always true
     */
    @Override
    public boolean modelBaseRecordClassGenerated(
            TopLevelClass topLevelClass,
            IntrospectedTable introspectedTable
    ) {
        addAnnotations(topLevelClass);
        return true;
    }

    /**
     * Intercepts primary key class generation
     *
     * @param topLevelClass     the generated primary key class
     * @param introspectedTable The class containing information about the table as
     *                          introspected from the database
     * @return always true
     */
    @Override
    public boolean modelPrimaryKeyClassGenerated(
            TopLevelClass topLevelClass,
            IntrospectedTable introspectedTable
    ) {
        addAnnotations(topLevelClass);
        return true;
    }

    /**
     * Intercepts "record with blob" class generation
     *
     * @param topLevelClass     the generated record with BLOBs class
     * @param introspectedTable The class containing information about the table as
     *                          introspected from the database
     * @return always true
     */
    @Override
    public boolean modelRecordWithBLOBsClassGenerated(
            TopLevelClass topLevelClass,
            IntrospectedTable introspectedTable
    ) {
        addAnnotations(topLevelClass);
        return true;
    }

    /**
     * Prevents all getters from being generated.
     * See SimpleModelGenerator
     *
     * @param method             the getter, or accessor, method generated for the specified
     *                           column
     * @param topLevelClass      the partially implemented model class
     * @param introspectedColumn The class containing information about the column related
     *                           to this field as introspected from the database
     * @param introspectedTable  The class containing information about the table as
     *                           introspected from the database
     * @param modelClassType     the type of class that the field is generated for
     */
    @Override
    public boolean modelGetterMethodGenerated(
            Method method,
            TopLevelClass topLevelClass,
            IntrospectedColumn introspectedColumn,
            IntrospectedTable introspectedTable,
            ModelClassType modelClassType
    ) {
        return false;
    }

    /**
     * Prevents all setters from being generated
     * See SimpleModelGenerator
     *
     * @param method             the setter, or mutator, method generated for the specified
     *                           column
     * @param topLevelClass      the partially implemented model class
     * @param introspectedColumn The class containing information about the column related
     *                           to this field as introspected from the database
     * @param introspectedTable  The class containing information about the table as
     *                           introspected from the database
     * @param modelClassType     the type of class that the field is generated for
     * @return always false
     */
    @Override
    public boolean modelSetterMethodGenerated(
            Method method,
            TopLevelClass topLevelClass,
            IntrospectedColumn introspectedColumn,
            IntrospectedTable introspectedTable,
            ModelClassType modelClassType
    ) {
        return false;
    }

    /**
     * Adds the lombok annotations' imports and annotations to the class
     *
     * @param topLevelClass the partially implemented model class
     */
    private void addAnnotations(TopLevelClass topLevelClass) {
        for (Annotations annotation : annotations) {
            topLevelClass.addImportedType(annotation.javaType);
            topLevelClass.addAnnotation(annotation.asAnnotation());
        }
    }

    @Override
    public void setProperties(Properties properties) {
        super.setProperties(properties);

        //@Data is default annotation
        annotations.add(Annotations.DATA);
        annotations.add(Annotations.EQUALS_AND_HASHCODE);

        for (String annotationName : properties.stringPropertyNames()) {
            if (annotationName.contains(".")) {
                // Not an annotation name
                continue;
            }
            String value = properties.getProperty(annotationName);
            if (!Boolean.parseBoolean(value)) {
                // The annotation is disabled, skip it
                continue;
            }
            Annotations annotation = Annotations.getValueOf(annotationName);
            if (annotation == null) {
                continue;
            }
            String optionsPrefix = annotationName + ".";
            for (String propertyName : properties.stringPropertyNames()) {
                if (!propertyName.startsWith(optionsPrefix)) {
                    // A property not related to this annotation
                    continue;
                }
                String propertyValue = properties.getProperty(propertyName);
                annotation.appendOptions(propertyName, propertyValue);
                annotations.add(annotation);
                annotations.addAll(Annotations.getDependencies(annotation));
            }
        }
    }

    public boolean clientGenerated(
            Interface interfaze,
            TopLevelClass topLevelClass,
            IntrospectedTable introspectedTable
    ) {
        interfaze.addImportedType(new FullyQualifiedJavaType(
                "org.apache.ibatis.annotations.Mapper"));
        interfaze.addAnnotation("@Mapper");
        return true;
    }

    private enum Annotations {
        DATA("data", "@Data", "lombok.Data"),
        EQUALS_AND_HASHCODE("equalsAndHashCode", "@EqualsAndHashCode", "lombok.EqualsAndHashCode"),
        BUILDER("builder", "@Builder", "lombok.Builder"),
        ALL_ARGS_CONSTRUCTOR("allArgsConstructor", "@AllArgsConstructor", "lombok.AllArgsConstructor"),
        NO_ARGS_CONSTRUCTOR("noArgsConstructor", "@NoArgsConstructor", "lombok.NoArgsConstructor"),
        ACCESSORS("accessors", "@Accessors", "lombok.experimental.Accessors"),
        TO_STRING("toString", "@ToString", "lombok.ToString");


        private final String paramName;
        private final String name;
        private final FullyQualifiedJavaType javaType;
        private final List<String> options;


        Annotations(String paramName, String name, String className) {
            this.paramName = paramName;
            this.name = name;
            this.javaType = new FullyQualifiedJavaType(className);
            this.options = new ArrayList<String>();
        }

        private static Annotations getValueOf(String paramName) {
            for (Annotations annotation : Annotations.values())
                if (String.CASE_INSENSITIVE_ORDER.compare(paramName, annotation.paramName) == 0)
                    return annotation;

            return null;
        }

        private static Collection<Annotations> getDependencies(Annotations annotation) {
            if (annotation == ALL_ARGS_CONSTRUCTOR)
                return Collections.singleton(NO_ARGS_CONSTRUCTOR);
            else
                return Collections.emptyList();
        }

        // A trivial quoting.
        // Because Lombok annotation options type is almost String or boolean.
        private static String quote(String value) {
            if (Boolean.TRUE.toString().equals(value) || Boolean.FALSE.toString().equals(value))
                // case of boolean, not passed as an array.
                return value;
            return value.replaceAll("[\\w]+", "\"$0\"");
        }

        private void appendOptions(String key, String value) {
            String keyPart = key.substring(key.indexOf(".") + 1);
            String valuePart = value.contains(",") ? String.format("{%s}", value) : value;
            this.options.add(String.format("%s=%s", keyPart, quote(valuePart)));
        }

        private String asAnnotation() {
            if (options.isEmpty()) {
                return name;
            }
            StringBuilder sb = new StringBuilder();
            sb.append(name);
            sb.append("(");
            boolean first = true;
            for (String option : options) {
                if (first) {
                    first = false;
                } else {
                    sb.append(", ");
                }
                sb.append(option);
            }
            sb.append(")");
            return sb.toString();
        }
    }

}

2. 增加自定义注释生成类

/**
 *    Copyright 2006-2020 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.mybatis.generator.internal;

import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.dom.java.Field;
import org.mybatis.generator.api.dom.java.Method;
import org.mybatis.generator.api.dom.java.TopLevelClass;
import org.mybatis.generator.api.dom.xml.XmlElement;

import java.time.LocalDateTime;
import java.util.Properties;

/**
 * @author 2356999674@qq.com
 */
public class MyCommentGenerator extends DefaultCommentGenerator {
    private boolean suppressAllComments;
    private boolean addRemarkComments;
    private Properties properties;

    public MyCommentGenerator() {
        properties = new Properties();
    }

    @Override
    public void addConfigurationProperties(Properties properties) {
        // 获取自定义的 properties
        this.properties.putAll(properties);
    }

    /**
     * model类注释
     */
    @Override
    public void addModelClassComment(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
        String author = properties.getProperty("author");

        // 获取表注释
        String remarks = introspectedTable.getRemarks();

        topLevelClass.addJavaDocLine("/**");
        topLevelClass.addJavaDocLine(" * " + remarks);
        topLevelClass.addJavaDocLine(" *");
        topLevelClass.addJavaDocLine(" * @author " + author);
        topLevelClass.addJavaDocLine(" * @date " + LocalDateTime.now());
        topLevelClass.addJavaDocLine(" */");
    }

    /**
     * serialVersionUID注释
     */
    @Override
    public void addFieldComment(Field field, IntrospectedTable introspectedTable) {
        if (suppressAllComments) {
            return;
        }
        field.addJavaDocLine("/**"); //$NON-NLS-1$
        field.addJavaDocLine(" * 序列化 ID"); //$NON-NLS-1$
        field.addJavaDocLine(" */"); //$NON-NLS-1$
    }


    /**
     * 字段属性注释
     */
    @Override
    public void addFieldComment(Field field, IntrospectedTable introspectedTable,
                                IntrospectedColumn introspectedColumn) {
        if (suppressAllComments) {
            return;
        }
        StringBuilder sb = new StringBuilder();
        field.addJavaDocLine("/**");
        sb.append(" * ");
        sb.append(introspectedColumn.getRemarks());
        field.addJavaDocLine(sb.toString());
        field.addJavaDocLine(" */");
    }

    /**
     * Mapper接口方法注释
     */
    @Override
    public void addGeneralMethodComment(Method method, IntrospectedTable introspectedTable) {
        if (suppressAllComments) {
            return;
        }
    }
    /**
     * get方法注释
     */
    @Override
    public void addGetterComment(Method method, IntrospectedTable introspectedTable,
                                 IntrospectedColumn introspectedColumn) {
        if (suppressAllComments) {
            return;
        }
    }

    /**
     * set注释
     */
    @Override
    public void addSetterComment(Method method, IntrospectedTable introspectedTable,
                                 IntrospectedColumn introspectedColumn) {
        if (suppressAllComments) {
            return;
        }
    }

    /**
     * 添加xml文件的注释("完全反人类 没用")
     */
    @Override
    public void addComment(XmlElement xmlElement) {
        if (suppressAllComments) {
            return;
        }
    }
}

3. 重新打包

将GitHub上的mybatis/generator项目clone到本地，在mybatis-generator-core目录下，分别将两个新加的类添加，添加之后重新打包生成mybatis-generator-core.jar即可

4. 配置generatorConf.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--数据库驱动-->
    <classPathEntry location="mysql-connector-java-5.1.16-bin.jar"/>
    <context id="DB2Tables" targetRuntime="MyBatis3" defaultModelType="flat">
        <!-- 生成的Java文件的编码 -->
        <property name="javaFileEncoding" value="UTF-8"/>
        <!-- 格式化java代码 -->
        <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
        <!-- 格式化XML代码 -->
        <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
        <!-- 为生成的Java模型类添加序列化接口 -->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <!-- 启用自定义的插件 -->
        <plugin type="org.mybatis.generator.plugins.LombokPlugin"/>
		<!--type配置为自定义的注释生成类路径-->
        <commentGenerator type="org.mybatis.generator.internal.MyCommentGenerator">
            <!-- 去除自动生成的时间戳，避免重复提交SVN -->
            <property name="suppressDate" value="true"/>
            <!--<property name="suppressAllComments" value="false"/>-->
            <property name="addRemarkComments" value="true"/>
            <!-- 设置author，为model类注释中的author -->
            <property name="author" value="xxx"/>
        </commentGenerator>
        <!--数据库链接地址账号密码-->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"
                        userId="root" password="123456">
            <property name="useInformationSchema" value="true" />
        </jdbcConnection>
        <javaTypeResolver>
            <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和
            NUMERIC 类型解析为java.math.BigDecimal -->
            <property name="forceBigDecimals" value="true"/>
        </javaTypeResolver>
        <!--生成Model类存放位置-->
        <javaModelGenerator targetPackage="com.test.model"
                            targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!--生成XML映射文件存放位置-->
        <sqlMapGenerator targetPackage="com.test.mapper"
                         targetProject="src/main/resources">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
            <property name="trimStrings" value="true"/>
        </sqlMapGenerator>
        <!--生成Dao类存放位置-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.test.mapper"
                             targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>
        <!--生成对应表及类名-->
        <table tableName="%" schema="test" domainObjectName="Test"
                enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false">
        <!-- 字段id为主键，并且自动递增 -->
        <generatedKey column="id" sqlStatement="Mysql" identity="true"/>
        <property name="useActualColumnNames" value="true"/>
        <!--<ignoreColumn column="FRED"/>
        <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR"/>-->
        </table>
    </context>

</generatorConfiguration>

5. 运行MyBatisGenerator生成代码

在配置文件及jar包所在目录下打开命令行，运行命令

java -jar mybatis-generator-core-1.4.1-SNAPSHOT.jar -configfile generatorConfig.xml -overwrite

6. 附件

修改后的jar
修改后的源码

参考

  1. mybatis generator插件系列–lombok插件 （减少百分之九十bean代码）
  2. mybatis generator 生成的model带注解
  3. MyBatis Generator 自定义生成注释
赱乂
关注
专栏目录
mybatis-generator+lombok自动生成mybatis代码
11-27
自己找资料，慢慢高了一个mybatis自动生成代码的类，当然是在mybatis-generator基础之上的，由于项目中有lombok，所以需要对生成的地方进行改造。我将改造后的文件都打包上传了，需要的同学拿去吧 zip包里面包含： ...
Java逆向生成：代码生成器
weixin_44160476的博客
09-18 975
持久层【dao】 1、mybatis-generator概述 mybatis-generators是一个可以用来生成一些实体的工具，可以根据数据库逆向生成实体对象，功能强大，可以省去很多重复麻烦的工作。需要注意的是在mybatis-generator的配置文件中要生成的表名与包名保持一致 其一共有两个依赖文件 1：**mybatis-generator-core-1.3.5.jar **：代码生成的 jar文件 2：mybatis-generator.xml： 代码生成的 XML定义文件 2、编写格式
Mybatis generator 生成中文注释/lombok注解（使用数据库字段注释）
吾生也有涯，而知也无涯
02-11 2799
目录快速开始初始化sql使用前使用后pom.xml配置generator的config.xml在idea的插件中使用插件源码 快速开始 初始化sql 数据库的建表sql CREATE TABLE `user` ( `id` bigint(20) DEFAULT NULL COMMENT '自增id', `name` varchar(255) DEFAULT NULL COMMENT '姓名...
mybatis generator 搭配lombok ,逆向生成字段类注释
Nba_3210的博客
07-31 1135
逆向生成字段类注释 自定义插 的实现方式有两种： 1，实现接口 **Plugin** 2, 继承抽象类：**PluginAdapter** （已经实现了接口Plugin ,功能更丰富）-推荐使用 自定义插件说明 我使用的是mybatis-generator-core 是 1.3.7 版本。 <dependencies> <dependency> <groupId
SpringBoot中generator整合lombok和添加注释
我的博客
10-24 1445
一、研究问题 本文分享使用Mybatis的逆向工程generator的时候，将生成的实体改为lombox形式，并且在成员变量上添加数据库中的字段描述（中文的描述哦）。 本次环境是基于SpringBoot和MySQL，阅读前提是你先会使用原生的generator工具，如果你的环境是普通maven或其它环境也可以阅读，换汤不换药的。 这里先看下图效果：一张数据库表，student库下的class，如果...
使用mybatis插件mybatis-generator 自动生成lombok注解,去除get和set方法,自动为实体添加数据库字段的注释
weixin_55586010的博客
03-01 1727
1.pom文件依赖2.generator.xml文件注意：generator.xml文件中的标签是有顺序的 顺序不对会报错的 关于lombok的配置在plugin标签中。
mybatis generator源码修改
07-13
1、实体类可配置 Lombok 注解 2、实体类可配置 swagger注解 3、实体类可配置 JPA注解 4、实体类可配置 文件名统一修改 5、可配置 mapper文件名更改 6、可配置 xml文件名更改 7、mapper类可配置父类泛型：mapper对应...
mybatis-generator整合lombok及swagger格式注解
02-07
最近由于项目需要，研究了一下mybatis-generator，利用mybatis-generator读取数据库表格及字段配置，生成实体类对应注释，同时通过实现lombok及swagger自定义插件来实现自定义格式注释，通过开关控制注释格式。...
实体类带注释、支持lombok的mybatis-generator-core-1.3.7.jar
05-30
mybatis-generator-core-1.3.7.jar 带注释，支持lombok，如 @Data public class Person { /** * 自增ID */ private Long id; }
mybatisGeneratorSupportLombokDB:mybatis代码生成工具，去掉getset方法、增加Lombok注解、字段注释取用表字段描述
04-30
因此下载了mybatis-generator-core-1.3.7-sources源码，并在此基础上，做些调整集成了lombok和swagger。 新增功能 生成支持中文注释的entity 生成支持Lombok的entity 生成支持Swagger的entity 去掉生成带类型参数的...
使用mybatis插件mybatis-generator(lombok）
最新发布
weixin_51296247的博客
03-18 960
***/@Override/*** 为实体添加lombok的注解* @return*/@Override//添加domain的import*///添加domain的注解*///添加domain的注释/*** 为实体类字段添加注释* @return*/@Override@Override//不生成getter@Override//不生成setter。
lombok插件浅析
ldcaws的专栏
09-13 2028
在java开发中，定义实体类之后，需要写很多的get/set/toString/hashCode/equals等方法，麻烦的很，尤其是定义很多的实体类且每个实体类的变量又高达几十个时，写完get/set方法之后，简直要心潮澎湃，鲜血直喷。由于Java的官方版本没有提供这种快速生成方法的注解工具，类似Lombok这样的工具，其实都是使用了从Java 6和JSR 269的Annotation Processing技术中实现方法的注入。为了简化代码，避免重复劳动的工作，下面谈谈lombok插件工具。
Lombok原理分析与功能实现（转）
米斯特程序猿
03-01 1085
本文转自：https://blog.mythsman.com/2017/12/19/1/ 前言 这两天没什么重要的事情做，但是想着还要春招总觉得得学点什么才行，正巧想起来前几次面试的时候面试官总喜欢问一些框架的底层实现，但是我学东西比较倾向于用到啥学啥，因此在这些方面吃了很大的亏。而且其实很多框架也多而杂，代码起来费劲，无非就是几套设计模式套一套，用到的东西其实也就那么些，感觉没啥新意。刚这两...
Java数据类（JavaBean）的注解化解决方案：@Data（Lombok实现）
宋冠巡的博客
05-19 1502
Java数据类（JavaBean）的注解化解决方案。 实现原理，是通过编译器插件，在编译期，为添加了 @Data 注解的数据类，自动生成set、get等方法。
纯手写lombok插件（试玩版）
无与伦比的博客
01-21 1514
实现思路： 1.自定义注解GdzData 2.利用javassist字节码技术创建CtClass容器 3.给ctClass对象添加get,set方法 4.更新之前的class文件 lombok插件可以简化代码，大大提高JavaBean中方法的执行效率。lombok实现原理如下图： 首先是项目的源代码文件，在经过编译处理以后，lombok会使用自己的抽象语法树去进行注解的匹配，如果在项目中的某一个...
手写一个简易的lombok
客官不爱喝酒的博客
10-14 1973
在面向对象编程中，必不可少的需要在代码中定义对象模型，而在基于Java的业务平台开发实践中尤其如此。相信大家在平时开发中也深有感触，本来是没有多少代码开发量的，但是因为定义的业务模型对象比较多，而需要重复写Getter/Setter、构造器方法、字符串输出的ToString方法、Equals/HashCode方法等。我们都知道Lombok能够替大家完成这些繁琐的操作，但是其背后的原理很少有人会关注或者说得清，本文会带着大家了解这一开发神器内部的运行机制与原理！
安装lombok插件_Lombok的介绍及安装
weixin_39759589的博客
01-30 604
简介Lombok是一个java库，它可以自动插入到编辑器和构建工具中，从而简化我们的ava代码。不用再重新编写getter和equals方法。通过在类上添加注释，可以使类带有功能全面的生成器，自动化的日志记录变量等等。总之一句话Lombok是一个通过在类上添加注解来简化我们的java代码，避免编写一些觉得相对比较臃肿的代码的工具包。原理Lombok本质上就是一个实现了“JSR 269 API”的程...
【高效开发插件】10 Lombok 简化代码
Yuu
11-02 159
介绍 Lombok 可以减少很多重复代码的书写。例如：getter/setter/toString 等方法的编写。 Intellij IDEA 安装 Lombok File -&amp;amp;gt; Setting -&amp;amp;gt; Plugins -&amp;amp;gt; Browse repositories... -&amp;amp;gt; 搜索 Lombok -&amp;amp;gt; install -&amp;amp;gt; 安装
lombok插件
普通还不自信的程序员
08-13 82
lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码的工具，简单来说，比如我们新建了一个类，然后在其中写了几个字段，然后通常情况下我们需要手动去建立getter和setter方法啊，构造函数啊之类的，lombok的作用就是为了省去我们手动创建这些代码的麻烦，它能够在我们编译源码的时候自动帮我们生成这些方法。lombok能够达到的效果就是在源码中不需要写一些通用的方法，但是在编译生成的字节码文件中会帮我们生成这些方法，这就是lombok的神奇作用。 @Data
SpringBoot+Mybatis注解方式实现多数据源读写分离教程
"本文将详细介绍如何使用Mybatis注解来实现多数据源的读写分离。在实际项目中，为了提高数据库性能，通常会采用主从数据库的架构，主数据库负责写操作，从数据库负责读操作。我们将通过具体的步骤和示例代码来展示这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值