Java：SpringBoot系列——第七章整合tkMapperSpringBoot系列——第七章整合tkMapper前言

96 阅读 0 评论 64 点赞

我是靠谱客的博主活泼煎蛋，这篇文章主要介绍Java：SpringBoot系列——第七章整合tkMapperSpringBoot系列——第七章整合tkMapper前言，现在分享给大家，希望可以做个参考。

SpringBoot系列——第七章整合tkMapper

文章目录

SpringBoot系列——第七章整合tkMapper
前言
- 一、在项目开发中DAO的实现问题
- - 1. 实体类与数据表的关系
  - 2. DAO接口中方法的规律
  - 3. Mapper映射文件的规律
- 二、tkMapper的概述
- - 1. tkMapper的介绍
  - 2. tkMapper的作用
- 三、tkMapper集成部署
- - 1. 基于SpringBoot完成MyBatis的集成
  - - 1.1 创建SpringBoot项目
    - 1.2 配置MyBatis
    - 1.3 在启动类指定DAO类的路径
  - 2. SpringBoot集成tkMapper
  - - 2.1 添加依赖
    - 2.2 修改启动类@MapperScan的包
- 四、tkMapper的使用
- - 1. 创建数据表
  - 2. 创建实体类
  - 3. 创建DAO接口
  - 4. 创建测试类
  - - 4.1 添加依赖
    - 4.2 测试类
    - 4.3 测试结果
- 五、tkMapper的常用方法
- - 1. 添加操作
  - - 1.1 添加一个对象
    - 1.2 主键回填的添加
  - 2. 修改操作
  - - 2.1 根据主键修改记录
  - 3. 删除操作
  - - 3.1 根据主键删除记录
  - 4. 查询操作
  - - 4.1 查询所有记录
    - 4.2 根据主键查询记录
    - 4.3 根据条件查询
    - 4.4 分页查询
    - 4.5 带条件的分页查询
- 六、tkMapper的关联查询
- - 1. 多次单表查询
  - 2. 自定义查询
- 七、基于tkMapper的逆向工程
- - 1. 添加逆向工程依赖
  - 2. 逆向工程配置
  - 3. 将配置文件设置到maven插件中
  - 4. 执行逆向生成

前言

基于mybatis提供了很多第三方插件，这些插件通常可以帮助我们完成数据操作方法的封装、数据库逆向工程工作的工作

一、在项目开发中DAO的实现问题

为什么需要用到tkMapper

1. 实体类与数据表的关系

实现类与数据表直接存在对应关系，并且是有规律的，因此我们只要指定数据表的结构，就能生成实体类

在这里插入图片描述

2. DAO接口中方法的规律

所有DAO接口中定义的方法也是有一定规律的，不同点就是实体类型的不同

UserDAO

public interface UserDAO {
   
    public int insertUser(User user);
    public User queryUserByName(String userName);
}

BookDAO

public interface BookDAO {
   
    public int insertBook(Book book);
    public Book queryBookByName(String bookName);
}

把它们相同的部分抽取出来，定义一个通用接口，再它们继承这个接口

public interface GeneralDAO<T> {

    public int insert(T t);
    public T queryByName(String name);
}

UserDAo

public interface UserDAO extends GeneralDAO<User>{
}

BookDAO

public interface BookDAO extends GeneralDAO<Book>{
}

3. Mapper映射文件的规律

GeneralDAO接口中定义的数据库操作方法使用了泛型，因此无需映射文件；对应UserDAO和BookDAO需要映射文件，所有DAO的相同操作的映射文件也是有规律可循的

UserMapper

<insert id="insert">
    insert into users(user_id,username)
    values (#{userId},#{username})
</insert>

@Table
public class User {
	@Id
	@Column("user_id")
	private int userId;
	@Column("username")
	private String username;
}

BookMapper

<insert id="insert">
    insert into books(book_id,book_name)
    values (#{bookId},#{bookName})
</insert>

@Table
public class Book {
	@Id
	@Column("book_id")
	private int bookId;
	@Column("book_name")
	private String BookName;
}

二、tkMapper的概述

基于mybatis提供了很多第三方插件，这些插件通常可以帮助我们完成数据操作方法的封装、数据库逆向工程工作的工作

数据库逆向工程：根据数据表生成实体类、映射文件。

常用的第三方插件：

MyBatis-plus
tkMapper

1. tkMapper的介绍

tkMapper是一个Mybatis插件，是在Mybatis的基础上提供了许多工具，可以帮助我们完成对应数据库的相关操作，提高开发效率。

2. tkMapper的作用

提供了针对表通用的数据库操作方法
逆向工程–根据数据表生成实体类、dao接口、映射文件

三、tkMapper集成部署

1. 基于SpringBoot完成MyBatis的集成

1.1 创建SpringBoot项目

File–New–Project–Spring Initializr
填写项目信息

远程服务器
项目名
本地JDK与远程服务器下载的应用JDK要保持一致

在这里插入图片描述

下载应用的配置

下载的SpringBoot版本
添加的依赖

在这里插入图片描述

1.2 配置MyBatis

在SpringBoot配置文件配置mybatis

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db6?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456


mybatis.mapper-locations=classpath:mappers/*Mapper.xml
mybatis.type-aliases-package=com.xiaoqing.springboottkmapperdemo.beans

1.3 在启动类指定DAO类的路径

@SpringBootApplication
@MapperScan("com.xiaoqing.springboottkmapperdemo.dao")//指定DAO类的路径
public class SpringbootTkmapperDemoApplication {

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

}

2. SpringBoot集成tkMapper

2.1 添加依赖

在pom.xml中添加依赖

<!-- https://mvnrepository.com/artifact/tk.mybatis/mapper-spring-boot-starter -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
</dependency>

2.2 修改启动类@MapperScan的包

修改tk.mybatis的包为tk.mybatis.spring.annotation.MapperScan，不修改会报错

在这里插入图片描述

package com.xiaoqing.springboottkmapperdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
//@MapperScan("com.xiaoqing.springboottkmapperdemo.dao")
@MapperScan("com.xiaoqing.springboottkmapperdemo.dao")
public class SpringbootTkmapperDemoApplication {

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

至此，tkMapper部署完成

四、tkMapper的使用

1. 创建数据表

创建数据表

users

DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(20) NOT NULL,
  `user_pwd` varchar(20) NOT NULL,
  `user_realname` varchar(20) NOT NULL,
  `user_img` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8;

2. 创建实体类

tkMapper，在映射的时候，实体类名要与数据库表名保持一致（实体类名为表名首字母大写、带有下划线‘_’的名字，省去下划线，下划线后的第一个首字母大写）

如果表名和实体类名不对应会报错，一共有两种解决方式：

修改实体类名，与表名对应
使用@Table（）注解指定表名

@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "users") //指定数据库中的表名
public class User {
    private int userId;
    private String userName;
    private String userPwd;
    private String userRealname;
    private String userImg;
}

3. 创建DAO接口

tkMapper已经完成了对单表的通用操作的封装，主要封装在Mapper接口和MysqlMapper接口中，因此我们如果要完成对单表的操作，只需要自定义dao接口继承这两个接口即可。

在测试类的时候userdao会报错，提示“找不到userdao”，这里可以忽略(因为是可以获取到的)，可以在接口中使用@Repository注解就不会提示错误

UserDAO

@Repository
public interface UserDAO extends Mapper<User>, MySqlMapper<User> {
}

4. 创建测试类

4.1 添加依赖

junit
Spring-test

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>4.13.2</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

4.2 测试类

@RunWith 声明单元测试的驱动

@SpringBootTest 声明启动类的路径

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootTkmapperDemoApplication.class)
public class UserDAOTest {
    @Autowired
    private UserDAO userDAO;
    @Test
    public void insert(){
        User user = new User();
        user.setUserName("hong");
        user.setUserPwd("123456");
        user.setUserRealname("小红");
        user.setUserImg("12.png");
        int insert = userDAO.insert(user);
        System.out.println(insert);
    }
}

4.3 测试结果

在这里插入图片描述

五、tkMapper的常用方法

1. 添加操作

添加操作的常用方法有两个：

insert() 添加一个对象

insertUseGeneratedKeys() 添加一个对象并进行主键回填

在进行主键回填的时候，实体类中id必须要用@Id指定，并且主键的数据类型改为Integer（通过反射）

1.1 添加一个对象

@Test
public void insert(){

    User user = new User();
    user.setUserName("ming");
    user.setUserPwd("123456");
    user.setUserRealname("小明");
    user.setUserImg("13.png");

    int i = userDAO.insert(user);
    assertEquals(1,i);

}

测试结果：

在这里插入图片描述

1.2 主键回填的添加

在进行主键回填的时候,实体类中id必须要用@Id指定，并且主键的数据类型改为Integer，不然获取不到回填的主键，因为tkMapper底层是通过反射实现的

@Test
public void insertUseGeneratedKeys(){
    User user = new User();
    user.setUserName("xiao");
    user.setUserPwd("888888");
    user.setUserRealname("笑笑");
    user.setUserImg("16.png");

    int i = userDAO.insertUseGeneratedKeys(user);
    assertEquals(1,i);
    System.out.println("回填的主键：" + user.getUserId());
}

在这里插入图片描述

测试结果

在这里插入图片描述

2. 修改操作

修改操作的常用方法：

updateByPrimaryKey() 根据主键修改记录
updateByExample() 根据条件删除记录

2.1 根据主键修改记录

@Test
public void update(){

    User user = new User();
    user.setUserId(17);
    user.setUserName("pipi");
    user.setUserPwd("666666");
    user.setUserRealname("pipi");
    user.setUserImg("18.png");

    int i = userDAO.updateByPrimaryKey(user);
    assertEquals(1,i);
}

修改前

在这里插入图片描述

修改后

在这里插入图片描述

3. 删除操作

删除操作常用方法：

deleteByPrimaryKey() 根据主键删除记录
deleteByExample() 根据条件删除记录

3.1 根据主键删除记录

@Test
public void delete(){

    int i = userDAO.deleteByPrimaryKey(17);
    assertEquals(1,i);
}

4. 查询操作

查询操作常用方法：

selectAll() 查询所有记录
selectByPrimaryKey() 根据主键查询
selectByExample() 根据条件查询
selectByRowBounds() 分页查询
selectCount() 查询总记录数
selectByExampleAndRowBounds() 带条件的分页查询
selectCountByExample()查询满足条件的总记录数

4.1 查询所有记录

@Test
public void select(){
    List<User> users = userDAO.selectAll();
    for (User user:
         users) {
        System.out.println(user);
    }
}

测试结果：

在这里插入图片描述

4.2 根据主键查询记录

@Test
public void select(){

    User user = userDAO.selectByPrimaryKey(18);
    System.out.println(user);
}

测试结果：

在这里插入图片描述

4.3 根据条件查询

1.查询用户名为xiao和hong的记录

@Test
public void select(){

    //根据条件查询
    //创建一个EXample对象用于封装User的查询条件
    Example example = new Example(User.class);
    Example.Criteria criteria = example.createCriteria();

    //封装条件：userName为xiao或者hong
    criteria.andEqualTo("userName","xiao");
    criteria.orEqualTo("userName","hong");

    List<User> users = userDAO.selectByExample(example);
    for (User user:users) {
    	System.out.println(user);
    }
}

测试结果:

在这里插入图片描述

2.查询用户名带“x”的记录

    @Test
    public void select(){
        //根据条件查询
        //创建一个EXample对象用于封装User的查询条件
        Example example = new Example(User.class);
        Example.Criteria criteria = example.createCriteria();
        //查询用户名带“x”的记录
        criteria.andLike("userName","%x%");

        List<User> users = userDAO.selectByExample(example);
        for (User user:
             users) {
            System.out.println(user);
        }
    }

测试结果：

在这里插入图片描述

4.4 分页查询

查询第二页，每页五条记录,总记录数

@Test
public void select(){
    //分页查询
    int pageNum = 2;
    int pageSize = 5;
    int start = (pageNum - 1) * pageSize;

    RowBounds rowBounds = new RowBounds(start,pageSize);
    List<User> users = userDAO.selectByRowBounds(new User(), rowBounds);
    for (User user:
         users) {
        System.out.println(user);
    }
    //查询总记录数
    int count = userDAO.selectCount(new User());
    System.out.println(count);
}

查询结果

在这里插入图片描述

4.5 带条件的分页查询

查询密码为123456的第二页，每页五条记录，满足条件的总记录数

@Test
public void select2(){
    //条件
    Example example = new Example(User.class);
    Example.Criteria criteria = example.createCriteria();
    criteria.andEqualTo("userPwd","123456");

    //分页查询
    int pageNum = 2;//第几页
    int pageSize = 5;//每页的条数
    int start = (pageNum - 1) * pageSize;
    RowBounds rowBounds = new RowBounds(start,pageSize);

    List<User> users = userDAO.selectByExampleAndRowBounds(example, rowBounds);
    for (User user:
            users) {
        System.out.println(user);
    }
    //查询满足条件的总记录数
    int count = userDAO.selectCountByExample(example);
    System.out.println(count);
}

查询结果：

在这里插入图片描述

六、tkMapper的关联查询

关联查询有两种策略：

进行多次单表查询
自定义查询

1. 多次单表查询

查询用户同时查询订单

①在User实体类private List orderList属性

②根据用户名查询出用户记录

③获取到用户记录的userId

④再根据userId去订单表查询符合条件订单记录

⑤最后将订单列表设置到用户orderList属性

@Test
public void select3(){
    //查询用户的同时查询订单

    //根据用户名查询用户
    Example example = new Example(User.class);
    Example.Criteria criteria = example.createCriteria();
    criteria.andEqualTo("userName","zhangsan");

    List<User> users = userDAO.selectByExample(example);
    User user = users.get(0);

    //根据用户id查询订单
    Example example1 = new Example(Order.class);
    Example.Criteria criteria1 = example1.createCriteria();
    criteria1.andEqualTo("userId",user.getUserId());
    List<Order> orders = orderDAO.selectByExample(example1);

    //将顶顶设置到user中
    user.setOrderList(orders);
    System.out.println(user);
}

查询结果：

在这里插入图片描述

2. 自定义查询

自定义查询是UserMapper.xml文件查询。

七、基于tkMapper的逆向工程

逆向工程，就是根据创建好的数据表，生成实体类、dao、映射文件

1. 添加逆向工程依赖

此依赖是一个mybatis的maven插件,在build标签里添加

<plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.5</version>

    <!--插件需要的依赖-->
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.1.5</version>
        </dependency>
    </dependencies>
</plugin>

2. 逆向工程配置

在com/xiaoqing/general目录下创建GeneralDao接口

注意：‘GeneralDao’,不能在dao包里

package general;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

public interface GeneralDao<T> extends Mapper<T>, MySqlMapper<T> {
}

在resources目录下创建generatorConfig.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="jdbc.properties"/>-->

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

        <!-- 配置 GeneralDAO -->
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="com.xiaoqing.general.GeneralDao"/>
        </plugin>

        <!-- 配置数据库连接 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/fmmail"
                        userId="root" password="123456">
        </jdbcConnection>

        <!-- 配置实体类存放路径 -->
        <javaModelGenerator targetPackage="com.xiaoqing.springboottkmapperdemo.beans" targetProject="src/main/java"/>

        <!-- 配置 XML 存放路径 -->
        <sqlMapGenerator targetPackage="/" targetProject="src/main/resources/mappers"/>

        <!-- 配置 DAO 存放路径 -->
        <javaClientGenerator targetPackage="com.xiaoqing.springboottkmapperdemo.dao" targetProject="src/main/java" type="XMLMAPPER"/>

        <!-- 配置需要指定生成的数据库和表，% 代表所有表 -->
        <table tableName="%"></table>
    </context>
</generatorConfiguration>

3. 将配置文件设置到maven插件中

pom.xml

在这里插入图片描述

<configuration>
    <configurationFile>${basedir}/src/main/resources/generatorConfig.xml</configurationFile>
</configuration>

4. 执行逆向生成

双击mybatis:generator:generate

在这里插入图片描述

出现BUILD SUCCESS则逆向成功

在这里插入图片描述

通过逆向生成的实体类、DAO和mapper

在这里插入图片描述

最后

以上就是活泼煎蛋最近收集整理的关于Java：SpringBoot系列——第七章整合tkMapperSpringBoot系列——第七章整合tkMapper前言的全部内容，更多相关Java：SpringBoot系列——第七章内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java
浏览次数：96 次浏览
发布日期：2023-10-29 05:21:01
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_18_fy_14__23__6_3.html

Java：SpringBoot系列——第七章 整合tkMapperSpringBoot系列——第七章 整合tkMapper前言

SpringBoot系列——第七章 整合tkMapper

文章目录

前言

一、在项目开发中DAO的实现问题

1. 实体类与数据表的关系

2. DAO接口中方法的规律

3. Mapper映射文件的规律

二、tkMapper的概述

1. tkMapper的介绍

2. tkMapper的作用

三、tkMapper集成部署

1. 基于SpringBoot完成MyBatis的集成

1.1 创建SpringBoot项目

1.2 配置MyBatis

1.3 在启动类指定DAO类的路径

2. SpringBoot集成tkMapper

2.1 添加依赖

2.2 修改启动类@MapperScan的包

四、tkMapper的使用

1. 创建数据表

2. 创建实体类

3. 创建DAO接口

4. 创建测试类

4.1 添加依赖

4.2 测试类

4.3 测试结果

五、tkMapper的常用方法

1. 添加操作

1.1 添加一个对象

1.2 主键回填的添加

2. 修改操作

2.1 根据主键修改记录

3. 删除操作

3.1 根据主键删除记录

4. 查询操作

4.1 查询所有记录

4.2 根据主键查询记录

4.3 根据条件查询

4.4 分页查询

4.5 带条件的分页查询

六、tkMapper的关联查询

1. 多次单表查询

2. 自定义查询

七、基于tkMapper的逆向工程

1. 添加逆向工程依赖

2. 逆向工程配置

3. 将配置文件设置到maven插件中

4. 执行逆向生成

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

Java：SpringBoot系列——第七章整合tkMapperSpringBoot系列——第七章整合tkMapper前言

SpringBoot系列——第七章整合tkMapper

发表评论取消回复