Mybatis基础

Mybatis

1、简介

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

• 持久层框架，支持定制化SQL、存储过程以及高级映射

• 避免JDBC代码

• XML或注解配置

如何获取：

• github
• maven

官网

1.1、什么是持久层

数据持久化

• 将程序的数据在持久状态和瞬时状态转换的过程

• 内存：断电即失

• 数据库（jdbc），io文件持久化

为什么需要持久化?

• 内存太贵
• 数据需要保存

1.2、持久层

Dao层，Service层，Controller层

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

1.3、为什么要Mybatis

• 简化传统JDBC
• 数据存入数据库中

2、第一个Mybatis程序

环境->导入Mybatis->写代码->测试

2.1、环境

搭建数据库

create database mybatis;
use mybatis;
create table user (
id int not null, 
name varchar(30) default null,
pwd varchar(30) default null,
primary key(id)

)engine=InnoDB default charset=utf8;
select * from user;
insert into user(id,name,pwd) values
(1,'lucas','123456'),
(2,'john','12345'),
(3,'mary','1234');

2.2、新建项目

1. 普通maven项目

2. 删除src

3. 编辑pom.xml

<!--父工程-->
    <groupId>com.lucas</groupId>
    <artifactId>mybatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>


    <!--导入依赖-->
    <dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15.1.46</version>
        </dependency>
        <!--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>

4. 创建一个模块

5. 新建mybatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="Sfwdsfw24#$%"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

6. 编写mybatis工具类

package com.lucas.utils;

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 {
            //使用Mybatis第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
        //有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();

    }
    }

2.3、编写代码

1. 实体类

package com.lucas.pojo;

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;
    }

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

2. Dao接口

package com.lucas.dao;

import com.lucas.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUserList();
}

3. 接口实现类

java impl->xml mapper

<?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.lucas.dao.UserDao">
    <select id="getUserList" resultType="com.lucas.pojo.User">
        select * from mybatis.user
    </select>

</mapper>

2.4、测试

junit

package com.lucas.dao;

import com.lucas.pojo.User;
import com.lucas.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //获得sqlsession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行sql 方式一 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中加上如下配置。

	 <!--在build中配置resources，来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

3、CRUD

3.1、namespace

namespace中的包名要和接口包名一致

3.2、select,update,insert,delete

• id为方法名

• resultType：sql执行的返回值

• parameterType：参数类型

编写顺序：

1. 编写接口

package com.lucas.dao;

import com.lucas.pojo.User;

import java.util.List;

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
    //根据id查询用户
    User getUseById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

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

<?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.lucas.dao.UserMapper">
    <select id="getUserList" resultType="com.lucas.pojo.User">
        select * from mybatis.user
    </select>
    <select id="getUseById" resultType="com.lucas.pojo.User" parameterType="int">
        select * from mybatis.user where id= #{id}
    </select>
<insert id="addUser" parameterType="com.lucas.pojo.User">
    insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd});
</insert>
    <update id="updateUser" parameterType="com.lucas.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id};
    </delete>
</mapper>

3. 编写测试

package com.lucas.dao;

import com.lucas.pojo.User;
import com.lucas.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        //获得sqlsession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行sql 方式一 getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sqlsession
        sqlSession.close();

    }

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

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User useById = userMapper.getUseById(1);
        System.out.println(useById);

        sqlSession.close();
    }
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=new User(4,"lucas","1222");
        int i =userMapper.addUser(user);
        //提交事务
        sqlSession.commit();
        System.out.println(i);

        sqlSession.close();
    }

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

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user=new User(4,"lucas","33333");
        int i =userMapper.updateUser(user);
        //提交事务
        sqlSession.commit();
        System.out.println(i);

        sqlSession.close();
    }

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

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

        int i =userMapper.deleteUser(4);
        //提交事务
        sqlSession.commit();
        System.out.println(i);

        sqlSession.close();
    }
}

注意：

• 标签对应
• resource 绑定mapper，用路径
• 程序配置文件符合规范

3.3、Map的使用

假如实体类或数据库中表的字段或参数过多，应考虑使用Map

• Map传递参数，直接在sql中取出key即可
• 对象传递参数，直接在sql中取对象的属性即可
• 只有一个基本类型参数的情况下，可直接在sql中取到.
• 多个参数用map，或者注解

 <!--对象中的属性，可以直接取出来-->
    <insert id="addUser2" parameterType="map">
    insert into mybatis.user(id,name,pwd) values (#{userid},#{username},#{password});
</insert>
    <select id="getUseById2" resultType="com.lucas.pojo.User" parameterType="map">
        select * from mybatis.user where id=#{userid} and name=#{username}
    </select>

    User getUseById2(Map<String ,Object >map );
    int addUser2(Map<String ,Object >map );

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

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> user=new HashMap<String,Object>();
        user.put("userid",5);
        user.put("username","lucas");
        user.put("password","111");

        int i =userMapper.addUser2(user);
        //提交事务
        sqlSession.commit();
        System.out.println(i);

        sqlSession.close();
    }

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

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("userid",1);
        map.put("username","lucas");
        User useById = userMapper.getUseById2(map);
        System.out.println(useById);

        sqlSession.close();
    }

4、配置解析

4.1、核心配置文件

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

4.2、环境配置

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

不过尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境

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

4.3、属性

可以通过properties属性实现引用配置文件

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

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8
username=root
password=Sfwdsfw24#$%

在核心配置文件中引入

<properties resource="db.properties">
        <property name="username" value="root"/>
    </properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

• 可以直接引入外部文件
• 可以在其中增加一些属性配置
• 如果两个文件有同一个字段，优先使用外部配置文件的

4.4、类型别名

防冗余，方便使用

4.5、设置

https://mybatis.org/mybatis-3/zh/configuration.html#settings

4.6、映射器

https://mybatis.org/mybatis-3/zh/configuration.html#mappers

最常使用

其他方法

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

4.7、生命周期和作用域

SqlSessionFactoryBuilder

一旦创建了 SqlSessionFactory，就不再需要它了。可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

SqlSessionFactory

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

SqlSession

• 连接到连接池的一个请求
• 每个线程都应该有它自己的 SqlSession 实例
• 不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
• 用完之后要关闭

Mapper

每一个mapper代表一个具体的业务

5、结果映射

ResultMap

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

https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#Result_Maps

6、日志

STDOUT_LOGGING

<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>  //标准的日志工厂实现
    </settings>

LOG4J

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；

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

通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程

这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1. 导入依赖

<dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

2. log4j.properties

### 设置###
log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ./logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR 级别以上的日志###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =./logs/error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
       

3. 配置log4j为日志的实现

<setting name="logImpl" value="LOG4J"/>

使用

import org.apache.log4j.Logger;
public class UserMapperTest {
    //日志对象，参数为当前类的class
    static Logger logger=Logger.getLogger(UserMapperTest.class); 

    @Test
    public void testLog4j(){
        logger.info("info");
        logger.debug("debug");
        logger.error("error");

    }
}

7、使用注解开发

7.1、面向接口编程

解耦

骨架

7.2、使用注解开发

1. 注解在接口上实现

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

<mappers>
        <mapper class="com.lucas.dao.UserMapper"/>
    </mappers>

本质是反射机制实现

底层是动态代理

7.3、CRUD

在工具类创建的时候实现自动提交事务

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

    }

编写接口，增加注解

编写测试类

关于@Param()注解

• 基本类型的参数或String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略
• 在SQL中引用的就是@Param()中设定的属性名

8、Lombok

使用步骤：

1. 在IDEA中安装Lombok

2. 在项目中导入lombok的 jar包

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

3. 可用的注解

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data 无参构造，get，set
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class User {
    private int id;
    private String name;
    private String password;


}

9、多对一

实体类

多

一

按照查询嵌套处理

按照结果嵌套处理

10、一对多

按照结果嵌套处理

按照查询嵌套处理

11、动态SQL

根据不同条件生成不同的SQL

动态拼接SQL

https://mybatis.org/mybatis-3/zh/dynamic-sql.html

IF

CHOOSE,WHEN,OTHERWISE

trim、where、set

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

FOREACH

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符

12、缓存

https://mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache

12.1、简介

1. 什么是缓存

• 存在内存中的临时数据
• 把用户经常查询的数据放在缓存中，提高效率，解决高并发系统的性能问题

2. 为什么使用缓存

• 减少和数据库的交互次数，减少开销

3. 什么样的数据能使用缓存

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

12.2、Mybatis缓存

提供一级缓存和二级缓存

• 一级缓存默认开启，SqlSession级别的缓存，拿到连接到关闭连接的时期内有效
• 二级缓存需手动配置，namespace级别的缓存

12.3、二级缓存

开启缓存

<cache/>
//设置
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

• 会话关闭后，一级缓存的数据会保存到二级缓存中
• 不同的mapper查出的数据会放在自己对应的缓存（map）中

13、Mybatis-Spring

https://mybatis.org/spring/zh/getting-started.html

1. 配置 spring-dao.xml

• 数据源配置
• sqlSessionFactory
• sqlSessionTemplate
• 自己接口的实现类

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

<!--DatoSource:使用Spring的数据源替换Mybatis的配置-->
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="Sfwdsfw24#$%"/>
    </bean>
    
    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource" />
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/lucas/mapper/UserMapper.xml"/>
    </bean>
    
    <!--sqlSessionTemplate-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    
    <!--自己接口的实现类-->
    <bean id="userMapper" class="com.lucas.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    <bean id="userMapper2" class="com.lucas.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

2. 自己接口的实现类

package com.lucas.mapper;

import com.lucas.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{
    //所有操作在之前mybatis时用sqlSession做，现在用SqlSessionTemplate做
    private SqlSessionTemplate sqlSessionTemplate;
    //定义set方法，用来注入到Spring中
    public void setSqlSession(SqlSessionTemplate sqlSessionTemplate){
        this.sqlSessionTemplate=sqlSessionTemplate;
    }

    public List<User> selectUser(){
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

3 . 测试类

import com.lucas.mapper.UserMapper;
import com.lucas.pojo.User;
import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;
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 org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class MyTest {
    @Test
    public void test1() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resources);

        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sessionFactory.openSession(true);

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
    @Test
    public void test2() throws IOException{
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }


    }
}

14、声明式事务

https://mybatis.org/spring/zh/transactions.html

• 声明式事务 交由容器管理事务
• 编程式事务