JAVA - mybatis的TK_Mapper(通用mapper)祥例使用

最新推荐文章于 2024-05-24 16:45:47 发布

孟浩浩

最新推荐文章于 2024-05-24 16:45:47 发布

阅读量2.1k

点赞数 3

分类专栏： jdbc 文章标签： mybatis mysql java spring

本文链接：https://blog.csdn.net/JAVA_MHH/article/details/117411550

版权

jdbc 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.项目工程搭建：

1.1 引入pom依赖

引入SpringBoot和SpringCloud版本时特别注意下他们的兼容
参考: https://spring.io/projects/spring-cloud

<!--引入springboot父工程依赖-->
    <!--引入依赖作用：
    可以省去version标签来获得一些合理的默认配置
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>

    <!--因为用eureka,是springCloud的，所以引入springCloud版本锁定-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!--spring cloud 版本 springBoott和springCloud版本要对应起来-->
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
    </properties>
    <!--引入Spring Cloud 依赖-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!--引入eureka-client jar包 这是eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!--因为要启动此项目，所以需要启动类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--用@Data 减少JavaBean get...set...方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--通用mapper起步依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.4</version>
        </dependency>
        <!--MySQL数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

1.2 application.yml 配置

主要配置 mysql地址和eureka注册地址
eureka配置可参考: EurekaService服务端创建 EurekaClient客户端创建

server:
  #客户端端口号
  port: 8080

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mhh_test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
  application:
    #客户端注册名字 ,在注册中心Application的名字
    name: client-general-mapper

eureka:
  client:
    #因为是客户端，所以需要自我注册，注册到eureka-server中 默认：true
    register-with-eureka: true
    #从客户端拉取服务，后面你不止用自己一个服务，可能会通过feign接口调用server中别的服务，所以需要拉取服务 默认：true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka #注册中心地址，如果集群，有几个写几个，逗号分隔
  instance:
    # 更倾向使用ip地址，而不是host名
    prefer-ip-address: true
    #注册中心中测项目Status的名字
    instance-id: ${eureka.instance.ip-address}
    # ip地址 这是客户端的注册地址， eureka 会通过这个地址建立管道
    ip-address: 127.0.0.1  #默认0.0.0.0.0.0.1
    # 表示eureka client发送心跳给server端的频率,续约间隔，默认30秒(只要服务端没有接收到，并不会直接剔除，会先把Status变为Down状态)
    lease-renewal-interval-in-seconds: 5
    # 表示eureka server至上一次收到client的心跳之后，等待下一次心跳的超时时间，在这个时间内若没收到下一次心跳，则将移除该instance
    lease-expiration-duration-in-seconds: 15

1.3 JavaBean对象

此javaBean对象对应的是MySql中的表用@Table注解指定表名

import lombok.Data;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;

@Data //get set 方法
@Table(name = "student") //表名(用于配置表与实体类的映射关系)
public class Student {

    @Id  //用于标识主键属性 (很重要 Mapper里他有好多方法用的就是这个id）：根据主键字段进行删除/查询等
    @NotNull(message = "id不能为空")     //限制不能为null;
    private String id;

    private String name;

    private Integer age;

    private String address;

    private String teacher;

    @Transient //此类要和数据库字段相对等 如果有额外的字段，必须加上@Transient注解。
    private Integer subjectId;
}

1.4 启动类配置

这里可以写@tk.mybatis.spring.annotation.MapperScan({“com.it.mhh.dao.*”}) 用来代替Dao层的@Mapper,开发可减少代码量 (我用的@Mapper注解)

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication //启动类 注解
@EnableEurekaClient // 注册eureka 表明此项目为客户端
public class MapperApplication {

    public static void main(String[] args) {
        SpringApplication.run(MapperApplication.class, args);
    }
}

1.5 SQL 表创建

这里我给地址(address)设置了默认值 为山东；

CREATE TABLE `student` (
  `id` varchar(32) NOT NULL COMMENT '数据表主键',
  `address` varchar(32) DEFAULT '山东' COMMENT '学生住址',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `name` varchar(32) DEFAULT NULL COMMENT '姓名',
  `teacher` varchar(32) DEFAULT NULL COMMENT '学生的老师',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2.基本增删改查

`mapper接口中的基本函数及方法:`

方法	功能说明
int insert(T var1);	根据传入对象属性，插入所有属性对应的字段。
int insertSelective(T var1);	根据传入对象属性，只插入对象属性非空字段
int delete(T var1);	根据传入对象属性，删除所有查找到的记录。
int deleteByPrimaryKey(Object var1);	根据传入的主键，删除对应记录
int updateByPrimaryKey(T var1);	根据传入对象属性，以主键为条件，更新所有字段
int updateByPrimaryKeySelective(T var1);	根据传入对象属性,以主键为条件，只更新对象属性非空字段。
List select(T var1);	根据传入对象属性查询，返回实体类元素集合。
T selectOne(T var1);	根据传入的对象属性查询，存在多个返回值时抛出异常。
List selectAll();	返回实体类元素集合 (返回表中所有数据)。
int selectCount(T var1);	根据传入的对象属性查询，返回总记录数。
T selectByPrimaryKey(Object var1);	根据传入的主键，查询数据库主键返回数据。
List selectByRowBounds(T var1, RowBounds var2);	分页查询

2.1 新增

2.1.1 insert:根据传入对象属性，插入所有属性对应的字段，null属性也会被保存，不会使用数据库默认值

方法	功能说明
int insert(T var1);	根据传入对象属性，插入所有属性对应的字段。

根据传入对象属性，插入所有属性对应的字段，null属性也会被保存，不会使用数据库默认值

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//-------------------------------insert-------------------------------------------------------------

    //insert 存储学生 : [根据传入对象属性，插入所有属性对应的字段。]
    @RequestMapping("/insert")
    public Boolean insertStudent(@Valid @RequestBody Student student) {
        return basicMapperService.instertStudent(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int insert(T var1);
说明：保存一个实体，null的属性也会保存，不会使用数据库默认值

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


    //insert 存储学生 : [根据传入对象属性，插入所有属性对应的字段。]
    @Override
    public Boolean instertStudent(Student student) {
        return basicMapper.insert(student) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 insert 新增方法 不会使用数据库默认值

请求体:

数据库

2.1.2 insertSelective：根据传入对象属性，插入所有属性对应的字段，null的属性不会保存，会使用数据库默认值

方法	功能说明
int insertSelective(T var1);	根据传入对象属性，只插入对象属性非空字段

根据传入对象属性，插入所有属性对应的字段，null的属性不会保存，会使用数据库默认值

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//-------------------------------insert-------------------------------------------------------------

 //insertSelective 存储学生 [根据传入对象属性，只插入对象属性非空字段]
    @RequestMapping("/insertSelective")
    public Boolean insertSelective(@Valid @RequestBody Student student) {
        return basicMapperService.insertSelective(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int insertSelective(T record);
说明：保存一个实体，null的属性不会保存，会使用数据库默认值

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


   //insertSelective 存储学生 [根据传入对象属性，只插入对象属性非空字段]
    @Override
    public Boolean insertSelective(Student student) {
        return basicMapper.insertSelective(student) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 insertSelective 新增方法 会使用数据库默认值

请求体:

数据库:

2.2 删除

2.2.1 delete: 根据实体属性作为条件进行删除，查询条件使用等号

方法	功能说明
int delete(T var1);	根据传入对象属性，删除所有查找到的记录。

根据传入对象属性，删除所有查找到的记录。

有个好玩的bug，当此对象的属性有是基本类型(int,float…)时不要给非基本类型(int,float…)属性赋值为前提条件，给空对象或者只给一个或多个基本类型(int,float…)赋值 都会删除此表全部数据
这里就注意不要用基本类型！！用封装类！！！！

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------delete---------------------------------------------------------
    
    //delete(T t)) 根据传入对象属性，删除所有查找到的记录。
    //有个好玩的bug，当此对象的属性有是基本类型(int,float..)时 不要给非基本类型(int,float..)属性赋值为前提条件，给空对象或者只给一个或多个基本类型(int,float..)赋值 都会删除此表全部数据
    // 这里就注意 不要用基本类型！！  用封装类！！！！
    @RequestMapping("/delete")
    public Boolean delete(@RequestBody Student student) {
        return basicMapperService.delete(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：delete(T t)) 根据传入对象属性，删除所有查找到的记录。
说明：根据传入对象属性，删除所有查找到的记录。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


   //delete(T t)) 根据传入对象属性，删除所有查找到的记录。
    //  有个好玩的bug，当此对象的属性有是int时 不要给非int属性赋值为前提条件，给空对象或者只给一个或多个int赋值 都会删除此表全部数据
    @Override
    public Boolean delete(Student student) {
        return basicMapper.delete(student) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 delete 删除方法 会删除对象属性值匹配中的数据

sql表元数据:

请求体:

代码执行完 数据库:

2.2.2 deleteByPrimaryKey: 根据传入的主键，删除对应记录。

方法	功能说明
int deleteByPrimaryKey(Object var1);	根据传入的主键，删除对应记录

这里可以传对象(它会取被@id所注解的属性)
deleteByPrimaryKey(Object key) 根据传入的主键，删除对应记录。

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------delete---------------------------------------------------------
    
    //根据主键进行删除
    //deleteByPrimaryKey(Object key) 根据传入的主键，删除对应记录。
    //这里可以传对象(它会取被@id所注解的对象)
    //传属性参数 则就直接用于主键比较 相等则删除；
    @RequestMapping("/deleteByPrimaryKey/{id}")
    public Boolean deleteByPrimaryKey(@PathVariable Object id) {
        return basicMapperService.deleteByPrimaryKey(id);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int deleteByPrimaryKey(Object key);
说明：根据传入的主键，删除对应记录。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


 //deleteByPrimaryKey(Object key) 根据传入的主键，删除对应记录。
    //这里可以传对象(它会取被@id所注解的对象)
    //传属性参数 则就直接用于主键比较；
    @Override
    public Boolean deleteByPrimaryKey(Object id) {
        return basicMapper.deleteByPrimaryKey(id) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 deleteByPrimaryKey 删除方法 删除对应主键为1的数据

sql表元数据:

请求体:

代码执行完数据库:

2.3 修改

2.3.1 updateByPrimaryKey:根据主键进行修改，更新所有字段(属性是null或 ’ ’ 也会覆盖掉之前的数据)

方法	功能说明
int updateByPrimaryKey(T var1);	根据传入对象属性，以主键为条件，更新所有字段

updateByPrimaryKey(Object o) 根据传入对象属性，更新所有字段(就是你这个属性名对应上字段名那么就会给你更新，哪怕这个属性值是null或" ",都会覆盖原有数据，进行更新)

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------update---------------------------------------------------------

     //根据主键进行修改
    // updateByPrimaryKey(Object o) 根据传入对象属性，更新所有字段(就是你这个属性名对应上字段名那么就会给你更新，哪怕这个属性值是null或" ",都会覆盖原有数据，进行更新)
    @RequestMapping("/updateByPrimaryKey")
    public Boolean updateByPrimaryKey(@RequestBody Student student) {
        return basicMapperService.updateByPrimaryKey(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int updateByPrimaryKey(T var1);
说明：根据传入对象属性，更新所有字段，依据主键进行修改

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


   // updateByPrimaryKey(Object o) 根据传入对象属性，更新所有字段(就是你这个属性名对应上字段名那么就会给你更新，哪怕这个属性值是null或" ",都会覆盖原有数据，进行更新)
    @Override
    public Boolean updateByPrimaryKey(Student student) {
        return basicMapper.updateByPrimaryKey(student) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 updateByPrimaryKey 修改方法 根据传入对象属性，更新所有字段，属性是null或'' 也会被更新上

sql表元数据:

请求体:

代码执行完 数据库:

2.3.2 updateByPrimaryKey:根据主键进行修改，只更新对象属性非空字段

方法	功能说明
int updateByPrimaryKeySelective(T var1);	根据传入对象属性,以主键为条件，只更新对象属性非空字段。

updateByPrimaryKeySelective(T t) 只更新对象属性非空字段。(相当于sql里加了标签用来判断此属性否为空或null,如果是就不修改此字段否则修改)

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------update---------------------------------------------------------

    //根据主键进行修改
    // updateByPrimaryKeySelective(T t) 只更新对象属性非空字段 。(相当于sql里加了<if>标签用来判断此属性否为空或null,如果是就不修改此字段 否则修改)
    @RequestMapping("/updateByPrimaryKeySelective")
    public Boolean updateByPrimaryKeySelective(@RequestBody Student student) {
        return basicMapperService.updateByPrimaryKeySelective(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int updateByPrimaryKeySelective(T var1);
说明：根据传入对象属性，更新此对象非空字段，依据主键进行修改

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


  //updateByPrimaryKeySelective(T t) 只更新对象属性非空字段 。(相当于sql里加了<if>标签用来判断此属性否为空或null,如果是就不修改此字段 否则修改)
    @Override
    public Boolean updateByPrimaryKeySelective(Student student) {
        return basicMapper.updateByPrimaryKeySelective(student) > 0 ? true : false;
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 updateByPrimaryKeySelective 修改方法 根据传入对象属性，更新此对象非空字段

sql表元数据:

请求体:

代码执行完 数据库:

2.4 查看

2.4.1 select: 根据传入对象非空属性查询，返回实体类元素集合。

方法	功能说明
List select(T var1);	根据传入对象属性查询，返回实体类元素集合。

select()方法入参为null 则表明查询此表全部数据。
sql中标签做了校验，对传进来的对象做非空属性校验进行等值匹配，将匹配成功的返回；

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

    //select(T t) :根据传入对象属性查询，返回实体类元素集合。
    // sql中<if>标签 做了校验，对传进来的对象做非空属性校验 进行等值匹配，将匹配成功的返回；
    @RequestMapping("/select")
    public List<Student> select(@RequestBody Student student) {
        return basicMapperService.select(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：List select(T var1);
说明：根据传入对象属性查询，返回实体类元素集合。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


  	//select(T t) :根据传入对象属性查询，返回实体类元素集合。
    // sql中<if>标签 做了校验，对传进来的对象做非空属性校验 进行等值匹配，将匹配成功的返回；
    @Override
    public List<Student> select(Student student) {
        return basicMapper.select(student);
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 select 查询方法 根据传入对象非空属性查询，返回实体类元素集合

sql表元数据:

请求体:

2.4.2 selectOne: 根据传入的对象属性查询，存在多个返回值时抛出异常。

方法	功能说明
T selectOne(T var1);	根据传入的对象属性查询，存在多个返回值时抛出异常。

这个方法只能返回一个参数，要注意查询结果不能是多个

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

   //selectOne(T t)) :根据传入的对象属性查询，存在多个返回值时抛出异常。
    // sql中<if>标签 做了校验，对传进来的对象做非空属性校验 进行等值匹配，将匹配成功的返回；
    @RequestMapping("/selectOne")
    public Student selectOne(@RequestBody Student student) {
        return basicMapperService.selectOne(student);
    //Expected one result (or null) to be returned by selectOne(), but found: 2 多个会报此错误
    }

ServiceImpl层：BasicMapperServiceImpl

方法：T selectOne(T var1);
说明：根据传入的对象属性查询，存在多个返回值时抛出异常。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


    //selectOne(T t)) :根据传入的对象属性查询，存在多个返回值时抛出异常。
    // sql中<if>标签 做了校验，对传进来的对象做非空属性校验 进行等值匹配，将匹配成功的返回；
    @Override
    public Student selectOne(Student student) {
        return basicMapper.selectOne(student);
        //Expected one result (or null) to be returned by selectOne(), but found: 2 多个会报此错误
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectOne 查询方法 根据传入对象非空属性查询，着重注意返回参数数据必须是少于或等于1个，返回多个则抛出异常
error：Expected one result (or null) to be returned by selectOne(), but found: 2

sql表元数据:

请求体:

2.4.3 selectAll: 查询全部结果，select(null)方法能达到同样的效果

方法	功能说明
List selectAll();	返回实体类元素集合 (返回表中所有数据)。

查询此表的全部数据

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

  //selectAll() :返回实体类元素集合。
    @RequestMapping("/selectAll")
    public List<Student> selectAll() {
        return basicMapperService.selectAll();
    }

ServiceImpl层：BasicMapperServiceImpl

方法：List selectAll();
说明：查询 JavaBean中@Table()注解中表的所有数据

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


  //selectAll() :返回实体类元素集合。
    @Override
    public List<Student> selectAll() {
        return basicMapper.selectAll();
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectAll 查询方法 查询出 JavaBean中@Table()注解中表的所有数据

sql表元数据:

请求体:

2.4.4 ：selectCount :根据传入的对象属性查询，返回总记录个数。

方法	功能说明
int selectCount(T var1);	根据传入的对象属性查询，返回总记录数。

查询入参命中的总个数
好玩的 bug：当你传的参数所有数值都为null时，则返回此表的总个数(可能不算是bug)

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

  //selectCount(T t)) :根据传入的对象属性查询，返回总记录数。
  //好玩的 bug：当你传的参数所有数值都为null时，则返回此表的总个数(可能不算是bug)
    @RequestMapping("/selectCount")
    public Integer selectCount(@RequestBody Student student) {
        return basicMapperService.selectCount(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：int selectCount(T var1);
说明：根据传入的对象属性查询，返回命中总记录个数。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


 //selectCount(T t)) :根据传入的对象属性查询，返回总记录数。
    @Override
    public Integer selectCount(Student student) {
        return basicMapper.selectCount(student);
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectCount 查询方法 根据传入的对象属性查询，返回命中总记录个数

请求体:

2.4.5 ：selectByPrimaryKey: 根据传入的主键，查询数据库返回相应数据。

方法	功能说明
T selectByPrimaryKey(Object var1);	根据传入的主键，查询数据库主键返回数据。

这里可以传对象(它会取被@id所注解的对象),其他属性就没用处了，传与不传都一样，sql不会解读除了@id注解的参数
或者直接传值，则就直接用于主键比较；

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

  //selectByPrimaryKey(Object key) 根据传入的主键，查询数据库主键返回数据。
    //这里可以传对象(它会取被@id所注解的对象),其他属性就没用处了，传与不传都一样，sql不会解读除了@id注解的参数
    //传属性参数 则就直接用于主键比较；
    @RequestMapping("/selectByPrimaryKey")
    public Student selectByPrimaryKey(@RequestBody Student student) {
        return basicMapperService.selectByPrimaryKey(student);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：T selectByPrimaryKey(Object var1);
说明：根据传入的对象主键或参数，查询数据库主键返回数据。

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


	//selectByPrimaryKey(Object key) 根据传入的主键，查询数据库主键返回数据。
    //这里可以传对象(它会取被@id所注解的对象)
    //传属性参数 则就直接用于主键比较；
    @Override
    public Student selectByPrimaryKey(Student student) {
        return basicMapper.selectByPrimaryKey(student);
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectByPrimaryKey 查询方法 根据传入的对象中被@id()注解的属性，查询数据库主键，返回数据。

请求体:

2.4.6 ：selectByRowBounds: 分页查询

方法	功能说明
List selectByRowBounds(T var1, RowBounds var2);	分页查询

offset :表示从第几条数据开始
limit : 连续取出几条数据
RowBounds.DEFAULT 返回所有查询到的数据

Controller层：BasicMapperController



import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;

/*
*  基本增删改查
* */
@RestController
@RequestMapping("/basicMapper")
public class BasicMapperController {

    @Autowired
    private BasicMapperService basicMapperService;

//--------------------------------------select---------------------------------------------------------

 //selectByRowBounds(T t,RowBounds rowBounds)：分页查询
    //offset :表示从第几条数据开始
    //limit : 连续取出几条数据
    //RowBounds.DEFAULT  返回所有查询到的数据
    @RequestMapping("/selectByRowBounds")
    public List<Student> selectByRowBounds(@RequestBody Student student, @RequestParam("offset") Integer offset,@RequestParam("limit")Integer limit) {
        return basicMapperService.selectByRowBounds(student,offset,limit);
    }

ServiceImpl层：BasicMapperServiceImpl

方法：List selectByRowBounds(T var1, RowBounds var2);
说明：第一个入参是你要查询的数据，第二入参就是分页了

offset :表示从第几条数据开始
limit : 连续取出几条数据
RowBounds.DEFAULT 返回所有查询到的数据

import com.it.mhh.dao.BasicMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.BasicMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BasicMapperServiceImpl implements BasicMapperService {

    @Autowired
    private BasicMapper basicMapper;


	 @Override
    public List<Student> selectByRowBounds(Student student,Integer offest,Integer limit) {
        RowBounds rowBounds = new RowBounds(offest, limit);
        //RowBounds.DEFAULT  返回所有查询到的数据
        return basicMapper.selectByRowBounds(student,rowBounds);
    }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  基本增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectByRowBounds 查询方法 就是Sql中的limit，从第几条开始(offset)，读取几条(limit)

请求体:

3.复杂条件查询

`mapper接口中的复杂函数及方法:Example.Criteria实例解析:`

方法	说明
example.setOrderByClause(“字段名 ASC”);	添加升序排列条件，DESC为降序
example.setDistinct(false)	去除重复，boolean型，true为选择不重复的记录。
criteria.andIsNull(String property)	添加字段xxx为null的条件
criteria.andIsNotNull(String property)	添加字段xxx不为null的条件
criteria.andEqualTo(String property, Object value)	添加xxx字段等于value条件
criteria.andNotEqualTo(String property, Object value)	添加xxx字段不等于value条件
criteria.andGreaterThan(String property, Object value)	添加xxx字段大于value条件
criteria.andGreaterThanOrEqualTo(String property, Object value)	添加xxx字段大于等于value条件
criteria.andLessThan(String property, Object value)	添加xxx字段小于value条件
criteria.andLessThanOrEqualTo(String property, Object value)	添加xxx字段小于等于value条件
criteria.andIn(String property, Iterable values)	添加xxx字段值在List<？>条件 [Iterable 为迭代器，相当于对元素集合遍历]
criteria.andNotIn(String property, Iterable values)	添加xxx字段值不在List<？>条件 [Iterable 为迭代器，相当于对元素集合遍历]
criteria.andLike(String property, String value)	添加xxx字段值为%value%的模糊查询条件（传进来的参数必须是用%value%这种形式拼接）
criteria.andNotLike(String property, String value)	添加xxx字段值不为%value%的模糊查询条件（传进来的参数必须是用%value%这种形式拼接）
criteria.andBetween(String property, Object value1, Object value2)	添加xxx字段值在value1和value2之间条件
criteria.andNotBetween(String property, Object value1, Object value2)	添加xxx字段值不在value1和value2之间条件

3.1 修改：

3.1.1 updateByExample:更新满足条件的数据中对象所有值，包括null

根据Example条件更新实体对象包含的全部属性，null值会被更新

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

    //------------------------------update----------------------------------------------------------
    //方法：int updateByExample(@Param("record") T var1, @Param("example") Object var2);
    //说明： 更新满足条件的数据中对象所有值，包括null
    @RequestMapping("/updateByExample")
    public Boolean updateByExample(@RequestBody Student student) {
        return complexMapperService.updateByExample(student);
    }
  }

ServiceImpl层：ComplexMapperImpl

方法：int updateByExample(@Param(“record”) T var1, @Param(“example”) Object var2);
说明：根据Example条件更新实体record包含的全部属性，null值会被更新
需求：修改name是小黑的数据

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

    @Override
    public Boolean updateByExample(Student student) {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();

        criteria.andEqualTo("name", "小黑");//意思修改 sql中name=="小黑"的
        return complexMapper.updateByExample(student, example) > 0 ? true : false;
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 updateByExample 修改方法根据Example条件 Example条件是 修改name是小黑的数据，null值也会被更新进去

sql表元数据:

请求体:

代码执行完数据库:

3.1.2 updateByExampleSelective:据Example条件更新实体包含的不是null的属性值

根据Example条件更新实体对象包含的全部属性，null值不会被更新

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

    //------------------------------update----------------------------------------------------------
    //方法：int updateByExampleSelective(@Param("record") T var1, @Param("example") Object var2);
    //说明： updateByExampleSelective     只会更新满足条件的数据中对象中有字段的值
    @RequestMapping("/updateByExampleSelective")
    public Boolean updateByExampleSelective(@RequestBody Student student) {
        return complexMapperService.updateByExampleSelective((student));
    }
  }

ServiceImpl层：ComplexMapperImpl

方法：int updateByExampleSelective(@Param(“record”) T record, @Param(“example”) Object example);@Param(“example”) Object var2);
说明：根据Example条件更新实体record包含的不是null的属性值
需求：修改age是>12的数据

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

   @Override
    public Boolean updateByExampleSelective(Student student) {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andGreaterThan("age", 12);//意思修改 sql中age>"12"的
        return complexMapper.updateByExampleSelective(student, example) > 0 ? true : false;
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 updateByExampleSelective 修改方法根据Example条件 Example条件是修改age是>12的数据，null值不会被更新

sql表元数据:

请求体:

代码执行完数据库:

3.2 删除：

3.2.1 deleteByExample:根据Example条件删除数据

根据Example条件删除数据

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

  //------------------------------delete----------------------------------------------------------
    //方法：int deleteByExample(Object var1);
    //说明：根据Example条件删除数据
    @RequestMapping("/deleteByExample/{object}")
    public Boolean deleteByExample(@PathVariable Object object) {
        return complexMapperService.deleteByExample(object);
    }
 
  }

ServiceImpl层：ComplexMapperImpl

方法：int deleteByExample(Object example);
说明：根据Example条件删除数据
需求：删除age是>入参的数据

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

   @Override
    public Boolean deleteByExample(Object object) {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andGreaterThan("age", object);//意思删除 sql中age>"入参object"的
        return complexMapper.deleteByExample(example) > 0 ? true : false;
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 deleteByExample 删除方法根据Example条件 Example条件是只删除age是>入参值的数据【入参值是12】

sql表元数据:

请求体:

代码执行完数据库:

3.3 查询：

3.2.1 selectByExample:根据Example条件进行查询

根据Example条件查询数据

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

 //------------------------------select----------------------------------------------------------

    //方法：List<T> selectByExample(Object var1);
    //说明：根据Example条件进行查询
    @RequestMapping("/selectByExample")
    public List<Student> selectByExample() {
        return complexMapperService.selectByExample();
    }
 
  }

ServiceImpl层：ComplexMapperImpl

方法：List selectByExample(Object var1);
说明：根据Example条件查询数据
需求：查询age是>12的数据和name是小小倩的

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

   @Override
    public List<Student> selectByExample() {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andGreaterThan("age", 12);//意思查询 sql中age>"12"的
        criteria.andEqualTo("name", "小小倩");//意思查询 name=="小小倩"的
        return complexMapper.selectByExample(example);
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectByExample 查询方法根据Example条件 Example条件是查询age是>12的数据和name是小小倩的

sql表元数据:

请求体:

3.2.2 selectByExampleAndRowBounds:根据Example条件进行分页查询

根据Example条件进行分页查询

offset :表示从第几条数据开始
limit : 连续取出几条数据
RowBounds.DEFAULT 返回所有查询到的数据

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

 //------------------------------select----------------------------------------------------------

   //List<T> selectByExampleAndRowBounds(Object var1, RowBounds var2);
    //根据Example条件进行查询 和分页查询
    //offset :表示从第几条数据开始
    //limit : 连续取出几条数据
    //RowBounds.DEFAULT  返回所有查询到的数据
    @RequestMapping("/selectByExampleAndRowBounds")
    public List<Student> selectByExampleAndRowBounds() {
        return complexMapperService.selectByExampleAndRowBounds();
    }

  }

ServiceImpl层：ComplexMapperImpl

方法：List selectByExampleAndRowBounds(Object var1, RowBounds var2);
说明：根据Example条件进行分页查询
需求：查询name是模糊的 %小小%的数据并分页返回2条数据

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

   @Override
    public List<Student> selectByExampleAndRowBounds() {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andLike("name", "%小小%");//意思查询 sql中name"%小小%"的
        return complexMapper.selectByExampleAndRowBounds(example, new RowBounds(0, 2));
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectByExampleAndRowBounds 查询方法根据Example条件 Example条件是查询name是模糊的 %小小%的数据并分页返回2条数据

sql表元数据:

请求体:

3.2.3 selectOneByExample:根据Example条件进行查询,在多个返回值时抛出异常。

根据Example条件进行查询,在多个返回值时抛出异常。
error: Expected one result (or null) to be returned by selectOne(), but found: 4

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

 //------------------------------select----------------------------------------------------------

    //方法：T selectOneByExample(Object var1);
    //说明：根据Example条件进行查询,在多个返回值时抛出异常。
    @RequestMapping("/selectOneByExample")
    public Student selectOneByExample() {
        return complexMapperService.selectOneByExample();
        //Expected one result (or null) to be returned by selectOne(), but found: 4
    }
  }

ServiceImpl层：ComplexMapperImpl

方法：T selectOneByExample(Object var1);
说明：根据Example条件进行查询,在多个返回值时抛出异常。
需求：查询age是>=12的和age是<=14的

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

      @Override
    public Student selectOneByExample() {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andBetween("age", 12,14);//意思查询 sql中age>="12"和age<="14"的
        return complexMapper.selectOneByExample(example);
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectOneByExample 查询方法根据Example条件 Example条件是查询age是>=12的和age是<=14的【切记返回数据一定是一条 否则报错】

sql表元数据:

请求体:

3.2.3 selectCountByExample:根据Example条件进行查询,返回命中个数。

根据Example条件进行查询,返回命中个数。
当你传的参数为null时，则返回此表的总个数。

Controller层：ComplexMapperController




import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("complexMapper")
public class ComplexMapperController {

    @Autowired
    private ComplexMapperService complexMapperService;

 //------------------------------select----------------------------------------------------------

     //selectCountByExample
    //方法：int selectCountByExample(Object var1);
    //说明：根据Example条件进行查询,返回命中个数。
    //好玩的 bug：当你传的参数为null时，则返回此表的总个数(可能不算是bug)
    @RequestMapping("/selectCountByExample")
    public Integer selectCountByExample() {
        return complexMapperService.selectCountByExample();
    }

  }

ServiceImpl层：ComplexMapperImpl

方法：int selectCountByExample(Object var1);
说明：根据Example条件进行查询,返回命中个数
需求：查询address是null的有几个

import com.it.mhh.dao.ComplexMapper;
import com.it.mhh.entitry.Student;
import com.it.mhh.service.ComplexMapperService;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class ComplexMapperImpl implements ComplexMapperService {

    @Autowired
    private ComplexMapper complexMapper;

   @Override
    public Integer selectCountByExample() {
        Example example = new Example(Student.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andIsNull("address");//意思查询 sql中address是null的
        return complexMapper.selectCountByExample(example);
    }
 }

Dao层:BasicMapper

Dao层使用通用Mapper接口，只需要让我们的接口实现Mapper即可,泛型就是你要操作的那个表映射的javaBean对象
此处需注意导入的是tk.mybatis.mapper.common.Mapper而不是mybatis的Mapper

import com.it.mhh.entitry.Student;
import org.apache.ibatis.annotations.Mapper;

/*
*  复杂增删改查
* */
@Mapper
public interface BasicMapper   extends tk.mybatis.mapper.common.Mapper<Student> {

}

结果：

可以看出 selectCountByExample 查询方法根据Example条件 Example条件是查询address是null的有几个

sql表元数据:

请求体:

链接：JAVA - mybatis的TK_Mapper(通用mapper)祥例使用源代码下载地址

孟浩浩

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA - mybatis的TK_Mapper(通用mapper)祥例使用

目录1.项目工程搭建：1.1 引入pom依赖1.2 application.yml 配置1.3 JavaBean对象1.4 启动类配置2.基本增删改查2.1 新增2.1.1 insert1.项目工程搭建：1.1 引入pom依赖引入SpringBoot和SpringCloud版本时特别注意下他们的兼容       参考: https://spring.io/projects/spring-cloud<!--引入springb
复制链接

扫一扫