手把手教你如何使用Mybatis代码生成器——封装单表操作及一键生成实体类、mapper、service、serviceImpl

最新推荐文章于 2024-04-11 14:51:23 发布

马老师发生甚么事了？

最新推荐文章于 2024-04-11 14:51:23 发布

阅读量1.1k

点赞数 2

分类专栏： mybatis使用文章标签：数据库 mybatis java generator spring boot

本文链接：https://blog.csdn.net/darkry/article/details/115628673

版权

mybatis使用专栏收录该内容

1 篇文章 0 订阅

订阅专栏

我们在做Java开发的时候，经常能听说过什么所谓的代码生成器，可以根据需求一键生成我们需要的代码。本教程基于TKmybatis、mybatis-generator和模板生成引擎FreeMarker来一键生成我们需要的代码文件，使用这些文件实现对单表增删改查等等的一系列操作，使我们不用浪费时间在写dao语句上面
抽空研究了一下上家公司所使用的代码，分享一下自己的心得。本教程以MySQL数据库为例。从搭建项目开始，如果项目已经搭好了可直接跳到导入依赖部分。
需要注意的一点是，代码中的June，demo等等字样是我自己建立的包名和我设置的路径，需要去改成自己的。

1、创建springboot项目

点击File-New-Project,在左边选中Spring Initializer，点击下一步
在这里插入图片描述

这边的配置项可以选择性的勾选，这边我没有选，后面直接手动添加依赖也是一样的

设置项目名，点击finish即可

至此，一个springboot的项目就搭建完毕了

2、导入依赖

在pom.xml里的dependencies标签下导入如下依赖：

		<!--Lombok插件-->
		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version>
            <scope>provided</scope>
        </dependency>
			
		<!-- mysql数据库的驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

		<!--mybatis generator-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.7</version>
        </dependency>

		<dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.1.5</version>
        </dependency>

        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
		
		<!--模板引擎-->
		<dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.23</version>
        </dependency>

		<!--swagger相关注解-->
		<dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${io.springfox.swagger2.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${io.springfox.swagger.ui.version}</version>
        </dependency>

		<!--spring web-->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
		
		<!--pagehelper分页容器-->
		<dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.8</version>
        </dependency>

以下依赖可以选择性添加（可加可不加，看自己需求）

		<!--Junit单元测试-->
		<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        
		<!--slf4j日志-->
		<dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>

		<!--joda time时间工具类-->
		<dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>

3、配置数据源

首先在application.properties里添加数据源配置，包含数据库的url、用户名、密码、驱动。其中比较关键的是需要配置mapper识别的位置，以及实体类生成的位置，以及把驼峰自动转换选项设置为true，同时关闭mybatis的二级缓存。示例如下，根据自己的需求进行更改

#数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&amp;characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.jdbc.Driver
#mybatis的相关配置
mybatis.mapperLocations=classpath:mapper/**/*.xml
mybatis.typeAliasesPackage=com.june.demo.common.entity
mybatis.configuration.mapUnderscoreToCamelCase=true
#mybatis二级缓存开关
mybatis.configuration.cache-enabled=false

4、编写mybatis-generator配置文件

这里不得不提一下Tkmybatis，有兴趣的可以搜索了解一下，这是个基于Mybatis框架开发的一个工具，通过调用它提供的方法实现对单表的数据操作，不需要写任何sql语句，这极大地提高了项目开发效率。简单来说就是帮你封装了单表的所有操作。
这里我们再resource文件夹下新建一个mybatis-generator的配置文件：mybatis-generator.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>
    <context id="Mysql" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="javaFileEncoding" value="UTF-8"/>

        <!-- 引入lombok插件，下面会讲 -->
        <plugin type="com.june.demo.plugin.LombokPlugin"/>

        <!--通用 Mapper 插件，可以生成带注解的实体类-->
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="com.june.demo.mapper.Mapper"/>
            <property name="caseSensitive" value="true"/>
            <property name="forceAnnotation" value="true"/>
            <property name="swagger" value="true"/>
            <property name="beginningDelimiter" value="`"/>
            <property name="endingDelimiter" value="`"/>
        </plugin>

        <!--通用mapper xml文件生成器插件-->
        <plugin type="tk.mybatis.mapper.generator.TemplateFilePlugin">
            <property name="targetProject" value="src/main/resources"/>
            <property name="targetPackage" value="mapper/original"/>
            <property name="mapperPackage" value="com.june.demo.mapper"/>
            <property name="templatePath" value="generator/mapper-xml.ftl"/>
            <property name="fileType" value="xml"/>
            <property name="fileName" value="${tableClass.shortClassName}Mapper.${fileType}"/>
        </plugin>

        <!--通用mapper java文件生成器插件-->
        <plugin type="tk.mybatis.mapper.generator.TemplateFilePlugin">
            <property name="targetProject" value="src/main/java"/>
            <property name="targetPackage" value="com.june.demo.mapper"/>
            <property name="modelPackage" value="entity"/>
            <property name="templatePath" value="generator/mapper.ftl"/>
            <property name="fileType" value="java"/>
            <property name="fileName" value="${tableClass.shortClassName}Mapper.${fileType}"/>
        </plugin>

        <!--通用IService java文件生成器插件-->
        <plugin type="tk.mybatis.mapper.generator.TemplateFilePlugin">
            <property name="targetProject" value="src/main/java"/>
            <property name="basePackages" value="com.june.demo"/>
            <property name="targetPackage" value="com.june.demo.service"/>
            <property name="templatePath" value="generator/IService.ftl"/>
            <property name="fileType" value="java"/>
            <property name="fileName" value="I${tableClass.shortClassName}Service.${fileType}"/>
        </plugin>

        <!--通用ServiceImpl java文件生成器插件-->
        <plugin type="tk.mybatis.mapper.generator.TemplateFilePlugin">
            <property name="targetProject" value="src/main/java"/>
            <property name="basePackages" value="com.june.demo"/>
            <property name="targetPackage" value="com.june.demo.service.impl"/>
            <property name="templatePath" value="generator/service-impl.ftl"/>
            <property name="fileType" value="java"/>
            <property name="fileName" value="${tableClass.shortClassName}ServiceImpl.${fileType}"/>
        </plugin>

		<!--设置JDBC的连接-->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/test?autoReconnect=true&amp;characterEncoding=utf-8"
                        userId="root"
                        password="root">
        </jdbcConnection>

        <!--MyBatis 生成器只需要生成 Model-->
        <javaModelGenerator targetPackage="com.june.demo.common.entity" targetProject="src/main/java"/>
        
		<!--设置表名，主键id，这里可以先不写，后面跑代码生成会用到，只需要在这里配置需要生成的表即可-->
        <table tableName="t_alert_dialog">
            <generatedKey column="LOG_ID" identity="true" sqlStatement="MYSQL"/>
        </table>


    </context>
</generatorConfiguration>

关于mybatis-generator里的的标签的具体含义，可以参考文章MyBatis学习笔记（五）：代码生成器.

5、引入自定义Lombok插件

在第四点的mybatis-generator配置中，我们引入了一个自定义Lombok插件，
这个插件主要对生成的文件进行注解生成的定制化，代码如下：

package com.june.demo.plugin;

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.Method;
import org.mybatis.generator.api.dom.java.TopLevelClass;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * lombok插件
 */
public class LombokPlugin extends PluginAdapter {

    @Override
    public boolean validate(List<String> warnings) {
        StringBuffer sb = new StringBuffer();
        sb.append("\r\n【lombok插件支持】\r\n");
        sb.append("【LombokPlugin初始化】\r\n");
        warnings.add(sb.toString());
        return true;
    }

    @Override
    public boolean modelBaseRecordClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {

        //添加entity的import
        topLevelClass.addImportedType("lombok.Data");
        topLevelClass.addImportedType("lombok.Builder");
        topLevelClass.addImportedType("lombok.NoArgsConstructor");
        topLevelClass.addImportedType("lombok.AllArgsConstructor");

        //添加entity实体类的注解
        topLevelClass.addAnnotation("@Data");
        topLevelClass.addAnnotation("@Builder");
        topLevelClass.addAnnotation("@NoArgsConstructor");
        topLevelClass.addAnnotation("@AllArgsConstructor");

        //添加entity的注释
        topLevelClass.addJavaDocLine("/**");
        topLevelClass.addJavaDocLine(" * MyBatis Generator工具自动生成" + date2Str(new Date()));
        topLevelClass.addJavaDocLine(" */");

        return true;
    }

    @Override
    public boolean modelSetterMethodGenerated(Method method, TopLevelClass topLevelClass, IntrospectedColumn introspectedColumn, IntrospectedTable introspectedTable, ModelClassType modelClassType) {
        //不生成getter
        return false;
    }

    @Override
    public boolean modelGetterMethodGenerated(Method method, TopLevelClass topLevelClass, IntrospectedColumn introspectedColumn, IntrospectedTable introspectedTable, ModelClassType modelClassType) {
        //不生成setter
        return false;
    }

    private String date2Str(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        return sdf.format(date);
    }
}

6、编写生成模板类

在resource目录下新建generator文件夹，在该文件夹下编写我们需要生成的service、serviceImpl、mapper类、mapper.xml的模板
IService.ftl：

package ${props['targetPackage']};

import ${tableClass.pkFields[0].fullTypeName};
import ${tableClass.packageName}.${tableClass.shortClassName};
import ${props['basePackages']}.mapper.${tableClass.shortClassName}Mapper;

public interface I${tableClass.shortClassName}Service extends IBaseService
<${tableClass.shortClassName}Mapper, ${tableClass.shortClassName}, ${tableClass.pkFields[0].shortTypeName}> {
}

mapper.ftl：

package ${props['targetPackage']};

import ${tableClass.packageName}.${tableClass.shortClassName};

public interface ${tableClass.shortClassName}Mapper extends Mapper<${tableClass.shortClassName}> {

}

mapper-xml.ftl：

<?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="${props['mapperPackage']}.${tableClass.shortClassName}Mapper">
    <resultMap id="BaseResultMap" type="${tableClass.fullClassName}">
        <#if tableClass.pkFields??>
            <#list tableClass.pkFields as field>
                <id column="${field.columnName}" jdbcType="${field.jdbcType}" property="${field.fieldName}"/>
            </#list>
        </#if>
        <#if tableClass.baseFields??>
            <#list tableClass.baseFields as field>
                <result column="${field.columnName}" jdbcType="${field.jdbcType}" property="${field.fieldName}"/>
            </#list>
        </#if>
    </resultMap>

    <sql id="Base_Column_List">
        <#list tableClass.baseFields as field>
            <#if field_index != tableClass.baseFields?size - 1 >
                ${field.columnName},
            <#else>
                ${field.columnName}
            </#if>
        </#list>
    </sql>

</mapper>

service-impl.ftl：

package ${props['targetPackage']};

import org.springframework.stereotype.Service;
import ${tableClass.pkFields[0].fullTypeName};
import ${tableClass.packageName}.${tableClass.shortClassName};
import ${props['basePackages']}.service.I${tableClass.shortClassName}Service;
import ${props['basePackages']}.mapper.${tableClass.shortClassName}Mapper;


@Service
public class ${tableClass.shortClassName}ServiceImpl extends AbstractServiceImpl
<${tableClass.shortClassName}Mapper, ${tableClass.shortClassName}, ${tableClass.pkFields[0].shortTypeName}> implements I${tableClass.shortClassName}Service {
}

这里的模板类除了mapper.xml，其他的模板类基本继承某一个类，这些父类就包含了基本的单表查询，使用到了泛型。接下来我们需要书写我们需要使用的父类文件，也就是代码中写到的IBaseService、AbstractServiceImpl和Mapper

7、IBaseService、AbstractServiceImpl和Mapper

IBaseService、AbstractServiceImpl和Mapper这三个文件分别放到service包，Impl包以及mapper包下，如图：
在这里插入图片描述

IBaseService：

package com.june.demo.service;

import com.june.demo.mapper.Mapper;

import java.util.List;

public interface IBaseService<M extends Mapper<T>, T, PK> {

    List<T> selectAll();

    T selectByPrimaryKey(PK pk);

    int selectCount(T record);

    List<T> select(T record);

    T selectOne(T record);

    List<T> selectByIds(String ids);

    int updateByPrimaryKey(T record);

    int updateByPrimaryKeySelective(T record);

    int deleteByIds(String ids);

    int insertList(List<? extends T> list);

    int deleteByPrimaryKey(PK pk);

    int delete(T record);

    int insert(T record);

    int insertSelective(T record);

    boolean existsWithPrimaryKey(PK PK);
}

AbstractServiceImpl：

package com.june.demo.service.impl;


import com.google.common.collect.Lists;
import com.june.demo.mapper.Mapper;
import com.june.demo.service.IBaseService;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;


public class AbstractServiceImpl<M extends Mapper<T>, T, PK> implements IBaseService<M, T, PK> {

    @Autowired
    protected M mapper;

    @Override
    public T selectByPrimaryKey(PK pk) {
        return mapper.selectByPrimaryKey(pk);
    }

    @Override
    public int selectCount(T record) {
        return mapper.selectCount(record);
    }

    @Override
    public T selectOne(T record) {
        return mapper.selectOne(record);
    }

    @Override
    public List<T> select(T record) {
        return mapper.select(record);
    }

    @Override
    public List<T> selectAll() {
        return mapper.selectAll();
    }

    @Override
    public List<T> selectByIds(String ids) {
        return mapper.selectByIds(ids);
    }

    @Override
    public boolean existsWithPrimaryKey(PK pk) {
        return mapper.existsWithPrimaryKey(pk);
    }

    @Override
    public int insert(T record) {
        return mapper.insert(record);
    }

    @Override
    public int insertSelective(T record) {
        return mapper.insertSelective(record);
    }

    @Override
    public int insertList(List<? extends T> list) {
        final int partitionSize = 1000;

        if (list.size() <= partitionSize * 1.25) {
            return mapper.insertList(list);
        }

        final List<? extends List<? extends T>> partitions = Lists.partition(list, partitionSize);
        return partitions.stream().mapToInt(mapper::insertList).sum();
    }

    @Override
    public int updateByPrimaryKeySelective(T record) {
        return mapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(T record) {
        return mapper.updateByPrimaryKey(record);
    }

    @Override
    public int deleteByPrimaryKey(PK pk) {
        return mapper.deleteByPrimaryKey(pk);
    }

    @Override
    public int delete(T record) {
        return mapper.delete(record);
    }

    /**
     * 根据主键字符串进行删除，类中只有存在一个带有@Id注解的字段
     *
     * @param ids 如 "1,2,3,4"
     * @return
     */
    @Override
    public int deleteByIds(String ids) {
        return mapper.deleteByIds(ids);
    }
}

Mapper：

package com.june.demo.mapper;

import tk.mybatis.mapper.annotation.RegisterMapper;
import tk.mybatis.mapper.common.BaseMapper;
import tk.mybatis.mapper.common.IdsMapper;
import tk.mybatis.mapper.common.special.InsertListMapper;


@RegisterMapper
public interface Mapper<T> extends BaseMapper<T>, InsertListMapper<T>, IdsMapper<T> {
}

8、编写代码生成器

在test目录下新建一个包codetool(事实上你放哪里都行，这边为了规范一点把代码放在test的目录下。经过配置后在git上传的时候不会上传test包下的代码文件)，具体代码如下，注意这里有些包括包名，路径等等根据自己的项目进行修改。

package com.june.demo.codetool;

import lombok.extern.slf4j.Slf4j;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;
import org.mybatis.generator.internal.NullProgressCallback;

import java.io.File;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

@Slf4j
public class CodeGenerator {

    public static void main(String[] args) throws Exception {
        generator();
    }

    private static final String PACKAGE_BASE = "com.june.demo";//指定包

    private static final String PACKAGE_ENTITY = PACKAGE_BASE + ".entity";//指定实体类的包路径

    private static final String PACKAGE_MAPPER = PACKAGE_BASE + ".mapper";//指定mapper类的包路径

    private static final String PACKAGE_SERVICE = PACKAGE_BASE + ".service";//指定service的包路径

    private static final String PACKAGE_SERVICE_IMPL = PACKAGE_SERVICE + ".impl";//指定serviceImpl的包路径


    private static String PATH_PROJECT = System.getProperty("user.dir") + "/server";//获取程序的当前路径

    private static String PATH_ENTITY = PATH_PROJECT + "/src/main/java" + packageConvertPath(PACKAGE_ENTITY); //entity文件路径

    private static String PATH_MAPPER = PATH_PROJECT + "/src/main/java" + packageConvertPath(PACKAGE_MAPPER); //Mapper文件路径

    private static String PATH_MAPPER_XML = PATH_PROJECT + "/src/main/resources/mapper/original"; //Mapper xml文件路径

    private static String PATH_SERVICE = PATH_PROJECT + "/src/main/java" + packageConvertPath(PACKAGE_SERVICE); //Service文件路径

    private static String PATH_SERVICE_IMPL = PATH_PROJECT + "/src/main/java" + packageConvertPath(PACKAGE_SERVICE_IMPL); //ServiceIMPL文件路径


    private static void generator() throws Exception {
        //执行过程中的警告信息
        List<String> warnings = new ArrayList<>();
        //生成的代码重复时，覆盖原代码
        boolean overwrite = true;
        //配置信息
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(getResourceAsStream("mybatis-generator.xml"));
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);

        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        //执行生成代码
        myBatisGenerator.generate(new NullProgressCallback() {
            @Override
            public void startTask(String taskName) {
                String regex = "Saving file ";
                if (!taskName.contains(regex)) {
                    return;
                }
                String fileName = taskName.replaceAll(regex, "");

                FileType fileType = getFileType(fileName);
                boolean isExists = checkFileExists(fileType, fileName);

                // 当文件存在时 只覆盖entity
                if (isExists && (fileType != FileType.ENTITY && fileType != FileType.MAPPERXML)) {
                    throw new RuntimeException(fileName + "存在不覆盖");
                }
            }

        });
        for (String warning : warnings) {
            //打印日志
            log.debug(warning);
        }
    }

    //检查文件是否存在的方法
    private static boolean checkFileExists(FileType fileType, String fileName) {

        String filePath = "";
        switch (fileType) {
            case ENTITY:
                filePath = PATH_ENTITY;
                break;
            case MAPPER:
                filePath = PATH_MAPPER;
                break;
            case SERVICE:
                filePath = PATH_SERVICE;
                break;
            case MAPPERXML:
                filePath = PATH_MAPPER_XML;
                break;
            case SERVICEIMPL:
                filePath = PATH_SERVICE_IMPL;
                break;
            default:
                return false;
        }

        File file = new File(filePath + fileName);

        return file.exists();
    }

    //检查文件类型
    private static FileType getFileType(String fileName) {
        if (fileName.contains("Mapper.xml")) {
            return FileType.MAPPERXML;
        }
        if (fileName.contains("Mapper.java")) {
            return FileType.MAPPER;
        }
        if (fileName.contains("Service.java")) {
            return FileType.SERVICE;
        }
        if (fileName.contains("ServiceImpl.java")) {
            return FileType.SERVICEIMPL;
        }
        if (fileName.contains(".java")) {
            return FileType.ENTITY;
        }

        return FileType.OTHER;
    }

    //根据路径将文件资源转换为流的形式
    private static InputStream getResourceAsStream(String path) {
        return Thread.currentThread().getContextClassLoader().getResourceAsStream(path);
    }

    //将包转换为路径
    private static String packageConvertPath(String packageName) {
        return String.format("/%s/", packageName.contains(".") ? packageName.replaceAll("\\.", "/") : packageName);
    }

    enum FileType {
        MAPPER, MAPPERXML, ENTITY, SERVICE, SERVICEIMPL, OTHER
    }

}

同样的，在该目录下添加MyBatisGenerator，这里直接下载完丢进去就好了
下载地址：mybatis-generator.class.

9、添加Mybatis配置

最后一步是对我们使用的mybatis进行配置，这里我们需要对mybatis的分页容器PageHelper进行定制化，以及对mybatis扫描的mapper位置进行设定，代码如下：

package com.june.demo.core;

import com.github.pagehelper.PageInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;

import java.util.Properties;


/**
 * @author June
 * @description: TODO
 * @date 2021/5/8 15:53
 */
@Slf4j
@Configuration
public class MybatisConfiguration {
    /**
     * 5.0.0以上的版本  PageInterceptor
     *
     * @return
     */
    @Bean
    public PageInterceptor pageHelper() {
        PageInterceptor pageHelper = new PageInterceptor();
        Properties properties = new Properties();
        /**默认false，设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用*/
        properties.setProperty("offsetAsPageNum", "true");
        /**默认false，设置为true时，使用RowBounds分页会进行count查询 */
        properties.setProperty("rowBoundsWithCount", "true");
        /** 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 */
        properties.setProperty("reasonable", "fase");
        /** always总是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page */
        properties.setProperty("returnPageInfo", "check");
        /** 支持通过Mapper接口参数来传递分页参数 */
        properties.setProperty("supportMethodsArguments", "false");
        /**  配置数据库的方言  */
        properties.setProperty("helperDialect", "mysql");
        pageHelper.setProperties(properties);
        return pageHelper;
    }


    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setBasePackage("com.june.demo.mapper");

        // 配置通用Mapper，详情请查阅官方文档
        Properties properties = new Properties();
        properties.setProperty("mappers", "com.june.demo.mapper.Mapper");
        properties.setProperty("notEmpty", "false");//insert、update是否判断字符串类型!='' 即 test="str != null"表达式内是否追加 and str != ''
        properties.setProperty("IDENTITY", "MYSQL");
        mapperScannerConfigurer.setProperties(properties);
        return mapperScannerConfigurer;
    }

}

至此我们需要的环境配置已经搭建完毕，接下来就是生成器的使用流程了

10、代码生成器的使用

首先我们打开mybatis-generator.xml，记得我们上面提到的table标签吗？只需要写入我们需要进行生成的表名，主键，再运行代码生成器就可以了。下面是table标签的示例代码，tableName表示表名，column处填写主键名，identity设置为true就可以了，而sqlStatement则是所使用的数据库。

		<table tableName="t_xxx">
            <generatedKey column="xxx_ID" identity="true" sqlStatement="MYSQL"/>
        </table>

写完后右键CodeGenerator——Run，这时候我们需要的mapper.xml，mapper.class，service，serviceImpl，entity都会自动生成了。这时候我们写一个controller，使用@resource引入service，就可以调用单表的所有方法了，如图：
在这里插入图片描述

马老师发生甚么事了？

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
手把手教你如何使用Mybatis代码生成器——封装单表操作及一键生成实体类、mapper、service、serviceImpl

使用软件：Idea Navicat本教程以MySQL数据库为例。从搭建项目开始，如果项目已经搭好了可直接跳到导入依赖。目录1、创建springboot项目2、导入依赖3、编写mybatis配置文件4、编写生成模板类1、创建springboot项目点击File-New-Project,在左边选中Spring Initializer，点击下一步这边的配置项可以选择性的勾选，这边我没有选，后面直接手动添加依赖也是一样的设置项目名，点击finish即可至此，一个springboot的项目就搭
复制链接

扫一扫