mybatis狂神(附自学过程中疑问解决)

首先先附上mybatis的官方文本链接mybatis – MyBatis 3 | 简介

一、Mybatis介绍

MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

简单来说,mybatis极大的方便我们对数据库的操作,在没有学mybatis之前,我们操作数据库的步骤十分繁琐,且编写sql语句复用性不高,而mybatis可以极大的方便我们操作数据库和编写sql,同时最重要的是体现了开发中的低耦合的特点,我们现在只需要进行对xml文件的修改就可以操作数据库和进行编写sql!!!

二、第一个Mybatis程序

mybatis狂神(附自学过程中疑问解决)_第1张图片

2.1、 环境搭建

搭建数据库

CREATE DATABASE `mybatis`;
USE `mybatis`;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(20) NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `pwd` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert  into `user`(`id`,`name`,`pwd`) values (1,'狂神','123456'),(2,'张三','abcdef'),(3,'李四','987654');

导入mybatis相关jar包


    org.mybatis
    mybatis
    3.5.2


    mysql
    mysql-connector-java
    5.1.47

编写mybatis-config核心配置文件




    
        
            
            
                
                
                
                
            
        
    
    
        
    

编写Mybatis工具类

为什么要这样写,这个详细见mybatis官方文档,地址在文章开头

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 java.io.IOException;
import java.io.InputStream;
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //获取SqlSession连接
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }
}

创建pojo

这个在后续会引入一个插件lombok,可以简化pojo

package com.kang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public User() {
    }
}

编写Mapper接口

import com.kang.pojo.User;
import java.util.List;
public interface UserMapper {
    List selectUser();
}

Mapper配置文件




  

编写测试类

    @Test
    public void selectUser() {
        //获取sqlSession
        SqlSession session = MybatisUtils.getSqlSession();
        //获取mapper
        UserMapper mapper = session.getMapper(UserMapper.class);

        //调用mapper定义的方法
        List userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user.toString());
        }

        session.close();
    }

2.2、 问题说明

1.Maven静态资源过滤问题

mybatis狂神(附自学过程中疑问解决)_第2张图片

若你dao包下没有xml文件说明存在maven过滤问题,这个我们只需要在pom文件加以下代码就可以解决


    
        src/main/java
        
            **/*.properties
            **/*.xml
        
        false
    
    
        src/main/resources
        
            **/*.properties
            **/*.xml
        
        false
    

2.3、 编译器问题

这里我所使用的编译工具是idea2020.2 这里可能会存在一个问题,就是每次我们修改我们的Mapper文件后,我们必须手动的clean以前的Mapper,否则我们的修改过后的Mapper无法更新,这里手动的方法如下图

mybatis狂神(附自学过程中疑问解决)_第3张图片

三、CRUD操作

3.1、 重要标签

select标签是mybatis中最常用的标签之一

select语句有很多属性可以详细配置每一条SQL语句

  • id

  • 命名空间中唯一的标识符

  • 接口中的方法名与映射文件中的SQL语句ID 一一对应

  • parameterType

  • 传入SQL语句的参数类型 。【万能的Map,可以多尝试使用】

  • resultType

  • SQL语句返回值类型。【完整的类名或者别名】

Mapper接口

//根据名称模糊查询
    List selectUsersByName(String name);

    //根据id查询用户
    User getUserById(int id);

    //新增一个用户
    int addUser(User user);

    //根据id修改用户
    int updateUser(User user);

    //根据id删除用户
    int deleteUserById(int id);

    //map 查询
    User selectUserByNP2(Map map);

Mapper.xml

   
    

    
    
        insert user(id,name,pwd) values (#{id},#{name},#{pwd})
    
    
    
        update user set name = #{name},pwd = #{pwd} where id = #{id}
    

    
    
        delete from user where id = #{id}
    



    


    

测试类

    @Test
    public void selectUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User userById = mapper.getUserById(1);
        System.out.println(userById);
    }

    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int addUser = mapper.addUser(new User(4, "张婧怡", "121223"));
        sqlSession.commit();
        System.out.println(addUser);
    }

    @Test//模糊查询
    public void selectUsersByName(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List users = mapper.selectUsersByName("%张%");
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(4);
        user.setPwd("121212");
        user.setName("帅哥");
        int i = mapper.updateUser(user);
        sqlSession.commit();
        System.out.println(i);
    }

    @Test
    public void deleteUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUserById(2);

        sqlSession.commit();
        System.out.println(i);
    }

    @Test//map查询
    public void selectUserByNP2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map map = new HashMap();
        map.put("username","狂神");
        map.put("password","123456");
        User user = mapper.selectUserByNP2(map);
        System.out.println(user);
    }

3.2、 注意事项

所有的增删改操作都需要提交事务!

接口所有的普通参数,尽量都写上@Param参数,尤其是多个参数时,必须写上!

有时候根据业务的需求,可以考虑使用map传递参数!

为了规范操作,在SQL的配置文件中,我们尽量将Parameter参数和resultType都写上!

模糊查询时记得加通配符!

四、Mybatis配置解析

4.1、核心配置文件

configuration(配置)
    properties(属性)
    settings(设置)
    typeAliases(类型别名)
    typeHandlers(类型处理器)
    objectFactory(对象工厂)
    plugins(插件)
    environments(环境配置)
        environment(环境变量)
            transactionManager(事务管理器)
            dataSource(数据源)
    databaseIdProvider(数据库厂商标识)
    mappers(映射器)

4.2、 环境配置

MyBatis 可以配置成适应多种环境

不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。

学会使用配置多套运行环境!

Mybatis默认的事务管理器就是 JDBC , 连接池 : POOLED

pooled: 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得并发 Web 应用快速响应请求的流行处理方式。

4.3、Mapper文件




  • namespace中文意思:命名空间,作用如下:

  1. namespace和子元素的id联合保证唯一 , 区别不同的mapper

  1. 绑定DAO接口

  • namespace的命名必须跟某个接口同名

  • 接口中的方法与映射文件中sql语句id应该一一对应

  1. namespace命名规则 : 包名+类名

MyBatis 的真正强大在于它的映射语句,这是它的魔力所在。由于它的异常强大,映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比,你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建,以尽可能地为你减少麻烦。

4.4、Properties优化(重点)

数据库这些属性都是可外部配置且可动态替换的,既可以在典型的 Java 属性文件中配置,亦可通过 properties 元素的子元素来传递。具体的官方文档

我们来优化我们的配置文件

第一步 ; 在资源目录下新建一个db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=123456

第二步 : 将文件导入properties 配置文件





    

    
        
    
    
    
        
            
            
                
                
                
                
            
        
    
    
        
    
    
    

4.5、typeAliases优化(重点)

类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关,存在的意义仅在于用来减少类完全限定名的冗余。



    

当这样配置时,User可以用在任何使用com.kuang.pojo.User的地方。

也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:


    

每一个在包 com.kuang.pojo 中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。

若有注解,则别名为其注解值。见下面的例子:

@Alias("user")
public class User {
    ...
}

其它配置信息了解即可,详细见官方文档

4.6、生命周期和作用域

理解我们目前已经讨论过的不同作用域和生命周期类是至关重要的,因为错误的使用会导致非常严重的并发问题。

我们可以先画一个流程图,分析一下Mybatis的执行过程!

mybatis狂神(附自学过程中疑问解决)_第4张图片

作用域理解

  • SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory,创建成功后,SqlSessionFactoryBuilder 就失去了作用,所以它只能存在于创建 SqlSessionFactory 的方法中,而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域(也就是局部方法变量)。

  • SqlSessionFactory 可以被认为是一个数据库连接池,它的作用是创建 SqlSession 接口对象。因为 MyBatis 的本质就是 Java 对数据库的操作,所以 SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中,所以一旦创建了 SqlSessionFactory,就要长期保存它,直至不再使用 MyBatis 应用,所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。

  • 由于 SqlSessionFactory 是一个对数据库的连接池,所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory,那么就存在多个数据库连接池,这样不利于对数据库资源的控制,也会导致数据库连接资源被消耗光,出现系统宕机等情况,所以尽量避免发生这样的情况。

因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例,让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。

如果说 SqlSessionFactory 相当于数据库连接池,那么 SqlSession 就相当于一个数据库连接(Connection 对象),你可以在一个事务里面执行多条 SQL,然后通过它的 commit、rollback 等方法,提交或者回滚事务。所以它应该存活在一个业务请求中,处理完整个请求后,应该关闭这条连接,让它归还给 SqlSessionFactory,否则数据库资源就很快被耗费精光,系统就会瘫痪,所以用 try…catch…finally… 语句来保证其正确关闭。

  • 所以 SqlSession 的最佳的作用域是请求或方法作用域。

简单来说 SqlSessionFactoryBuilder:

一旦创建了 SqlSessionFactory,就不再需要它了

局部变量

SqlSessionFactory:

说白了就是可以想象为 :数据库连接池

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。因此 SqlSessionFactory 的最佳作用域是应用作用域。最简单的就是使用单例模式或者静态单例模式。

SqlSession

连接到连接池的一个请求!

SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。

用完之后需要赶紧关闭,否则资源被占用!

mybatis狂神(附自学过程中疑问解决)_第5张图片

五、ResultMap

主要解决字段名和属性名不一致的问题

5.1、 问题引入

当我们的实体类与数据库命名

mybatis狂神(附自学过程中疑问解决)_第6张图片

这里的pojo中password与数据库pwd不一致

导致我们测试结果中的password为null,针对这个问题我们有两种解决方法

  1. 在sql语句中起别名

    
    
  1. 用ResultMap做结果集映射(推荐使用)



    
    
    
    


  • resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC 数据提取代码中解放出来。ResultSets

  • 实际上,在为一些比如连接的复杂语句编写映射代码的时候,一份 能够代替实现同等功能的长达数千行的代码。resultMap

  • ResultMap 的设计思想是,对于简单的语句根本不需要配置显式的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。

这里引用一句官网的话:

如果世界总是这么简单就好了。

六、日志工厂

如果一个数据库操作,出现了异常,我们需要排错。日志就是最好的助手!

曾经:sout 、debug

现在:日志工厂!

总的来说,这个日志工厂对我们日后的排错非常重要,一旦代码出错我们可以很快速和方便的发现错误!

这里我们主要介绍两种日志:标准日志和log4j

6.1、 标准日志输出

在Mybatis中具体使用那个一日志实现,在设置中设定!

STDOUT_LOGGING标准日志输出

在mybatis核心配置文件中,配置我们的日志!

    


        
    

这里如果粘贴到config中报错,可能时配置标签的顺序有问题!

测试可以看我们的控制台,输出日志

mybatis狂神(附自学过程中疑问解决)_第7张图片

6.2、log4j

  • Log4j是Apache的一个开源项目

  • 通过使用Log4j,我们可以控制日志信息输送的目的地:控制台,文本,GUI组件….

  • 我们也可以控制每一条日志的输出格式;

  • 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。

使用步骤:

  1. 导入log4j的依赖



    log4j
    log4j
    1.2.17

  1. log4j的properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
  1. 在config中配置log4j

    




        
    
  1. Log4j的使用!,直接测试运行刚才的查询

测试类

    static Logger logger = Logger.getLogger("MyTest");
    @Test
    public void selectUser() {
        logger.info("info:进入selectUser方法");
        logger.debug("debug:进入selectUser方法");
        logger.error("error: 进入selectUser方法");
        //获取sqlSession
        SqlSession session = MybatisUtils.getSqlSession();
        //获取mapper
        UserMapper mapper = session.getMapper(UserMapper.class);

        //调用mapper定义的方法
        List userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user.toString());
        }

        session.close();
    }
mybatis狂神(附自学过程中疑问解决)_第8张图片

我们在log包下的文件中有详细的日志输出,包括我们在测试类加入的日志

mybatis狂神(附自学过程中疑问解决)_第9张图片

七、分页

思考:为什么需要分页?

在学习mybatis等持久层框架的时候,会经常对数据进行增删改查操作,使用最多的是对数据库进行查询操作,如果查询大量数据的时候,我们往往使用分页进行查询,也就是每次处理小部分数据,这样对数据库压力就在可控范围内。

7.1、 使用limit分页

基本语法:

语法:SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 3;  #[0,n]

使用Mybatis实现分页,核心SQL

  1. 接口

    //分页limit
    List getUserByLimit(Map map);
  1. Mapper.xml


    
  1. 测试

    @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        HashMap map = new HashMap();
        map.put("startIndex",1);
        map.put("pageSize",2);

        List userList =  mapper.getUserByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }

7.2、 RowBounds分页

不再使用SQL实现分页

  1. 接口

    //RowBounds() 分页
    List getUserByRowBounds();
  1. Mapper.xml

    
    
  1. 测试

      @Test
    public void getUserByRowBounds(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

//RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 2);

//通过Java代码层面实现分页
        List userList = sqlSession.selectList("com.kang.dao.UserMapper.getUserByRowBounds",null,rowBounds);

        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }

7.3、 使用分页插件

mybatis狂神(附自学过程中疑问解决)_第10张图片

了解即可,可以自己尝试使用

官方文档:https://pagehelper.github.io/

八、使用注解开发

8.1、面向接口编程

- 大家之前都学过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口编程

- 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好

- 在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;

- 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

- 接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。

- 接口的本身反映了系统设计人员对系统的抽象理解。

- 接口应有两类:

- 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);

- 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);

- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

- 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法 .

- 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现 .

- 接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题.更多的体现就是对系统整体的架构

8.2、使用注解开发

  1. 注解在接口上实现

//查询全部用户
@Select("select id,name,pwd password from user")
public List getAllUser();
  1. 测试

@Test
public void testGetAllUser() {
    SqlSession session = MybatisUtils.getSession();
    //本质上利用了jvm的动态代理机制
    UserMapper mapper = session.getMapper(UserMapper.class);
●   List users = mapper.getAllUser();
    for (User user : users){
        System.out.println(user);
    }
    session.close();
}

本质上利用了jvm的动态代理机制

mybatis狂神(附自学过程中疑问解决)_第11张图片

Mybatis详细的执行流程

mybatis狂神(附自学过程中疑问解决)_第12张图片

8.3 CRUD

我们可以在工具类中设置事物自动提交

public static SqlSession  getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

编写接口,添加注解

public interface UserMapper {

    @Select("select * from user")
    List getUsers();

    // 方法存在多个参数,所有的参数前面必须加上 @Param("id")注解
    @Select("select * from user where id = #{id}")
    User getUserByID(@Param("id") int id);


    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    
    @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
    int updateUser(User user);

    
    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

8.3、关于@Param() 注解

  • 基本类型的参数或者String类型,需要加上

  • 引用类型不需要加

  • 如果只有一个基本类型的话,可以忽略,但是建议大家都加上!

  • 我们在SQL中引用的就是我们这里的 @Param() 中设定的属性名!

8.4、#{} ${} 区别

网上看到了一篇讲解#{} ${} 区别,写的非常好!!!

1.#{}是预编译处理,是占位符,${}是字符串替换,是拼接符。

2.Mybatis在处理#{}的时候会将sql中的#{}替换成?号,调用PreparedStatement来赋值

#{}将传入的数据当作一个字符串,会对传入的数据加上一个双引号。

比如,select * from student where student_name = #{studentName}

如果传入的值为xiaoming,那么解析成sql的值为student_name="xiaoming"。

3.Mybatis在处理${}的时候就是把${}替换成变量的值,调用Statement来赋值

${}将传入的数据直接显示生成在sql中;

如:select ${fieldNmae} from student where student_age = 18

传入的参数作为要查询的字段,如果传入的值为student_name,则解析成的sql为:

select student_name from student where age = 18

4. #{}方式能够很大程度上防止sql注入。

5.${}无法防止sql注入。

6.${}方式一般用于传入数据库对象,例如列表和表名。

7.由于#{}方式具有更高的安全行,所以能用#{}的地方尽量不要使用${}。

8.Mybatis排序时使用order by动态参数时需要注意,用${}而不是#{}。

原文链接:https://blog.csdn.net/weixin_50977434/article/details/127782942

以下时狂神总结的#{} ${} 区别

8.4、Lombok

简化我们实体类

使用步骤:

  1. 在idea中安装插件

mybatis狂神(附自学过程中疑问解决)_第13张图片

  1. 项目导入lombok的jar包


    org.projectlombok
    lombok
    1.18.10

  1. 在实体类上加入注解

@Data:无参构造,get、set、tostring、hashcode,equals
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString
@Getter

九、多对一

  • 多个学生,对应一个老师

  • 对于学生这边而言, 关联 .. 多个学生,关联一个老师 【多对一】

  • 对于老师而言, 集合 , 一个老师,有很多学生 【一对多】

环境搭建:

SQL:

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8


INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

测试搭建环境:

  1. 导入lombok

  1. 新建实体类 Teacher,Student

 @Data //GET,SET,ToString,有参,无参构造
 public class Teacher {
     private int id;
     private String name;
 }
 @Data
 public class Student {
     private int id;
     private String name;
     //多个学生可以是同一个老师,即多对一
     private Teacher teacher;
 }
  1. 建立Mapper接口

  1. 建立Mapper.XML文件

  1. 在核心配置文件中绑定注册我们的Mapper接口或者文件!【方式很多,随心选】

  1. 测试查询是否能够成功!

9.1、安装查询嵌套处理






    
    
    
    


当时学到这里,突然忘了property的属性是干什么的?

又从头复习了一遍,property代表了pojo里的属性名。

9.2、按照结果嵌套处理





    
    
    
        
    

回顾Mysql 多对一查询方式:

  • 子查询

  • 联表查询

这里我感觉的确是按照结果嵌套查询比较容易理解,逻辑也比较清晰。

十、一对多

比如:一个老师拥有多个学生!

对于老师而言,就是一对多的关系!

搭建环境同上

实体类

@Data
public class Student {

    private int id;
    private String name;
    private int tid;

}
@Data
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生
    private List students;
}

10.1、按照查询嵌套处理




    



10.2、按照结果嵌套处理


    
    

    
        
        
        
        
            
            
            
        
    

10.3 小结

关联-association

集合-collection

所以association是用于一对一和多对一,而collection是用于一对多的关系

JavaType和ofType都是用来指定对象类型的

  • JavaType是用来指定pojo中属性的类型

  • ofType指定的是映射到list集合属性中pojo的类型。

注意说明:

保证SQL的可读性,尽量通俗易懂

根据实际要求,尽量编写性能更高的SQL语句

注意属性名和字段不一致的问题

注意一对多和多对一 中:字段和属性对应的问题

尽量使用Log4j,通过日志来查看自己的错误

面试高频

  • Mysql引擎

  • InnoDB底层原理

  • 索引

  • 索引优化!

十一、动态SQL

11.1 介绍

什么是动态SQL:动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

官网描述:
    MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验,你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。
    虽然在以前使用动态 SQL 并非一件易事,但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的强大的动态 SQL 语言得以改进这种情形。
    动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中,有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类,现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。
    -------------------------------
    - if
    - choose (when, otherwise)
    - trim (where, set)
    - foreach
    -------------------------------

我们之前写的 SQL 语句都比较简单,如果有比较复杂的业务,我们需要写复杂的 SQL 语句,往往需要拼接,而拼接 SQL ,稍微不注意,由于引号,空格等缺失可能都会导致错误。

那么怎么去解决这个问题呢?这就要使用 mybatis 动态SQL,通过 if, choose, when, otherwise, trim, where, set, foreach等标签,可组合成非常灵活的SQL语句,从而在提高 SQL 语句的准确性的同时,也大大提高了开发人员的效率。

搭建环境:

SQL:

CREATE TABLE `blog` (
  `id` varchar(50) NOT NULL COMMENT '博客id',
  `title` varchar(100) NOT NULL COMMENT '博客标题',
  `author` varchar(30) NOT NULL COMMENT '博客作者',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8

这里在以前的框架中导入IDutil工具类

public class IDUtil {
    public static String genId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

创建一个基础工程

  1. 导包

  1. 编写配置文件

  1. 编写实体类


@Data
public class Blog {
    private int id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
    
    
}
  1. 编写实体类对应Mapper接口 和 Mapper.XML文件

  1. 插入原始数据

接口

    @Insert("insert into blog (id, title, author, create_time, views)\n" +
            "    values (#{id},#{title},#{author},#{createTime},#{views})")
    int addBlog(Blog blog);

测试类

@Test
    public void addInitBlog(){
        SqlSession session = MybatisUtils.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);
        Blog blog = new Blog();
        blog.setId(IDutil.genId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        mapper.addBlog(blog);
        blog.setId(IDutil.genId());
        blog.setTitle("Java如此简单");
        mapper.addBlog(blog);
        blog.setId(IDutil.genId());
        blog.setTitle("Spring如此简单");
        mapper.addBlog(blog);
        blog.setId(IDutil.genId());
        blog.setTitle("微服务如此简单");
        mapper.addBlog(blog);

        session.commit();
        session.close();
    }

10.2、if 语句

需求:根据作者名字和博客名字来查询博客!如果作者名字为空,那么只根据博客名字查询,反之,则根据作者名来查询

编写接口类

//需求1
List queryBlogIf(Map map);

编写SQL语句


测试

@Test
public void testQueryBlogIf(){
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    map.put("title","Mybatis如此简单");
    map.put("author","狂神说");
    List blogs = mapper.queryBlogIf(map);

    System.out.println(blogs);

    session.close();
}

这样写我们可以看到,如果 author 等于 null,那么查询语句为 select from user where title=#{title},但是如果title为空呢?那么查询语句为 select from user where and author=#{author},这是错误的 SQL 语句,如何解决呢?请看下面的 where 语句!

10.3、Where

修改上面的SQL语句;

这个“where”标签会知道如果它包含的标签中有返回值的话,它就插入一个‘where’。此外,如果标签返回的内容是以AND 或OR 开头的,则它会剔除掉。【这是我们使用的最多的案例】

10.4、Set

同理,上面的对于查询 SQL 语句包含 where 关键字,如果在进行更新操作的时候,含有 set 关键词,我们怎么处理呢?

编写接口方法

int updateBlog(Map map);

sql配置文件



    update blog
      
          
              title = #{title},
          
          
              author = #{author}
          
      
    where id = #{id};

测试

@Test
public void testUpdateBlog(){

SqlSession session = MybatisUtils.getSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);

HashMap map = new HashMap();
map.put("title","动态SQL");
map.put("author","秦疆");
map.put("id","9d6a763f5e1347cebda43e2a32687a77");

mapper.updateBlog(map);

   session.close();
}

10.5、choose语句

有时候,我们不想用到所有的查询条件,只想选择其中的一个,查询条件有一个满足即可,使用 choose 标签可以解决此类问题,类似于 Java 的 switch 语句

1. 编写接口方法

List queryBlogChoose(Map map);

sql配置文件

测试类

@Test
public void testQueryBlogChoose(){
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    map.put("title","Java如此简单");
    map.put("author","狂神说");
    map.put("views",9999);
    List blogs = mapper.queryBlogChoose(map);

    System.out.println(blogs);

    session.close();
}

10.6、SQL片段

有时候可能某个 sql 语句我们用的特别多,为了增加代码的重用性,简化代码,我们需要将这些代码抽取出来,然后使用时直接调用。

提取SQL片段:


    
        title = #{title}
    
    
        and author = #{author}
    

引用SQL片段:

注意:①、最好基于 单表来定义 sql 片段,提高片段的可重用性

   ②、在 sql 片段中不要包括 where

10.7、Foreach

将数据库中前三个数据的id修改为1,2,3;

需求:我们需要查询 blog 表中 id 分别为1,2,3的博客信息

编写接口

List queryBlogForeach(Map map);

编写SQL语句

测试

@Test
public void testQueryBlogForeach(){
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    List ids = new ArrayList();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    map.put("ids",ids);

    List blogs = mapper.queryBlogForeach(map);

    System.out.println(blogs);

    session.close();
}

小结:其实动态 sql 语句的编写往往就是一个拼接的问题,为了保证拼接准确,我们最好首先要写原生的 sql 语句出来,然后在通过 mybatis 动态sql 对照着改,防止出错。多在实践中使用才是熟练掌握它的技巧

十二、缓存

12.1、简介

什么是缓存 [ Cache ]?

  • 存在内存中的临时数据。

  • 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。

为什么使用缓存?

  • 减少和数据库的交互次数,减少系统开销,提高系统效率。

什么样的数据能使用缓存?

  • 经常查询并且不经常改变的数据。

12.2、Mybatis缓存

  • MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。

  • MyBatis系统中默认定义了两级缓存:一级缓存二级缓存

  • 默认情况下,只有一级缓存开启。(SqlSession级别的缓存,也称为本地缓存)

  • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。

  • 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

12.3、一级缓存

  • 一级缓存也叫本地缓存:

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。

  • 以后如果需要获取相同的数据,直接从缓存中拿,没必须再去查询数据库;

12.3.1、初体验测试

在mybatis中加入日志,方便测试结果

编写接口方法

//根据id查询用户
User queryUserById(@Param("id") int id);

接口对应的Mapper文件

测试

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);
    User user2 = mapper.queryUserById(1);
    System.out.println(user2);
    System.out.println(user==user2);

    session.close();
}

结果分析

mybatis狂神(附自学过程中疑问解决)_第14张图片

12.3.2、一级缓存失效的四种情况

一级缓存是SqlSession级别的缓存,是一直开启的,我们关闭不了它;

一级缓存失效情况:没有使用到当前的一级缓存,效果就是,还需要再向数据库中发起一次查询请求!

sqlSession不同

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    SqlSession session2 = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    UserMapper mapper2 = session2.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);
    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    System.out.println(user==user2);

    session.close();
    session2.close();
}

观察结果:发现发送了两条SQL语句!

结论:每个sqlSession中的缓存相互独立

sqlSession相同,查询条件不同

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    UserMapper mapper2 = session.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);
    User user2 = mapper2.queryUserById(2);
    System.out.println(user2);
    System.out.println(user==user2);

    session.close();
}

观察结果:发现发送了两条SQL语句!很正常的理解

结论:当前缓存中,不存在这个数据

sqlSession相同,两次查询之间执行了增删改操作!

增加方法

//修改用户
int updateUser(Map map);

编写SQL


    update user set name = #{name} where id = #{id}

测试

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);

    HashMap map = new HashMap();
    map.put("name","kuangshen");
    map.put("id",4);
    mapper.updateUser(map);

    User user2 = mapper.queryUserById(1);
    System.out.println(user2);

    System.out.println(user==user2);

    session.close();
}

观察结果:查询在中间执行了增删改操作后,重新执行了

结论:因为增删改操作可能会对当前数据产生影响

sqlSession相同,手动清除一级缓存

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);

    session.clearCache();//手动清除缓存

    User user2 = mapper.queryUserById(1);
    System.out.println(user2);

    System.out.println(user==user2);

    session.close();
}

一级缓存就是一个map

11.4、二级缓存

  • 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存

  • 基于namespace级别的缓存,一个名称空间,对应一个二级缓存;

  • 工作机制

  • 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;

  • 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中;

  • 新的会话查询信息,就可以从二级缓存中获取内容;

  • 不同的mapper查出的数据会放在自己对应的缓存(map)中;

11.4.1、使用步骤

官方文档

开启全局缓存 【mybatis-config.xml】

去每个mapper.xml中配置使用二级缓存,这个配置非常简单;【xxxMapper.xml】

官方示例=====>查看官方文档

这个更高级的配置创建了一个 FIFO 缓存,每隔 60 秒刷新,最多可以存储结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此对它们进行修改可能会在不同线程中的调用者产生冲突。

代码测试

所有的实体类先实现序列化接口

测试代码

@Test
public void testQueryUserById(){
    SqlSession session = MybatisUtils.getSession();
    SqlSession session2 = MybatisUtils.getSession();

    UserMapper mapper = session.getMapper(UserMapper.class);
    UserMapper mapper2 = session2.getMapper(UserMapper.class);

    User user = mapper.queryUserById(1);
    System.out.println(user);
    session.close();

    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    System.out.println(user==user2);

    session2.close();
}

11.4.2、结论

  • 只要开启了二级缓存,我们在同一个Mapper中的查询,可以在二级缓存中拿到数据

  • 查出的数据都会被默认先放在一级缓存中

  • 只有会话提交或者关闭以后,一级缓存中的数据才会转到二级缓存中

11.5、缓存原理

mybatis狂神(附自学过程中疑问解决)_第15张图片

11.6、EhCache

第三方缓存实现—EhCache: 查看百度百科

官方文档

Ehcache是一种广泛使用的java分布式缓存,用于通用缓存;

要在应用程序中使用Ehcache,需要引入依赖的jar包



    org.mybatis.caches
    mybatis-ehcache
    1.1.0

在mapper.xml中使用对应的缓存即可

 
     

编写ehcache.xml文件,如果在加载时未找到/ehcache.xml资源或出现问题,则将使用默认配置。



    
    

    

    
    
    

你可能感兴趣的:(mybatis,java,mysql)