通用Mapper

一.引用

1.1.作用

替我们生成常用增删改查操作的 SQL 语句。

1.2. 代码官方发布地址

https://gitee.com/free
https://gitee.com/free/Mapper/wikis/1.1-java?parent=1.integration

1.3. 前置知识

MyBatis
Spring

二.快速入门

2.1.创建测试数据

2.1.1. SQL语句

CREATE TABLE `table_emp` (
`emp_id` INT NOT NULL AUTO_INCREMENT ,
`emp_name` VARCHAR(500) NULL ,
`emp_salary` DOUBLE(15,5) NULL ,
`emp_age` INT NULL ,
PRIMARY KEY (`emp_id`)
);
INSERT INTO `table_emp` (`emp_name`, `emp_salary`, `emp_age`) VALUES ('tom', '1254.37', '27');
INSERT INTO `table_emp` (`emp_name`, `emp_salary`, `emp_age`) VALUES ('jerry', '6635.42', '38');
INSERT INTO `table_emp` (`emp_name`, `emp_salary`, `emp_age`) VALUES ('bob', '5560.11', '40');
INSERT INTO `table_emp` (`emp_name`, `emp_salary`, `emp_age`) VALUES ('kate', '2209.11', '22');
INSERT INTO `table_emp` (`emp_name`, `emp_salary`, `emp_age`) VALUES ('justin', '4203.15', '3');

2.1.2.创建Maven工程

在这里插入图片描述

2.1.3.Java 实体类

考虑到基本数据类型在 Java 类中都有默认值,会导致 MyBatis 在执行相关操作
时很难判断当前字段是否为 null,所以在 MyBatis 环境下使用 Java 实体类时尽量不
要使用基本数据类型,都使用对应的包装类型。

package com.tedu.java.pojo;

/**
 * @author: zyy
 * @date: 2022/4/9 10:57
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
public class Employee {
    private Integer empId;
    private String empName;
    private Double empSalary;
    private Integer empAge;

    public Employee() {
    }

    public Employee(Integer empId, String empName, Double empSalary, Integer empAge) {
        this.empId = empId;
        this.empName = empName;
        this.empSalary = empSalary;
        this.empAge = empAge;
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public Double getEmpSalary() {
        return empSalary;
    }

    public void setEmpSalary(Double empSalary) {
        this.empSalary = empSalary;
    }

    public Integer getEmpAge() {
        return empAge;
    }

    public void setEmpAge(Integer empAge) {
        this.empAge = empAge;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "empId=" + empId +
                ", empName='" + empName + '\'' +
                ", empSalary=" + empSalary +
                ", empAge=" + empAge +
                '}';
    }
}

2.2. 搭建 MyBatis+Spring 开发环境

2.2.1. 导入所需要的依赖包

<?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>com.tedu.java</groupId>
    <artifactId>Mapper01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--引入项目依赖的jar包 -->
    <!-- SpringMVC、Spring -->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependencies>

        <!--引入pageHelper分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.0.0</version>
        </dependency>

        <!-- MBG -->
        <!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

        <!-- 返回json字符串的支持 -->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.8</version>
        </dependency>

        <!--JSR303数据校验支持;tomcat7及以上的服务器,
        tomcat7以下的服务器:el表达式。额外给服务器的lib包中替换新的标准的el
        -->
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.1.Final</version>
        </dependency>


        <!-- Spring-Jdbc -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <!--Spring-test -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <!-- Spring面向切面编程 -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <!--MyBatis -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>
        <!-- MyBatis整合Spring的适配包 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- 数据库连接池、驱动 -->
        <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <!-- (jstl,servlet-api,junit) -->
        <!-- https://mvnrepository.com/artifact/jstl/jstl -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- junit -->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/tk.mybatis/mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.2.1</version>
        </dependency>
        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>

                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.2.2. spring配置文件

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    <!--配置数据源-->
    <context:property-placeholder location="classpath:dbconfig.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--整合Mybatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    </bean>
    <!-- 原始全类名:org.mybatis.spring.mapper.MapperScannerConfigurer -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.tedu.java.mappers"></property>
    </bean>
    <!--配置Service自动扫描的包-->
    <context:component-scan base-package="com.tedu.java.service"></context:component-scan>
    <!--配置声明式事务-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* *..*Service.*(..))"></aop:advisor>
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="save*" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"></tx:method>
            <tx:method name="remove*" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
            <tx:method name="update*" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        </tx:attributes>
    </tx:advice>
</beans>

2.2.3.数据库配置文件

dbconfig.properties

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm_crud?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=UTC
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.user=root
jdbc.password=123456

2.2.4.log4j配置文件

log4j.rootLogger=DEBUG,myConsole
log4j.appender.myConsole=org.apache.log4j.ConsoleAppender
log4j.appender.myConsole.ImmediateFlush=true
log4j.appender.myConsole.Target=System.out
log4j.appender.myConsole.layout=org.apache.log4j.PatternLayout
log4j.appender.myConsole.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

log4j.logger.com.mchange.v2=ERROR

2.2.5. mybatis配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

2.3.测试

编写测试类:

package com.tedu.java;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * @author: zyy
 * @date: 2022/4/9 11:12
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
public class test {
   private ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    /**
     * 获取数据库连接
     * @throws SQLException
     */
    @Test
    public void testDataSource() throws SQLException {
        DataSource dataSource = context.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

}

在这里插入图片描述

2.4.集成 Mapper

2.4.1. 加入 Maven 依赖信息

<!-- https://mvnrepository.com/artifact/tk.mybatis/mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.2.1</version>
        </dependency>

2.4.2. 修改spring配置文件

 <!-- 整合通用Mapper所需要做的配置修改: -->
    <!-- 原始全类名:org.mybatis.spring.mapper.MapperScannerConfigurer -->
    <!-- 通用Mapper使用:tk.mybatis.spring.mapper.MapperScannerConfigurer -->
    <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.tedu.java.mappers"></property>
    </bean>

2.4.3. 添加EmployeeMapper接口

package com.tedu.java.mappers;

import com.tedu.java.pojo.Employee;
import tk.mybatis.mapper.common.Mapper;

/**
 * 具体操作数据库的Mapper接口,需要继承调用Mapper提供的核心接口Mapper
 * Mapper<Employee>
 *     泛型为需要操作的实体类
 */
public interface EmployeeMapper extends Mapper<Employee> {

}

三. 常用注解

3.1. @Table 注解

作用:建立实体类和数据库表之间的对应关系。
默认规则:实体类类名首字母小写作为表名。Employee 类→employee 表。
用法:在@Table 注解的 name 属性中指定目标数据库表的表名。

3.2. @Column 注解

作用:建立实体类字段和数据库表字段之间的对应关系。
默认规则:
实体类字段:驼峰式命名
数据库表字段:使用“_”区分各个单词
用法:在@Column 注解的 name 属性中指定目标字段的字段名。

3.3.@Id 注解

通用 Mapper 在执行 xxxByPrimaryKey(key)方法时,有两种情况。
情况 1:没有使用@Id 注解明确指定主键字段

SELECT emp_id,emp_name,emp_salary_apple,emp_age FROM tabple_emp WHERE emp_id = ?
AND emp_name = ? AND emp_salary_apple = ? AND emp_age = ?

之所以会生成上面这样的 WHERE 子句是因为通用 Mapper 将实体类中的所有
字段都拿来放在一起作为联合主键。
情况 2:使用@Id 主键明确标记和数据库表中主键字段对应的实体类字段。

3.4. @GeneratedValue 注解

作用:让通用 Mapper 在执行 insert 操作之后将数据库自动生成的主键值回写到实
体类对象中。
自增主键用法:
在这里插入图片描述
序列主键用法:
在这里插入图片描述应用场景:购物车结账
 增加商品销量…
 减少商品库存…
 生成订单数据→封装到 Order 对象中→保存 Order 对象→数据库自动生成主键
值→回写到实体类对象 Order 中
 生 成 一 系 列 订 单 详 情 数 据 → List → 在 每 一 个 OrderItem 中 设 置
Order 对象的主键值作为外键→批量保存 List

3.5.@Transient 主键

用于标记不与数据库表字段对应的实体类字段。

四. 常用方法

4.1.创建serviceImpl

package com.tedu.java.service;

import com.tedu.java.mappers.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author: zyy
 * @date: 2022/4/9 11:40
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
@Service
public class EmployeeServiceImpl {
    @Autowired
    private EmployeeMapper employeeMapper;
    
}

4.2.测试方法

package com.tedu.java;

import com.tedu.java.pojo.Employee;
import com.tedu.java.service.EmployeeServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: zyy
 * @date: 2022/4/9 11:39
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
public class EmployeeMapperTest {
    private ApplicationContext context =  new ClassPathXmlApplicationContext("applicationContext.xml");
    private EmployeeServiceImpl employeeService = context.getBean(EmployeeServiceImpl.class);
    }

4.3.selectOne 方法

/**
     * selectOne方法:
     * 通用Mapper替我们自动生成的SQL语句。
     * 实体类封装查询条件生成where子句规则
     *  1.使用非空的值生成where子句
     *  2.在条件表达式中使用"="进行比较。
     *  3.要求必须返回一个实体类结果,如果有多个则会抛出异常。
     */
    @Test
    public void testSelectOne(){
        //1.创建一个封装查询实体类的对象
        Employee employeeQueryCondition = new Employee(null,"bob",5560.11,null);
        //2.执行查询
        Employee employee = employeeService.getOne(employeeQueryCondition);
        System.out.println(employee);
    }
public Employee getOne(Employee employeeQueryCondition) {
        return employeeMapper.selectOne(employeeQueryCondition);
    }

注意:
在这里插入图片描述出现次错误,需要在实体类Employee上添加@Table注解
在这里插入图片描述实体类封装查询条件生成 WHERE 子句的规则:

  1. 使用非空的值生成 WHERE 子句
  2. 在条件表达式中使用“=”进行比较

在这里插入图片描述注意:要求必须返回一个实体类结果,如果有多个,则会抛出异常
在这里插入图片描述

4.3.xxxByPrimaryKey 方法

需要使用@Id 主键明确标记和数据库表主键字段对应的实体类字段,否则通用
Mapper 会将所有实体类字段作为联合主键。

 /**
     * @Id
     * 通用mapper在执行xxxselectByPrimaryKey(key)方法时,有两种情况
     * 情况1:
     * 没有使用@Id注解明确指定主键字段
     *      通用mapper会将实体类中所有的字段都拿来放在一起作为联合主键。
     * 情况2.
     * 使用@Id主键明确标记和数据库中主键字段作为主键。
     *
     *
     * 如果没有@Id注解的话,通用mapper会将实体类中所有的字段都拿来放在一起作为联合主键。
     */
    @Test
    public void testSelectByPrimaryKey(){
        //提供id值
        Integer empId=3;
        //执行按主键进行查询
        Employee employee =employeeService.getEmplyooById(empId);
        //输出打印结果
        System.out.println(employee);
    }
public Employee getEmplyooById(Integer empId) {
        return employeeMapper.selectByPrimaryKey(empId);
    }

在这里插入图片描述在这里插入图片描述

4.4.existsWithPrimaryKey方法

 /**
     * 判断是否存在该主键
     */
    @Test
    public void testExistsWithPrimaryKey(){
        //提供主键
        Integer empId=3;
        //执行查询
        boolean flag = employeeService.isExists(empId);
        System.out.println(flag);
    }
public boolean isExists(Integer empId) {
        return employeeMapper.existsWithPrimaryKey(empId);
    }

在这里插入图片描述

4.5.Insert方法

@Test
    public void testInsert(){
        //1.创建一个实体类对象封装要保存到数据库中的数据
        Employee employee = new Employee(null, "emp02", 2000.00, 25);
        employeeService.saveEmployee(employee);
    }
public void saveEmployee(Employee employee) {
        employeeMapper.insert(employee);
    }

在这里插入图片描述在这里插入图片描述

4.6.InsertSelective方法

/**
     * InsertSelective非主键字段如果为null,则不加入到SQL中。
     */
    @Test
    public void testInsertSelective(){
        //1.创建一个实体类对象封装要保存到数据库中的数据
        Employee employee = new Employee(null, "emp02", 4000.00, null);
        employeeService.saveEmployeeSelective(employee);
    }
public void saveEmployeeSelective(Employee employee) {
        employeeMapper.insertSelective(employee);
    }

在这里插入图片描述

五. QBC 查询

5.1.概念

Query By Criteria
Criteria 是 Criterion 的复数形式。意思是:规则、标准、准则。在 SQL 语句中相当
于查询条件。
QBC 查询是将查询条件通过 Java 对象进行模块化封装。

5.2.实例代码

 @Test
    public void testSelectByExample(){
        //1.目标:WHERE(EMP_salary>? AND emp_age<?) or (EMP_salary<? AND emp_age>?)
        //创建Example对象
        Example example = new Example(Employee.class);
        //设置排序信息
        example.orderBy("empSalary").asc().orderBy("empAge").desc();
        //设置去重
        example.setDistinct(true);
        //设置select字段
        example.selectProperties("empName","empSalary");
        //通过Example对象创建Criteria对象
        Example.Criteria criteria01 = example.createCriteria();
        Example.Criteria criteria02 = example.createCriteria();
        //在两个Criteria对象中分别设置查询条件
        //property参数:实体类的属性名
        //value参数:实体类的属性值
        criteria01.andGreaterThan("empSalary",3000).andLessThan("empAge",25);
        criteria02.andLessThan("empSalary",5000).andGreaterThan("empAge",30);
        //使用OR关键字来组装两个Criteria对象
        example.or(criteria02);
        //执行查询
        List<Employee> employees = employeeService.getEmpListByExample(example);
        for(Employee employee:employees){
            System.out.println(employee);
        }
    }

六. 逆向工程

6.1原生 MyBatis 逆向工程和通用 Mapper 逆向工程对比

在这里插入图片描述

6.2. 参考文档地址

https://github.com/abel533/Mapper/wiki/4.1.mappergenerator

6.3.逆向工程创建(Maven方式)

使用Maven插件的一个好处是可以将Maven中的属性使用${property}形式在generatorConfig.xml中引用。

6.3.1.在 Maven的 pom.xml 中properties声明

<properties>
        <!--
            ${basedir}:引用工程的根目录
            targetJavaProject:声明存放源码的目录位置
            targetMapperPackage:声明MBG生成xxxMapper接口后存放的package位置
            targetModelPackage:声明MBG生成实体类后存放的package位置
            targetResourcesProject:声明存放资源文件和XML配置文件的目录位置
            targetXMLPackage:声明存放具体XxxMapper.xml 文件的目录位置
        -->
        <!--  MyBatis Generator  -->
        <!--  Java接口和实体类  -->
        <targetJavaProject>${basedir}/src/main/java</targetJavaProject>
        <targetMapperPackage>com.tedu.java.mappers</targetMapperPackage>
        <targetModelPackage>com.tedu.java.com.tedu.java.pojo</targetModelPackage>
        <!--  XML生成路径  -->
        <targetResourcesProject>${basedir}/src/main/resources</targetResourcesProject>
        <targetXMLPackage>mappers</targetXMLPackage>
        <!--  依赖版本  -->
        <!--
            mapper.version:通用mapper版本
        -->
        <mapper.version>4.0.0-beta3</mapper.version>
        <mysql.version>8.0.26</mysql.version>
    </properties>

上面是pom.xml中properties配置的部分内容。这里配置了MBG配置文件中常用到的几个路径以及包名。还包含了通用Mapper的版本和数据库JDBC驱动的版本。

6.3.2.在 pom 文件中添加 plugin 配置(MBG的Maven插件配置)

<build>
        <plugins>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <!--
                    配置generatorConfig.xml配置文件的路径
                -->
                <configuration>
                    <configurationFile>${basedir}/src/main/resources/generator/generatorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                </configuration>
                <!--
                    MBG插件的依赖信息
                -->
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>${mysql.version}</version>
                    </dependency>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>${mapper.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

这里配置了MBG插件,并且配置了generatorConfig.xml配置文件的路径。另外还有两个依赖,分别是JDBC驱动以及通用Mapper(提供了MBG插件)。

6.3.3.所需依赖

 <dependencies>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.0.0-beta3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>
        <!-- MyBatis整合Spring的适配包 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>

6.3.4. 逆向工程 generatorConfiguration.xml 配置

在项目resource目录下创建generator包,存放generatorConfiguration.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>
    <!--
        引入外部属性文件
    -->
    <properties resource="config.properties"/>

    <context id="Mysql" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>

        <!--
            配置通用Mapper的MBG插件相关信息
        -->
        <plugin type="${mapper.plugin}">
            <property name="mappers" value="${mapper.Mapper}"/>
        </plugin>

        <jdbcConnection driverClass="${jdbc.driverClass}"
                        connectionURL="${jdbc.url}"
                        userId="${jdbc.user}"
                        password="${jdbc.password}">
        </jdbcConnection>

        <!--
            配置Java实体类存放位置
        -->
        <javaModelGenerator targetPackage="${targetModelPackage}"
                            targetProject="${targetJavaProject}"/>

        <!--
            配置XML映射文件XxxMapper.xml的存放位置
        -->
        <sqlMapGenerator targetPackage="${targetXMLPackage}" targetProject="${targetResourcesProject}"/>

        <!--
            配置mapper接口XxxMapper.java存放位置
        -->
        <javaClientGenerator targetPackage="${targetMapperPackage}"
                             targetProject="${targetJavaProject}"
                             type="XMLMAPPER"/>

        <!--
            根据数据库表生成Java文件的相关规则
            tableName="%" 表示数据库中所有的表都参与逆向工程,此时使用默认规则
            默认规则:table_depte  类名:TableDept

            不符合默认规则时需要使用tableName和 domainObjectName两个属性明确指定

            generatedKey:配置主键生成策略
        -->
        <table tableName="table_emp" domainObjectName="Employee">
            <generatedKey column="emp_id" sqlStatement="Mysql" identity="true"/>
        </table>
    </context>
</generatorConfiguration>

可以看到这个配置文件中的大多数属性都使用${}形式替代了。使用引入了config.properties属性配置,该文件内容如下:

# 数据库配置
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_crud?serverTimezone=Asia/Shanghai
jdbc.user=root
jdbc.password=123456

#c3p0
jdbc.maxPoolSize=50
jdbc.minPoolSize=10
jdbc.maxStatements=100
jdbc.testConnection=true

# 通用Mapper配置
mapper.plugin=tk.mybatis.mapper.generator.MapperPlugin
mapper.Mapper=tk.mybatis.mapper.common.Mapper

使用配置文件的目的是因为系统多处地方使用了这种配置,因而使用一个属性文件可以方便的保持一致。
除了引用配置文件中的属性外,部分还使用了pom.xml中的属性。这种方式使用起来更灵活。

6.3.5. 运行通用Mapper

在pom.xml这一级目录的命令行窗口执行mvn mybatis-generator:generate即可(前提是配置了mvn)。
在这里插入图片描述
在这里插入图片描述

6.4.生成的资源

在这里插入图片描述EmployeeMapper 接口:
在这里插入图片描述接口自动继承配置的通用Mapper接口,自动包含泛型实体。

6.5.逆向工程测试

添加myatis配置文件和log4.xmlj以及数据库配置文件
mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <properties resource="dbconfig.properties"></properties>
    <!--2.settings包含很多重要的设置项
	setting:用来设置每一个设置项
			name:设置项名
			value:设置项取值-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--3.typeAliases,可以为我们的java类型起别名
	typeAlias:为摸个java类起别名
	type:指定要起别名的类型全类型;默认类型就是类的小写 employee
	alias:指定新的别名
	别名不区分大小写
	-->
    <typeAliases>
        <!--<typeAlias type="com.tedu.com.tedu.com.tedu.java.pojo.Employee"></typeAlias>-->
        <!--批量起别名
		package:为某个包下的所有类批量起别名
		name:指定包名(为当前包以及下面所有的后带包的每一个类都起一个默认的别名)
		使用@Alias注解为某个类型指定新的别名
		-->
        <package name="com.tedu.com.tedu.com.tedu.java.pojo"/>
    </typeAliases>
    <!--4.environments:环境设置,mybatis可以配置多种环境 default指定某个环节
	environment:配置一个具体的环境信息,必须有两个标签,id代表环境的唯一标识
	transactionManager:事务管理器
		type:事务管理器的类型  JDBC|MANAGED
		  自定义事务管理器:实现TransactionFactory接口
	dataSource:数据源;UNPOOLED|POOLED|JNDI
		  自定义数据源实现DataSourceFactory接口

	-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="${jdbc.jdbcUrl}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--databaseIdProvider:支持多数据厂商的;
	type=DB_VENDOR VendorDatabaseIdProvider
	作用就是得到数据库厂商的标识,mybatis就能根据数据库厂商标识(驱动getDatabaseProductName())来执行不同的sql;
	-->
    <databaseIdProvider type="DB_VENDOR">
        <!--为不同的数据库厂商起别名-->
        <property name="Mysql" value="mysql"/>
    </databaseIdProvider>
    <!-- 将我们写好的sql映射文件(EmployeeMapper.xml)一定要注册到全局配置文件(mybatis-config.xml)中 -->
    <!--mappers:将sql映射注册到全局配置中-->
    <mappers>
        <package name="com.tedu.java.mappers"/>
    </mappers>
</configuration>

log4j.properties:

log4j.rootLogger=DEBUG,myConsole
log4j.appender.myConsole=org.apache.log4j.ConsoleAppender
log4j.appender.myConsole.ImmediateFlush=true
log4j.appender.myConsole.Target=System.out
log4j.appender.myConsole.layout=org.apache.log4j.PatternLayout
log4j.appender.myConsole.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

log4j.logger.com.mchange.v2=ERROR

dbconfig.properties:

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm_crud?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=UTC
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.user=root
jdbc.password=123456

测试类

package com.tedu.java;

import com.tedu.java.com.tedu.java.pojo.Employee;
import com.tedu.java.mappers.EmployeeMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import tk.mybatis.mapper.mapperhelper.MapperHelper;

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

/**
 * @author: zyy
 * @date: 2022/4/9 12:55
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
public class Mappertest {
    @Test
    public void test() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sessionFactory.openSession();

        //**********************
        //按照Java方式整合通用Mapper的特殊设置
        //1.创建MapperHelper 对象
        MapperHelper mapperHelper = new MapperHelper();
        //2.通过MapperHelper 对象对MyBatis原生的Configuration对象进行处理
        mapperHelper.processConfiguration(sqlSession.getConfiguration());

        //**********************

        EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
        List<Employee> employees = mapper.selectAll();
        employees.forEach(System.out::println);
        sqlSession.close();
    }
}

运行结果:
在这里插入图片描述

七.自定义 Mapper接口

在这里插入图片描述

7.1.让我们可以根据开发的实际需要对 Mapper接口进行定制。

7.2.创建自定义 Mapper接口

public interface MyMapper<T>extends SelectAllMapper<T>, SelectByExampleMapper<T>,MyBatchUpdateMapper<T> {
}

public interface EmployeeMapper extends MyMapper<Employee> {
}

7.3.配置 MapperScannerConfigurer 注册 MyMapper

<bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.tedu.java.mappers"></property>
        <property name="properties">
            <value>
                mappers = com.tedu.java.minMappers.MyMapper
            </value>
        </property>
    </bean>

八.通用 Mapper 接口扩展

8.1.说明

这里的扩展是指增加通用 Mapper 没有提供的功能。

8.2.举例

我们来仿照写一个批量 update。假设我们想生成下面这样的 SQL 语句:

UPDATE tabple_emp SET emp_name=?,emp_age=?,emp_salary=? where emp_id=? ;
UPDATE tabple_emp SET emp_name=?,emp_age=?,emp_salary=? where emp_id=? ;
UPDATE tabple_emp SET emp_name=?,emp_age=?,emp_salary=? where emp_id=? 

为了生成上面那样的 SQL 语句,我们需要使用到 MyBatis 的 foreach 标签。

<foreach collection="list" item="record" separator=";" >
UPDATE tabple_emp
SET emp_name=#{record.empName},
emp_age=#{record.empAge},
emp_salary=#{record.empSalary}
where emp_id=#{record.empId}
</foreach>

8.3.我们需要提供的接口和实现类

在这里插入图片描述1. 注册接口
MyMapper接口

public interface MyMapper<T>extends SelectAllMapper<T>, SelectByExampleMapper<T>,MyBatchUpdateMapper<T> {
}

继承的MyBatchUpdateMapper接口

public interface MyBatchUpdateMapper<T> {
    @UpdateProvider(type = MyBatchUpdateProvider.class,method = "dynamicSQL")
    void batchUpdate(List<T>list);
}

具体的实现类:MyBatchUpdateProvider

package com.tedu.java.minMappers;

import org.apache.ibatis.mapping.MappedStatement;
import tk.mybatis.mapper.entity.EntityColumn;
import tk.mybatis.mapper.mapperhelper.EntityHelper;
import tk.mybatis.mapper.mapperhelper.MapperHelper;
import tk.mybatis.mapper.mapperhelper.MapperTemplate;
import tk.mybatis.mapper.mapperhelper.SqlHelper;

import java.util.Set;

/**
 * @author: zyy
 * @date: 2022/4/5 13:53
 * @description: TODO
 * @version: 1.0
 * @描述:
 **/
public class MyBatchUpdateProvider extends MapperTemplate {
    public MyBatchUpdateProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }

    public String batchUpdate(MappedStatement mappedStatement) {
        //创建一个StringBuilder对象用于拼接SQL语句
        StringBuilder builder = new StringBuilder();
        //拼接foreach
        builder.append("<foreach collection=\"list\" item=\"record\" separator=\";\">");
        //获取实体类对应的class对象
        Class<?> entityClass = super.getEntityClass(mappedStatement);
        //获取表名
        String tableName = super.tableName(entityClass);
        String updateClause = SqlHelper.updateTable(entityClass,tableName);
        builder.append(updateClause);
        builder.append("<set>");
        //获取所有的字段信息
        Set<EntityColumn> columns = EntityHelper.getColumns(entityClass);
        String idColumn = null;
        String idHolder = null;
        for(EntityColumn entityColumn:columns){
            //判断当前列是否是主键
            if(entityColumn.isId()){
                //缓存主键的字段名和字段值
                idColumn = entityColumn.getColumn();
                idHolder = entityColumn.getColumnHolder("record");

            }else{
                //使用非主键字段拼接set语句
                String column = entityColumn.getColumn();
                String record = entityColumn.getColumnHolder("record");
                builder.append(column).append("=").append(record).append(",");
            }

        }
        builder.append("</set>");
        //使用前面缓存的主键值和主键名拼接where字句
        builder.append("WHERE ").append(idColumn).append("=").append(idHolder);
        builder.append("</foreach>");
        return builder.toString();
    }
}

九.二级缓存

9.1.myBatis 配置文件开启二级缓存功能

<settings>
<setting name="cacheEnabled" value="true"/>
</settings>

9.2.在 XxxMapper 接口上使用@CacheNamespace 注解

@CacheNamespace
public interface EmployeeMapper extends MyMapper<Employee> {
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot可以很方便地整合通用Mapper,只需要在pom.xml中添加通用Mapper的依赖,然后在配置文件中配置数据源和通用Mapper的相关属性即可。 具体步骤如下: 1. 在pom.xml中添加通用Mapper的依赖: ```xml <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.1.5</version> </dependency> ``` 2. 在配置文件中配置数据源和通用Mapper的相关属性: ```yaml spring: datasource: url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false username: root password: root driver-class-name: com.mysql.jdbc.Driver mybatis: mapper-locations: classpath:mapper/*.xml configuration: map-underscore-to-camel-case: true mapper: mappers: - tk.mybatis.mapper.common.Mapper not-empty: false identity: MYSQL ``` 其中,mapper.mappers指定了要使用的Mapper接口,这里使用了通用MapperMapper接口;mapper.identity指定了主键生成策略,这里使用了MySQL的自增长主键。 3. 在Mapper接口中继承通用MapperMapper接口即可使用通用Mapper提供的方法: ```java public interface UserMapper extends Mapper<User> { } ``` 这样就可以使用通用Mapper提供的方法来进行数据库操作了,例如: ```java @Autowired private UserMapper userMapper; public void addUser(User user) { userMapper.insert(user); } public void updateUser(User user) { userMapper.updateByPrimaryKeySelective(user); } public void deleteUser(Long id) { userMapper.deleteByPrimaryKey(id); } public User getUser(Long id) { return userMapper.selectByPrimaryKey(id); } public List<User> getUsers() { return userMapper.selectAll(); } ``` 以上就是Spring Boot整合通用Mapper的基本步骤,希望能对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值