Mybatis
 2022-01-31   35 分钟   5.2 k0次访问

Mybatis

Mybatis

环境：

  • Jdk1.8
  • Mysql 5.7
  • Maven 3.6.1

  • idea

    简介

  • MyBatis 是一款优秀的持久层框架

  • 它支持自定义 SQL、存储过程以及高级映射
  • MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
  • MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录
maven仓库
1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <arti factId>mybatis</artifactId>
  <version>3.4.6</version>
</dependency>

持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程

持久层

  • 完成持久化工作的代码块
  • 层界限十分明显

为什么需要Mybatis

  • 帮助程序猿将数据存入到数据库
  • 方便
  • 传统的jdbc代码太复杂了。简化。框架。自动化。

第一个Mybatis程序

思路：搭建环境—>导入Mybatis—>编写代码—>测试

搭建环境

搭建数据库

搭建数据库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user` (
	`id` INT(20) NOT NULL PRIMARY KEY,
	`name` VARCHAR(30) DEFAULT NULL,
	`pwd` VARCHAR(30) DEFAULT NULL
) ENGINE= INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`id`, `name`, `pwd`)VALUES
(1,'lvjie','123456'),
(2, '张三', '123456'),
(3, '李四', '123890')

新建maven项目，导入maven依赖

导入maven依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!--导入依赖-->
<dependencies>
  <!--mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
  </dependency>
  <!--mybatis--> 
  <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
  </dependency>
  <!--junit-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
  </dependency>
</dependencies>

创建一个模块

  • 编写mybatis的核心配置文件 在resources目录下

    Mybatis核心配置文件
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    <?xml version="1.O" encoding="UTF-8"?>
    <!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <!--configuration核心配置文件-->
    <configuration>
      <environments defau1t=" devel opment">
        <environment id="development">
        <transactionManager type="JDBC" />
        <dataSource type="POOLED" >
          <property name="driver" value="com.mysql.jdbc.Driver"/>
          <property name="ur1" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUni code=true&amp;characterEncoding=UTF-8"/>
          <property name="username" value="root"/>
          <property name="password" value="123456"/>
        </dataSource>
        </environment>
      </environments>
      
      <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册! -->
      <mappers>
    		<!--resource路径必须是斜杠，不是点-->
        <mapper resource= "com/lvjie/dao/UserMapper.xml"/>
        </mappers>
    </configuration>

  • 编写mybatis工具类 MybatisUtils.java

    SqlSession相当于preparestatement，执行sql语句，SqlSession需要通过工厂创建

    MybatisUtils.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //sqLSessionFactory --> sqlSession
    public class MybatisUtils {
      
    	private static SqlSessionFactory sqlSessionFactory;
    	
      static{
    		try {
    			//使用Mybatis第-步:获取sqlSessionFactory对象
    			String resource = "mybatis-config.xml";
    			InputStream inputStream = Resources.getResourceAsStream( resource);
    			sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch ( IOException e) {
    				e.printStackTrace();
        }
      }
      
    	// 既然有了SqlSessionFactory, 顾名思义，我们就可以从中获得SqlSession的实例了。
    	// SqlSession 完全包含了面向数据库执行SQL命令所需的所有方法。
    	public static SqlSession getSqlSession(){
    		return sqlSessionFactory.openSession();
      }
    }

    编写代码

    实体类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    public class User {

        private int id;
        private String name;
        private String pwd;

        public User() {
        }
        
        public User(int id, String name, String pwd) {
            this.id = id;
            this.name = name;
            this.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;
        }

        @java.lang.Override
        public java.lang.String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", pwd='" + pwd + '\'' +
                    '}';
        } 
    }
    Dao接口
    1
    2
    3
    public interface UserDao {
        List<User> getUerList();
    }

    接口实现类由原来的UserDaoImpl转变为一个Mapper配置文件

    Mapper配置文件
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <?xml version="1.0" encoding-"UTF-8"?>
    	<!DOCTYPE mapper
    			PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <!--namespace=绑定一个对应的Dao/Mapper接口-->
    <mapper namespace="com.lvjie.dao.UserDao">
    <!--select査詢語句-->
    <select id-"getUserList" resu1tType-"com.lvjie.pojo.User">
    		select * from mybatis.user
    </select>
    </mapper>

测试

核心配置文件中注册mappers

junit测试

test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class UserDaoTest{
	@Test
	public void test(){
    //第一步:获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //方式一: getMapper
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUserList();
    for (User user : userList) {
     System.out.println(user);
    }
    //关闭SqlSession
    sqlSession.close();
  }
}

添加maven依赖防止配置无法加载

maven
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- #buіld #rіс. rеѕоurсеѕ, ЖjL:#іІ]В-іі #Ш#УÉJjF]/f-->
<build>
  <resources>
    <resource>
    <directory>src/ main/ resources</directory>
    <includes>
      <include>**/*.properties</include>
      <include>**/*.xml</include>
    </includes>
    <filtering>true</filtering>
    </resource>
    <resource>
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.properties</include>
        <include>**/*.xml</ include>
      </includes>
      <filtering>true</filtering>
    </resource>
  </resources>
</build>

CRUD

namespace

namespace中的包名要和 Dao/mapper 接口的包名一致!

Select

选择，查询语句; .
●id: 就是对应的namespace中的方法名;
●resultType: Sq|语句执行的返回值!
●parameterType :参数类型!

  1. 编写接口UserMapper

    UserMapper接口
    1
    2
    3
    4
    5
    //查询全部用户
    List<User> getUserList();

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

  2. 编写对应的mapper中的sql语句

    UserMapper.xml
    1
    2
    3
    4
    5
    6
    7
    8
    <!--查询全部用户-->
    <select id="getUserList" resultType="com.lvjie.pojo.User">
    	select * from mybatis.user
    </select>
    <!--根据id查询用户-->
    <select id="getUserById" resultType="com.lvjie.pojo.User" parameterType="int">
    	select * from mybatis.user where id = #{id}
    </select>

  3. 测试

    test
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    @test
    public void getUserById() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
    	UserMapper mapper = sql.Session.getMapper(UserMapper.class);
      
      List<User> userList = mapper.getUserList();
      for (User user : userList) {
        System.out.println(user)
      }
      
      sqlSession.close();
    }


    @test
    public void getUserById() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      UserMapper mapper = sql.Session.getMapper(UserMapper.class);
      
      User user = mappper.getUserById(1);
      System.out.println(user);
      
      sqlSession.close();
    }

Insert

  1. 编写接口UserMapper

    UserMapper接口
    1
    2
    //增加一个用户
    int addUser(User user);

  2. 编写对应的mapper中的sql语句

    UserMapper.xml
    1
    2
    3
    <insert id="addUser" parameterType="com.lvjie.pojo.User" >
    	insert into mybatis.user (id, name, pwd) values (#{id}, #{name}, #{pwd});
    </insert>

  3. 测试

    test
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @test
    public void addUser() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      UserMapper mapper = sql.Session.getMapper(UserMapper.class);
      
      mappper.addUser(new User(4, "lvjie", "111111"));
      
      //增删改需要提交事务
      sqlSession.commit();
      
      sqlSession.close();
    }

Update

  1. 编写接口UserMapper

    UserMapper接口
    1
    2
    //修改用户
    int updateUser(User user);

  2. 编写对应的mapper中的sql语句

    UserMapper.xml
    1
    2
    3
    <update id="updateUser" parameterType="com.lvjie.pojo.User">
    	update mybatis.user set name = #{name}, pwd = #{pwd} where id = #{id};
    </update>

  3. 测试

    test
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @test
    public void updateUser() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      UserMapper mapper = sql.Session.getMapper(UserMapper.class);
      
      mappper.updateUser(new User(4, "lvjie", "123456"));
      
      //增删改需要提交事务
      sqlSession.commit();
      
      sqlSession.close();
    }

Delete

  1. 编写接口UserMapper

    UserMapper接口
    1
    2
    //删除一个用户
    int deleteUser(int id);

  2. 编写对应的mapper中的sql语句

    UserMapper.xml
    1
    2
    3
    <delete id="deleteUser" parameterType="int">
    	delete from mybatis.user where id = #{id};
    </delete>

  3. 测试

    test
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @test
    public void deleteUser() {
      SqlSession sqlSession = MybatisUtils.getSqlSession();
      UserMapper mapper = sql.Session.getMapper(UserMapper.class);
      
      mappper.deleteUser(4);
      
      //增删改需要提交事务
      sqlSession.commit();
      
      sqlSession.close();
    }

万能Map

假设我们的实体类或数据库中的表，字段或者参数过多，我们应当考虑使用Map！

UserMapper接口
1
2
// 万能的map
int addUser2(Map<String, Object> map);
UserMapper.xml
1
2
3
4
<!--对象中的属性，可以直接取出来，传递map的key-->
<insert id="addUser" parameterType="map">
	insert into mybatis.user(id, pwd) values (#{userid}, #{password});
</insert>
test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@test
public void addUser2() {
  SqlSession sqlSession = MybatisUtils.getSqlSession();
  
  UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
  map.put("userid", 5);
  map.put("password", "22222");
  map.addUser(map);
  
	//增删改需要提交事务
  sqlSession.commit();
  
  sqlSession.close();
}

Map传递参数，直接在sql中去除key即可

对象传递参数，直接在sql中取对象的属性即可

多个参数用map，或者注解。

模糊查询

在sql中陪你姐中使用通配符

1
select * from mybatis.user where name like "%"#{value}"%"

配置解析

核心配置文件

  • mybatis-config.xml

  • MyBatis 的配置文件包含了会深深影呵MyBatis行为的设置和属性信息。

    配置文件
    1
    2
    3
    4
    5
    6
    7
    8
    configuration (配置) 
    properties (属性)
    settings (没置)
    typeAliases (炎型別名)
    environments (坏境配置)
    environment (坏境変量)
    transactionManager (事努管理器)
    mappers (映射器)

环境配置（environments)

Mybatis默认的事务管理器是JDBC，连接池：POOLED

属性（Properties）

我们可以通过properties属性来实现引用配置文件
编写一个配置文件

db.properties
1
2
3
4
driver=com.mysql.jdbc.Driver
ur1=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

在核心配置文件中引入

配置文件
1
2
3
4
<!--引入配置文件-->
<properties resource="db.properties">
<!-- <property name="username" value="root"/> -->
</properties>

可以直接引用外部文件，如果两个文件由同一个字段，有先使用外部配置文件的。

类型别名(typeAliases)

  • 类型别名是为Java类型设置一个短的名字。

  • 存在的意义仅在于用来减少类完全限定名的冗余。

    typeAlias
    1
    2
    3
    4
    <!--可以给实体类起别名-->
    <typeAliases>
    	<typeAlias type="com.lvjie.pojo.User" alias="User"/>
    </typeAliases>

    也可以指定一个包名， MyBatis 会在包名下面搜索需要的Java Bean，比如:
    扫描实体类的包，它的默认别名就为这个类的类名的首字母小写!

    typeAlias
    1
    2
    3
    4
    <!--可以给实体类起别名-->
    <typeAliases>
    	<package name="com.lvjie.pojo"/>
    </typeAliases>

    在实体类比较少的时候，使用第一种方式
    如果实体类十分多，建议使用第二种。
    第一中可以DIY别名，第二种则不行，如果非要改，需要在实体上增加注解

    注解
    1
    2
    @Alias("user")
    public class User {}

映射器（mapper)

MapperRegitry:注册绑定我们的Mapper文件;
方式一：【推荐使用】

Mapper.XML
1
2
3
4
<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
	<mapper resource="com/lvjie/dao/userMapper.xml"/>
</mappers>

方式二: 使用Class文件绑定注册

Mapper.XML
1
2
3
4
<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
	<mapper class="com.lvjie.dao.userMapper"/>
</mappers>

注意点:

  • 接口和他的Mapper配置文件必须同名!
  • 接口和他的Mapper配置文件必须在同一个包下!

方式三:使用扫描包进行注入绑定

Mapper.XML
1
2
3
4
<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册! -->
<mappers>
	<package name="com.lvjie.dao"/>
</mappers>

注意点:

  • 接口和他的Mapper配置文件必须同名!
  • 接口和他的Mapper配置文件必须在同一个包下!

生命周期和作用域

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqISessionFactoryBuilder:（建造工厂）

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

SqlSessionFactory:（工厂）

  • 说白了就是可以想象为:数据库连接池
  • SqISessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
  • 因此SqlSessionFactory的最佳作用域是应用作用域。
  • 最简单的就是使用单例模式或者静态单例模式。

SqlSession（一个请求）

  • 连接到连接池的一个请求!
  • SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
  • 用完之后需要赶紧关闭，否则资源被占用!


这里面每一个Mapper，就代表一个具体的业务。

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

当数据库中的字段和我们的实体类字段不一致时会出现结果不能正确显示，比如

实体类
1
2
3
4
5
public class User {
  private int id;
  private String name;
  private String password;
}

解决方法：

  • 起别名

    1
    2
    3
    <select id="getUserById" resultType="com.lvjie.pojo.User">
    	select id,name,pwd as password from mybatis.user where id = #{id}
    </select>

  • 结果集映射 resultMap

    1
    2
    3
    4
    5
    6
    7
    8
    <!--结果集映射-->
    <resultMap id="UserMap" type="User">
      <!--column数据库中的字段，property实体类中的属性-->
      <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserById" resultMap="UserMap">
    	select * from mybatis.user where id = #{id}
    </select>

日志

日志工厂

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

在Mybatis核心配置文件中配置我们的日志。

STDOUT_LOGGING标准日志输出

STDOUT_LOGGING
1
2
3
<settings>
	<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

Log4j

什么是Log4j?

  • Log4j是Apache的一个开源项目,通过使用Log4j, 我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。
  • 我们也可以控制每-条日志的输出格式;
  • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
  • 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

  1. 先导入log4j的包

    maven
    1
    2
    3
    4
    5
    6
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</ groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

  2. Log4j.properties

    Log4j.properties
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #将等级为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/lvjie.log
    lpg4j.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

  3. 配置log4j为日志的实现

    1
    2
    3
    <settings>
    	<setting name="logImpl" value="LOG4J"/>
    </settings>

  4. 简单使用

    • 在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

    • 日志对象，参数为当前类的class

      1
      static Logger logger = Logger.getLogger(UserDaoTest.class);

使用Limit分页

1
2
# 语法 select * from user limit startIndex,pageSize;
select * from user limit 3,5;

使用Mybatis实现分页

  1. 接口

    接口
    1
    2
    //分页
    List<User> getUserByLimit(Map<String,Integer> map);

  2. Mapper.xml

    Mapper.xml
    1
    2
    3
    4
    <!--分页--> 
    <select id="getuserByLimit" parameterType="map" resu1tMap="userMap ">
    	select * from mybatis.user limit #{startIndex}, #{pagesize}
    </select>

  3. 测试

    test
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Test
    public void getUserByLimit() {
        sqlsession sqlsession = MybatisUtils.getsqlsession();
        UserMapper mapper = sqlsession.getMapper(userMapper.class);
        HashMap<String, Integer> map = new HashMap<string, Integer>();
        map.put("startIndex", 1); 
        map.put("pageSize", 2);
        List<User> userList = mapper.getUserByLimit(map);
        for (User user : userList) {
        System.out.println(user);
      }
    	sqlsession.close();
    }

注解

使用注解开发

  1. 注解在接口上实现

    接口
    1
    2
    @Select("select * from user")
    List<User> getUsers();

  2. 需要在核心配置文件中绑定接口!

    核心配置文件
    1
    2
    3
    4
    <!--绑定接口-->
    <mappers>
    	<mapper class="com.lvjie.dao.UserMapper"/>
    </mappers>

    本质: 反射机制实现
    底层: 动态代理

CRUD

我们可以在工具类创建的时候实现自动提交事务!

1
2
3
public static SqlSession getsqlSession(){
	return sqlSessionFactory.openSession(true);
}

编写接口，增加注解

UserMapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public interface UserMapper {
	
  @Select("select * from user")
	List<User> getUsers();
	
  //方法存在多个基本类型参数或String类型，所有的参数前而必须加上@Param( "id")注解
	@Select("select * from user where id = #{id}" )
	User getUserById(@Param("id") int id);
	
  //方法存在引用类型参数，不用加Param()注解
  @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);
  
	//在SQL中引用的是我在@Param()中设定的属性名
  @Delete("delete from user where id = #{uid}")
	int deleteUser(@Param("uid") int id);
}

Lombok

使用步骤:
1.在IDEA中安装Lombok插件!
2.在项目中导入lombok的jar包

maven
1
2
3
4
5
<dependency>
  <groupId>org.projectlombok </groupId>
  <artifactId>lombok </artifactId>
  <version>1.18.10</version>
</dependency>

3.在实体类上加注解即可!

注解类型
1
2
3
4
5
6
@Data //get和set和toString方法，不包括有参和无参构造方法
@Al1ArgsConstructor //有参构造方法
@NoArgsConstructo //无参构造方法
@ToString //toString方法
@Getter //get方法
@Setter //set方法

多对一处理

一个老师对应多个学生

实体类

实体类
1
2
3
4
5
6
7
@Data
public class Student {
  private int id;
  private String name;
  //学生需要关联一个老师
  private Teacher teacher;
}
实体类
1
2
3
4
5
@Data
public class Teacher {
  private int id;
  private String name;
}

SQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
ECREATE 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, 'lvjie') ;

ECREATE 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

  2. 新建实体类Teacher, Student

  1. 建立Mapper接口

  2. 建立Mapper.XML文件

  3. 在核心配置文件中绑定注册我们的Mapper接口或者文件! [方式很多， 随心选]

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

按照结果嵌套处理（联表查询）

联表查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--按照结果嵌套处理-->
<select id=" getStudent2" resultMap=" StudentTeacher2" >
  select s.id sid, s.name sname, t.name tname
  from student s, teacher t
  where s.tid = t.id;
</select>

<resultMap id="StudentTeacher" type="Student">
  <result property="id" column="sid"/>
  <result property="name" column="sname"/>
  <association property="teacher" javaType="Teacher">
  	<result property="name" column="tname"/>
  </association>
</resultMap>

按照查询嵌套处理（子查询）

子查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!--
思路:
	1.查询所有的学生信息
	2.根据查询出来的学生的tid, 寻找对应的老师!
-->

<select id="getStudent" resultMap="StudentTeacher">
	select * from student
</select>
<resultMap id="StudentTeacher" type="Student" >
  <result property="id" column="id"/>
  <result property- "name" column="name" />
  <!--
  复杂的属性，我们需要单独处理  association 对象 collection 集合
  -->
  <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="Teacher" >
	select * from teacher where id = #{id}
</select>

一对多处理

一个老师拥有多个学生
1.环境搭建，和刚才一样
实体类

实体类
1
2
3
4
5
6
7
@Data
public class Student {

  private int id;
  private String name;
  private int tid;
}
实体类
1
2
3
4
5
6
7
8
@Data
public class Teacher {
  private int id;
  private String name;
  
  //一个老师拥有多个学生
  private List<student> students;
}

按照结果嵌套处理（联表查询）

联表查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!--按结果嵌套查询-->
<select id="getTeacher" resultMap-"TeacherStudent">
  select s.id sid, s.name sname, t.name tname, t.id tid
  from student s, teacher t
  where s.tid = t.id and t.id = #{tid}
</select>

<resultMap id=" TeacherStudent" type="Teacher">
  <result property="id" column="tid"/>
  <result property="name" column="tname"/>
  <!--复杂的属性，我们需要单独处理 对象: association 集合: collection
  javaType 指定属性的类型!
  集合中的泛型信息，我们使用ofType 获取
  -->
  <collection property= " students" ofType="Student">
    <result property="id" column="sid"/>
    <result property= "name" column="sname"/>
    <result property="tid" column="tid"/>
  </collection>
</resultMap>

按照查询嵌套处理（子查询）

子查询
1
2
3
4
5
6
7
8
9
<select id="getTeacher" resultMap="TeacherStudent">
	select * from mybatis.teacher where id = #{tid}
</select>
<resultMap id="TeacherStudent" type="Teacher">
	<collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
	select * from mybatis.student where tid = #{tid}
</select>

小结

  1. 关联 - association [多对一 ]
  2. 集合 - collection [一对多]
  3. javaType & ofType
    • JavaType用来指定实体类中属性的类型
    • ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型!

动态SQL

动态SQL就是根据不同的条件生成不同的SQL语句。所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面去执行一个逻辑代码。动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了。

搭建环境

1
2
3
4
5
6
7
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

创建一个基础工程

  1. 导包

  2. 编写配置文件

  3. 编写实体类

    实体类
    1
    2
    3
    4
    5
    6
    7
    8
    @Data
    public class Blog {
      private int id;
      private String title;
      private String author;
      private Date createTime;
      private int views;
    }

  4. 编写实体类对应Mapper接口和Mapper.xml文件

IF

Mapper.xml
1
2
3
4
5
6
7
8
9
<select id="queryBlogIF" parameterType="map" resultType="blog">
	select from mybatis.blog where 1=1
  <if test="title != null">
    and title = #{title}
  </if>
  <if test="author != null">
  	and author = #{author} 
  </if>
</select>

Where

Mapper.xml
1
2
3
4
5
6
7
8
9
10
11
<select id="queryBlogWhere" parameterType="map" resultType="blog">
  select * from mybatis.blog 
  <where>
    <if test="title != null">
      title = #{title}
    </if>
    <if test="author != null">
      and author = #{author}
    </if>
  </where>
</select>

Choose

Mapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<select id-"queryBlogChoose" parameterType="map" resultType="blog">
  select * from mybatis.blog
  <where>
    <choose>
      <when test="title != null">
      	title = #{title}
      </when>
      <when test="author != null">
      	and author = #{author}
      </when>
      <otherwise>
      	and views = #{views}
      </otherwise>
    </choose>
  </where>
</select>

Set

Mapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
<update id="updateBlog" parameterType="map">
  update mybatis.blog
  <set>
    <if test="title != null">
    	title = #{title},
    </if>
    <if test "author != null">
    	author = #{author}
    </if>
  </set>
  where id = #{id} 
</update>

SQL片段

有的时候，我们可能会将一些功能的一部分抽取出来，方便复用。

  1. 使用SQL标签抽取公共的部分

    Mapper.xml
    1
    2
    3
    4
    5
    6
    7
    8
    <sql id="if-title-author">
      <if test="title != null">
      	title = #{title}
      </if>
      <if test="author != null">
      	and author = #{author}
      </if>
    </sql>

    注意事项

    • 最好基于单表来定义SQL片段
    • 不要存在where标签

  2. 在需要使用的地方使用Include标签引用即可

    Mapper.xml
    1
    2
    3
    4
    5
    6
    <select id="queryBlogIF" parameterType="map" resultType="blog">
      select * from mybatis.blog
      <where>
      	<include refid "if-title-author"></include>
      </where>
    </select>

Foreach

Mapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
<!--
	select * from mybatis.blog where 1=1 and (id=1 or id=2 or id=3)
	我们现在传递一个万能的map，这map中可以存在一个集合!
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
	select * from mybatis.blog
  <where>
    <foreach collection="ids" item="id" open="and (" close=")" separator="or">
    id = #{id}
    </foreach>
  </where>
</select>

缓存

简介

  1. 什么是缓存[ Cache ]?
    • 存在内存中的临时数据。
    • 将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
  2. 为什么使用缓存?
    • 减少和数据库的交互次数，减少系统开销，提高系统效率。
  3. 什么样的数据能使用缓存?
    • 经常查询并且不经常改变的数据。

Mybatis缓存

  • MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
  • MyBatis系统中默认定义了两级缓存: 一级缓存和二级缓存
    • 默认情况下，只有一级缓存开启。(SqISession级别的缓存， 也称为本地缓存)
    • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
    • 为了提高扩展性，MyBatis定义了缓存接口Cache. 我们可以通过实现Cache接口来自定义二级缓存

一级缓存

  • 一级缓存也叫本地缓存: SqlSession
    • 与数据库同-次会话期间查询到的数据会放在本地缓存中。
    • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库;

缓存失效的情况:

  1. 查询不同的东西

  2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存!

  3. 查询不同的Mapper.xml

  4. 手动清理缓存!

    1
    sqlSession.clearCache();//手动清理缓存

小结：
一级缓存默认是开启的，只在一次SqISession中有效， 也就是拿到连接到关闭连接这个区间段!
一级缓存就是一个Map。

二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
  • 基于namespace级别的缓存，一个名称空间，对应一个二级缓存;
  • 工作机制
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中;
    • 新的会话查询信息，就可以从二级缓存中获取内容;
    • 不同的mapper查出的数据会放在自己对应的缓存(map) 中;

步骤:

  1. 开启全局缓存

    Mapper.xml
    1
    2
    <!--显示的开启全局缓存-->
    <setting name="cacheEnabled" value="true"/>

  2. 在要使用二级缓存的Mapper中开启

    Mapper.xml
    1
    2
    <!--在当前Mapper.xml中使用二级缓存-->
    <cache/>

    也可以自定义参数

    Mapper.xml
    1
    2
    3
    4
    5
    <!--在当前Mapper.xml中使用二级缓存-->
    <cache eviction="FIFO"
          flushInterval="60000"
          size="512"
          readonly="true"/>

小结:

  • 只要开启了二级缓存，在同一个Mapper下就有效
  • 所有的数据都会先放在一级缓存中
  • 只有当会话提交，或者关闭的时候，才会提交到二级缓冲中

Mybatis

作者

lvjie

发布于

2022-01-31

许可协议

# 相关文章
  1.文件上传和下载
  2.请求拦截器和响应拦截器
  3.Spring
# 推荐文章
  1.absolute和relative定位
  2.display:table-cell在布局上的应用
  3.两列布局css
  4.解决GitHub访问不了问题
  5.Collection集合和Map集合
  6.JDK，JRE和JVM

喜欢这篇文章？打赏一下作者吧

关注我

:D 一言句子获取中...

链接

最新文章

分类

归档

标签

二叉树2
泰勒公式2
ADB1
B+树1
BootLoader1
B树1
Collection1
Fastboot1
JDK1
JRE1
JVM1
KMP1
LeetCode1
List1
Map1
Mybatis1
NAT1
PageHelper1
RAM1
ROM1
查看全部>>

订阅更新

×