MyBatis_学习笔记汇总

阅读需要20分钟

一、MyBatis的开始

从官方文档开始

MyBatis是什么

  • 持久层框架
  • 支持定制化 SQL、存储过程以及高级映射
  • 避免几乎所有的JDBC代码和手动设置参数以及获得结果集
  • 可以使用简单的xml或者注释来配置和映射原生类型、接口和Java的pojo(Plain Old Java Object,普通老式Java对象)为数据库中的记录。

MyBatis的Maven配置

        
        
        
            org.mybatis
            mybatis
            3.5.6
        

持久化

  • 程序数据在持久状态和瞬时状态转化的过程
  • 内存特点:断电即失
  • 数据库、io文件实现数据持久化

持久层

  • 完成持久化工作的代码块

MyBatis的优点

  • 对数据库进行增删改查
  • 简单、灵活
  • sql和代码的分离,提高可维护性
  • 提供映射标签,支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签,支持对象关系组建维护
  • 提供xml标签,支持编写动态sql

第一个MyBatis程序

1. 配置pom.xml

  • 父工程
  1. 在一个maven项目中创建一个model
  2. 导入依赖,子工程也可以使用这些依赖,而不用在子工程的xml中再次导入依赖

    com.vigil
    Mybatis_Study
    pom
    1.0-SNAPSHOT
    
    
        mybatis-01
    

    
    
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
        
        
            org.mybatis
            mybatis
            3.5.6
        
        
        
            junit
            junit
            4.12
        
    

error:资源导出问题

  • 处理方式:在项目配置文件中加入下面的代码
 
    
        
            
                src/main/java
                
                    **/*.xml
                    **/*.properties
                
            

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

2. 子工程项目配置

  • 这里使用默认生成的就行

        Mybatis_Study
        com.vigil
        1.0-SNAPSHOT
    
    4.0.0

    mybatis-01

3. 数据库

  • 用于查询的简单数据库
create table user
(
    id   int(20)     not null comment 'id'
        primary key,
    name varchar(20) not null comment 'name',
    pwd  varchar(20) not null comment 'password'
)
    charset = utf8;
  • idea连接数据库

4. 编写对应数据库的JavaBean:User类

5. 编写MyBatis的配置文件

XML 配置文件中包含了对 MyBatis 系统的核心设置,包括获取数据库连接实例的数据源(DataSource):需要对应自己的数据库进行配置
以及决定事务作用域和控制方式的事务管理器(TransactionManager)。




    
        
            
            
                
                
                
                
            
        
    

    
    
        
    


6. 编写获得数据库连接的工具类

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

package com.vigil.util;

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;

//SqlSessionFactory  --->  SqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //获取SqlSessionFactory对象
            // 要先获得SqlSessionFactoryBuilder对象,在数据库资源文件中获得
//从 XML 文件中构建 SqlSessionFactory 的实例非常简单,建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流(InputStream)实例,比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类,它包含一些实用方法,使得从类路径或其它位置加载资源文件更加容易。
            String resource = "mybatis-config.xml";
            InputStream inputStream =  Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了 SqlSessionFactory,顾名思义,我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

7. 编写Mapper接口(对应javaweb的dao接口,操作数据库)

public interface UserDao {
    List getUserList();
}

8. 编写Mapper的对应xml文件

类似javaweb里面的DaoImpl类
需要注意的是:
1、namespace(命名空间)=绑定一个对应的Dao\Mapper接口名:com.vigil.dao.UserDao
2、重写方法 --> select查询语句,id对应mapper中方法名字,resultType对应返回类型
全限定名:映射-->com.vigil.dao.UserDao.getUserList






    
    
    

9. 注册mapper.xml(尤其重要)

每一个Mapper.xml文件都需要到mybatis的配置文件下注册

    
    
        
    

10. 测试Mapper

package com.vigil.dao;

import com.vigil.pojo.User;
import com.vigil.util.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoText {
    @Test
    public void text() {
        // 获得SqlSession对象,从而执行sql语句
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 执行sql
        //方式一:getMapper
        // userDao是在web时对数据层操作的一个叫法,Data Access Object数据库访问对象
        // 而在Mybatis中则叫mapper,通过类名得到这个类的一个实例,反射和多态性
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List userList = userDao.getUserList();

        //方式二,方法后不用加括号,
        // 对于结果的返回是要确切知道方法的返回类型,然后需要选择对应的sqlsession方法并且进行强制转换
        // List userList = sqlSession.selectList("com.vigil.dao.UserDao.getUserList");

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

        //关闭SqlSession
        sqlSession.close();
    }
}

方式一(优先选择):在对应的映射器接口调用方法。
命名就可以直接映射到在命名空间中同名的映射器类,并将已映射的 select 语句匹配到对应名称、参数和返回类型的方法。

UserDao userDao = sqlSession.getMapper(UserDao.class);
List userList = userDao.getUserList();

方式二:用全限定名 “com.vigil.dao.UserDao.getUserList” 来调用映射语句,风险在于:对于结果的返回是要确切知道方法的返回类型,然后需要选择对应的sqlsession方法并且进行强制转换

List userList = sqlSession.selectList("com.vigil.dao.UserDao.getUserList");

mapper.xml的注意项:

  1. id:对应命名空间的接口的方法名
  2. resultType:sql语句执行的返回值类型
  3. parameterType:传入方法中参数的类型
  4. 对象中的属性,可以直接根据变量名取出来
  5. 标签名和sql语句要一一匹配,是select的sql语句就对应select标签,是update的sql语句就对应update标签
  6. mybatis配置文件中注册时,mapper标签对应的 resource 标签要使用mapper的相对类路径(com/vigil/dao/UserMapper.xml)注意是用的" / "
  7. 取值符号:#{},括号内填写变量名
  8. 参数取出关联着设置

(1)Map传递参数,直接在sql中取出key即可!【parameterType="Map"】
(2)对象传递参数,直接在sql中取对象的属性即可!【parameterType="Object"】
(3)只有一个基本参数的情况下,可以直接在sql中取到【可以不写】
(4)多个参数建议用Map,或者是注解

CRUD

1. namespace(命名空间)

命名空间的作用有两个,一个是利用更长的全限定名来将不同的语句隔离开来,同时也实现了你上面见到的接口绑定

  • 全限定名(比如 "com.vigil.dao.UserDao.getUserList")将被直接用于查找及使用。

编写步骤

  1. 编写接口
  2. 编写对应的mapper中的sql语句
  3. 测试:增删改需要提交事务

2. select

  • interface
    //根据id查询用户
    User getUserById(int id);
  • mapper.xml
    
  • test
    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.getUserById(1);

        System.out.println(user.toString());

        sqlSession.close();
    }

3. Insert

  • interface
    //插入一个新用户
    int addUser(User user);
  • mapper.xml
    
    
        insert into mybatis.user (id, name, pwd) values (#{id},#{name},#{pwd})
    
  • test
    @Test
    public void addUser() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.addUser(new User(4,"23","144352543"));
        System.out.println(i);

        //事务提交
        sqlSession.commit();

        sqlSession.close();
    }

4. update

  • interface
    //修改用户
    int updateUser(User user);
  • mapper.xml
    
        update mybatis.user set name = #{name}, pwd = #{pwd} where id = #{id}
    
  • test
    @Test
    public void updateUser() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.updateUser(new User(4, "扯一扯", "12323"));
        System.out.println(i);
        //事务提交
        sqlSession.commit();

        sqlSession.close();
    }

5. delete

  • interface
    //删除一个用户
    int deleteUser(int id);
  • mapper.xml
    
        delete from mybatis.user where id = #{id}
    
  • test
    @Test
    public void deleteUser() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUser(4);
        System.out.println(i);
        //事务提交
        sqlSession.commit();
        sqlSession.close();
    }

Map

前提:实体类、或者数据库中的表,字段或者参数过多,考虑使用Map传参

  • interface
    //根据id查询用户
    User getUserByIdMap(Map map);
  • mapper.xml
    
  • test
    public void getUserByIdMap() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map map = new HashMap();
        map.put("userid",1);
        User user = mapper.getUserByIdMap(map);
        System.out.println(user);
        sqlSession.close();
    }

模糊查询

  1. Java代码执行时,传递通配符% %
  2. 在sql拼接中使用通配符
    模糊查询的4种实现方式



二、MyBatis配置简单解析

(一)、核心配置文件

  • mybatis-config.xml
  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息

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

(二)、环境变量(environment)

  • MyBatis 可以配置适应多种环境
  • 尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
  • MyBatis 默认的事务管理器是jdbc,连接池:POOLED

(三)、属性(properties)

通过properties属性来实现引入配置文件

这些属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
username=root
password=20201123

在配置文件中引入

  • xml中标签位置有限定
    image
    
    
        
    

    
        
            
            
                
                
                
                
            
        
    
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置
  • 如果两个文件中同名的字段,最后读取作为方法参数传递的属性,并覆盖之前读取过的同名属性

(四)、类型别名(typeAliases)

  • 类型别名可为 Java 类型设置一个缩写名字
  • 仅用于 XML 配置,意在降低冗余的全限定类名书写。

第一种方法

    
        
    

第二种方法
指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如扫描一个实体类的包,他的默认别名就为这个类的 类名,首字母小写

    
        
    
  • 在实体类比较少的时候,使用第一种方式
  • 如果实体类比较多,使用第二种方式
  • 还可以使用注解的方式结合第二种方式起别名:
@Alias("User) public class User{}

(五)、设置(settings)

设置名 描述 有效值 默认值
cacheEnabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存 true \ false true
lazyLoadingEnabled 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 true \ false false
logImpl 指定 MyBatis 所用日志的具体实现,未指定时将自动查找 SLF4J \ LOG4J \ LOG4J2 \ JDK_LOGGING \ COMMONS_LOGGING \ STDOUT_LOGGING \ NO_LOGGING 未设置

(六)、映射器(mappers)

MapperRegistry:注册绑定我们的mapper文件
方式一: 使用相对于类路径的资源引用 -

    
    
        
    

方式二: 使用class文件绑定注册(使用映射器接口实现类的完全限定类名)

    
        
    

方式三: 使用扫描包进行注入绑定(将包内的映射器接口实现全部注册为映射器)

    


        
    

方式二和方式三必须的注意点

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

(七)、 生命周期和作用域

image

作用域、生命周期,是至关重要的,因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

  • 一旦创建了 SqlSessionFactory,就不再需要它了
  • 局部方法变量

SqlSessionFactory

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

SqlSession

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


    image

这里面的每一个mapper,就代表一个具体的业务




三、解决MyBatis_属性名和字段名不一致

属性名和字段名不一致导致查询结果为空的问题

表中的字段名:
image

对应的JavaBean实体类

public class User {
    private int id;
    private String name;
    private String password;
}

密码的字段是不一致的
最后测试,返回的User对象的password属性是空的

原因:列名不匹配

select * from mybatis.user where id = #{id}
--类型处理器
select id,name,pwd from mybatis.user where id = #{id}

解决方法:

(一)、起别名(更改的是:sql语句)

MyBatis 会在幕后自动创建一个 ResultMap,再根据属性名来映射列到 JavaBean 的属性上。如果列名和属性名不能匹配上,可以在 SELECT 语句中设置列别名(这是一个基本的 SQL 特性)来完成匹配。

    

(二)、使用resultMap

上面没有一个需要显式配置 ResultMap,完全可以不用显式地配置它们。
显式使用外部的 resultMap,是解决列名不匹配的另外一种方式。

    
    
        
        
        
        
    

在引用它的语句中设置 resultMap 属性就行了(注意去掉了 resultType 属性)。

    

官方文档_结果映射




四、MyBatis日志简单使用

日志工厂

数据库操作的错误通过日志来查找是比较方便的

  • 过去:sout、debug
  • 现在:日志工厂

logImpl: 指定 MyBatis 所用日志的具体实现,未指定时将自动查找

  • SLF4J
  • LOG4J
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING
  • NO_LOGGING

使用日志工厂

  • 默认情况下,日志工厂是 没设置 的
  • 在MyBatis中具体使用哪一个日志,在核心配置文件中,配置
  • STDOUT_LOGGING标准日志输出
    
    
        
    
  • 日志输出的重要信息

Opening JDBC Connection
Created connection 1263793464.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b53f538]
==> Preparing: select * from mybatis.user where id = ?
==> Parameters: 2(Integer)
<== Columns: id, name, pwd
<== Row: 2, 李四, 324332
<== Total: 1

User{id=2, name='李四', pwd='324332'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b53f538]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b53f538]
Returned connection 1263793464 to pool.

LOG4J

什么是LOG4J?

  • log for Java:Java的日志
  • 使用Log4j可以控制日志信息输送的目的地是控制台、文件、GUI组件
  • 可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别
  • 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。

使用LOG4J

1. 导入jar包

    
        
        
            log4j
            log4j
            1.2.17
        
    

2. 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/vigil.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

3. 配置log4j为日志的实现

    
        
    

4. 日志输出重要信息

[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 306206744.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@12405818]
[com.vigil.dao.UserMapper.getUserById]-==> Preparing: select * from mybatis.user where id = ?
[com.vigil.dao.UserMapper.getUserById]-==> Parameters: 2(Integer)
[com.vigil.dao.UserMapper.getUserById]-<== Total: 1
User{id=2, name='李四', pwd='324332'}
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@12405818]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@12405818]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 306206744 to pool.

在类里的简单应用

  1. 在要使用LOG4J的类中,导入包:import.org.apache.log4j.Logger;
  2. 日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserDaoText.class);
  1. 日志级别
logger.info("info");
logger.debug("debug");
logger.error("error");



五、MyBatis简单分页

分页作用:==减少数据的处理量==

(一)、 使用LImit分页(物理分页)

//语法:select * from 表名 limit startIndex,pageSize
select * from user limit 3; #[0,3)-->0,1,2,从0开始拿3个数据

使用MyBatis实现分页,核心是sql语句

  1. 接口
    //分页,查询用户,传参是map,坏处是不规范
    List getUserByLimit(Map map);
  1. Mapper.xml
    
    
        


        
    
    
    
  1. 测试
    @Test
    public void testLimit() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap map = new HashMap();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List users = mapper.getUserByLimit(map);
        for(User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

(二)、使用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.vigil.dao.UserMapper.getUserByRowBounds", null, rowBounds);

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

limit 和 rowbounds 的区别

limit
limit.png
rowbounds
rowbounds.png

(三)、PageHelper

(四)、面向接口编程

面向接口编程.png




六、MyBatis复杂查询_简单实现

复杂查询环境搭建

数据库文件

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. 导入mybatis
  2. 编写资源文件
  3. 编写mybatis核心配置文件
  • 引入外部资源文件:properties
  • 日志:settings
  • 起别名:typeAliases
  • 环境(数据库资源):environments-->transactionManager、dataSource
  1. 编写实体类
  2. 编写Mapper接口
  3. 编写Mapper.xml
  • mapper标签的命名空间:绑定接口
  • 选择sql对应的标签,绑定方法
  • 书写sql语句
  1. 到MyBatis的核心配置文件中注册mapper
  2. 测试

多对一处理(association)

查询学生信息以及对应老师的信息
思路: 1.查询学生信息 ;2.根据tid查找相对应的老师

一、按照结果嵌套处理(类似联表查询)

    

    
        
        
        
            
            
        
    

二、按照查询嵌套处理(类似子查询)

    

    

    
        
        
        
        
    

一对多处理

一、按照结果嵌套处理(类似联表查询)

    

    
        
        

        
        
            
            
        
    

二、按照查询嵌套处理(类似子查询)

    

    

    
        
        
        
    

小结

resultMap.png
  1. 关联 - association【多对一】
  2. 集合 - collection【一对多】
  3. javaType:用来指定实体类中属性的类型
  4. ofType:用来指定映射到List或者集合中的pojo类型,泛型中的约束类型

注意

  • 保证SQL的可读性
  • 字段和属性名问题
  • 日志查看



七、MyBatis动态SQL

  • 动态SQL:根据不同的条件生成不同的SQL语句
  • 本质还是sql语句,但却可以在sql层面上,执行一个逻辑代码

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。

  • if
  • choose(when,otherwise)
  • trim(where,set)
  • foreach

环境搭建

  1. 数据库
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. 编写MyBatis核心文件

  • 引入外部资源文件
  • 日志设置
  • 驼峰命名转化设置
  • 起别名
  • 数据库环境配置
  • 当编写好mapper要记得注册
  1. 编写工具类
  • 获得SqlSession的工具类
  • 获得随机字符串的工具类
  1. 实体类:JavaBean

  2. 实体类接口

  3. 编写对应接口的mapper

  • namespace
  • 选择对应sql语句标签
  • 编写sql语句
  1. 测试

IF

  1. 接口
   //查询博客
    List queryBlogIf(Map map);
  1. Mapper.xml
    
  1. 测试
    @Test
    public void queryBlogIf() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap map = new HashMap();
        map.put("title","会议厅");
        List blogs = mapper.queryBlogIf(map);

        for(Blog blog : blogs) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

choose(when,otherwise)

  • 类似switch语句
    

trim(where,set)

  • where 标签,会识别追加语句的出现,是否过滤and或or
    这也说明了,追加语句最好都加上and或or
    
  • set标签,动态设置set关键字,同时会删掉无关的逗号(where语句前面的逗号)
   
        update mybatis.blog
        
            
                title = #{title},
            
            
                author = #{author},
            
        
        where id = #{id}
    

自定义 trim 元素来定制 where 元素的功能。比如,和 where 元素等价的自定义 trim 元素为


  ...

set 元素等价的自定义 trim 元素


  ...

SQL片段

这个元素可以用来定义可重用的 SQL 代码片段,以便在其它语句中使用。 参数可以静态地(在加载的时候)确定下来,并且可以在不同的 include 元素中定义不同的参数值。

  • 将复用高的sql语句抽取出来放到一个标签里,在其他sql便签中使用id关联使用
  1. 使用sql便签将其抽取
    
        
            and title = #{title}
        
        
            and author = #{author}
        
    
  1. 使用include标签和sql便签的id将其引用
    
  1. 注意:
  • 最好基于单表来定义SQL片段
  • 不要加上where或者set语句,因为其特殊

Foreach

动态 SQL :对集合进行遍历(尤其是在构建 IN 条件语句的时候)。

(1)指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符。

  • 注意: 可以将任何可迭代对象(如 List、Set 等)、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时,index 是当前迭代的序号,item 的值是本次迭代获取到的元素。当使用 Map 对象(或者 Map.Entry 对象的集合)时,index 是键,item 是值。
    

==> Preparing: select * from mybatis.blog WHERE id in ( ? )
==> Parameters: 1(Integer)

动态sql核心:拼接sql

保证正确性:sql语句最好先在数据库测试成功了,再去拼接sql语句




八、MyBatis缓存_简单了解

简介(了解)

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

MyBatis缓存

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

一级缓存

  • 一级缓存也叫本地缓存:SqlSession
  • 与数据库同一次会话期间查询到的数据会放到本地缓存中
  • 下一次如果需要获得相同的数据,则直接从缓存中拿,除非缓存中没有才会去查询数据库

缓存失效的情况:

  1. 查询不同的东西
  2. 增删改操作,可能会改变原来的数据,必定会刷新缓存
  3. 查询不同的Mapper.xml
  4. 手动清理缓存

小结:

一级缓存是默认开启的,只在一次SqlSession中有效,也就是拿到数据库连接到关闭数据库连接的这个区间段(一级缓存就是一个Map)

二级缓存

  • 二级缓存也叫全局缓存,一级缓存作用域太低
  • 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
  • 工作机制:
  1. 一个会话查询一条数据,这个数据会被放在当前会话的一级缓存中
  2. 如果当前会话关闭了,这个会话对应的一级缓存就没了,但是开启二级缓存后,这个一级缓存中的数据就会保存到二级缓存中
  3. 新的会话查询信息,会到二级缓存中获取信息(假如没有就到一级缓存,还是没有则查询数据库)
  4. 不同的mapper查出的数据会放到自己对应的缓存(map)中

使用二级缓存的步骤

  1. 开启全局缓存


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


  1. 自定义参数


  1. error
    实体类需要序列化

小结:

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

缓存原理

缓存原理.png

基于内存的数据库:Redis实现缓存

你可能感兴趣的:(MyBatis_学习笔记汇总)