01-1-环境配置

1.框架概述

1)什么是框架

程序开发中的框架往往是对常见功能的封装，通常与具体业务无关，也可以认为是软件的半成品。程序框架理解为基础或者机械标准件(例如螺丝螺母标准的机械部件)。
假如你要造一辆马车，在没有框架的情况下，你需要自己去伐木，去把木头做成木板，木棍，然后组成轮子，门，等部件，然后组装起来。但如果你用了框架，就相当于你有现成的轮子，门等部件，你只需要组装一下就可以了。
一个框架是一组可复用的设计构件。
框架是一个半成品，软件是成品。我们在它的基础上开发出成品(软件)。

2)框架解决的问题

1.解决了技术通用的问题

在JavaEE体系中，有着各种各样的技术。不同的软件企业，根据自身的业务需求选择不同的技术，容易造成应用依赖技术，增加了项目开发实现的复杂性和技术风险性。而框架技术就可以解决上述问题。

2.提升了开发效率

企业项目中使用框架，只需要专注实现业务需求。使用框架的方便性，提升了开发效率。

3.提升了系统稳定性

一个成熟的框架，经过了在众多企业项目中的验证使用，稳定性有保障。

2.Mybatis框架介绍

2.1 mybatis框架介绍

mybatis是Apache软件基金会下的一个开源项目，前身是iBatis框架。2010年这个项目由apache 软件基金会迁移到google code下，改名为mybatis。2013年11月又迁移到了github(GitHub 是一个面向开源及私有 软件项目的托管平台)。
    MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射(多表)。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。它对 jdbc 的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建 connection、创建 statement、手动设置参数、结果集检索等 jdbc 繁杂的过程代码。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.mybatis的优点

1. 简单易学：mybatis本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个SQL映射文件即可。
2. 使用灵活：Mybatis不会对应用程序或者数据库的现有设计强加任何影响。SQL语句写在XML里，便于统一管理和优化。

3. 解除SQL与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易进行单元测试。SQL语句和代码的分离，提高了可维护性。

   2.mybatis的不足

4. 编写SQL语句时工作量很大，尤其是字段多、关联表多时，更是如此。

5. SQL语句依赖于数据库，导致数据库移植性差，不能更换数据库。
6. Mybatis框架还是比较简陋(半自动化框架)，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。

   3.官方网站及框架包下载

   官网地址：http://www.mybatis.org/mybatis-3/

   4.mybatis框架整体架构

   

   2.2 MyBatis的ORM方式

   Object Relational Mapping 对象关系映射
   
   Mybatis有两种映射方式:

   1.通过XML映射;
   2.通过注解;

   小结:
   1、mybatis解决了三层(web,service,dao)中哪一层的问题？

   dao

   2、mybatis框架是对什么技术进行的封装？

   JDBC

3.MyBatis框架入门开发【掌握】TODO

3.1Mybatis快速入门

数据准备:

create table user (
  id int primary key auto_increment,
  username varchar(20) not null,
  birthday date,
  sex char(1) default '男',
  address varchar(50)
);
insert into user values (null, '孙悟空','1980-10-24','男','花果山水帘洞');
insert into user values (null, '白骨精','1992-11-12','女','白虎岭白骨洞');
insert into user values (null, '猪八戒','1983-05-20','男','福临山云栈洞');
insert into user values (null, '蜘蛛精','1995-03-22','女','盤丝洞');
select * from user;

https://mybatis.org/mybatis-3/zh/index.html 
-- 官网参考地址

需求1:使用Mybatis框架,从User表中根据用户id查询用户信息;
1.创建项目
2.创建lib目录,并导入mysql-connector-java-5.1.37.jar,mybatis-3.5.0.jar,log4j.jar

3.创建实体类User

public class User {
    private Integer id;
    private String username;
    private Date birthday;
    private  String sex;
    private String address;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

4.在src下创建核心配置文件:mybatis-config.xml

<?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:///day06_2"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

5.在src下创建映射文件UserMapper.xml

<?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">
<mapper namespace="com.heima.UserMapper">
    <select id="findById" resultType="com.heima.pojo.User">
        select * from user where id = #{id}
    </select>
</mapper>

6.编写测试类代码

public class TestAll {
    @Test
    public void test1(){
        //1.加载核心配置文件,构建会话工厂
        String resouce="mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(resouce);
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        //2.获取会话对象
        SqlSession sqlSession = sessionFactory.openSession();
        //3.调用sqlsession API完成查询
        User user = (User)sqlSession.selectOne("com.heima.UserMapper.findById", 1);
        System.out.println(user);
        //4.关闭资源
        sqlSession.close();
    }
}

7.配置log4j.properties日志

### 设置Logger输出级别和输出目的地 ###
log4j.rootLogger=debug, stdout
### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

8.效果

3.2 Mybatis老式开发小结

1)旧式开发加载流程：
PPT演示:

2)使用mybatis老式的开发模式弊端：

1)要使用指定的sql必须使用命名空间.id进行字符串拼接,维护性比较差;
2)并且这个sql用多少次,就拼接多少次,维护性比较差;

3)Mybatis框架的核心类有哪些?

SqlSessionFactoryBuilder 会话工厂构建类 主要用来构建会话工厂的
SqlSessionFactory :会话工厂类 主要用来生产会话对象的;
SqlSession:会话对象,底层是对Connection连接对象的封装;

4.mybatis的dao层动态代理实现【掌握】

4.1 Mybatis动态代理快速入门

1)介绍

Mybatis存在2种开发方式:
1)旧版本mybatis执行的方式(了解即可);
2)动态代理实现操纵数据库(掌握);

核心步骤:

1)接口与xml映射文件绑定;
    接口名称与xml映射文件命名空间要一致;
    接口方法与xml中crud标签ID要一致;
2)通过SqlSession获取代理对象;
   eg:sqlSession.getMapper(接口);

2)需求

练习:使用mybatis动态代理根据用户ID查询用户信息
第一步：新建接口 UserMapper；

public interface UserMapper {
    /**
     * 根据用户id查询用户信息
     * @param id
     * @return
     */
    User findUserById(Integer id);
}

第二步：将接口和映射文件绑定，在映射文件中书写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">
<mapper namespace="com.heima.mapper.UserMapper">
    <select id="findUserById" resultType="com.heima.pojo.User">
        select * from user where id = #{id}
    </select>
</mapper>

说明:接口与xml映射文件进行绑定,分两步:
1)接口的全限定名称与xml的命名空间名称要一致
2)接口中的方法名称与xml的crud标签的id要一致;

第四步：获取UserMapper的动态代理对象完成查询；

/**
     * 基于动态代理实现查询
     */
    @Test
    public void test2(){
        //1.加载核心配置文件,构建会话工厂
        String resource="mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        //2.获取会话对象
        SqlSession sqlSession = sessionFactory.openSession();
        //3.获取接口的代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //4.调用接口方法,进行处理
        User user = mapper.findUserById(1);
        System.out.println(user);
        //5.释放资源
        sqlSession.close();
    }

原理图：
PPT演示:

4.2 mybatis动态代理小结

Mybatis动态代理开发流程？

1)导入依赖的jar mybatis.jar jdbc驱动包 log4j.jar
2)定义pojo类型;
3)定义操纵pojo类的接口
4)定义xml映射文件,然后与接口进行绑定
    4.1 xml的命名空间与接口的全限定名称要一致;
    4.2 xml中的crud的标签id与接口中的方法名称要一致;
5)配置核心配置文件 (1.配置数据源 2.加载xml映射文件)
6)通过SqlSessionFactoryBuilder类加载核心配置文件,构建会话工厂;
7)通过会话工厂获取会话对象;
8)通过会话对象调用getMapper(接口.class)获取代理对象(正常使用接口完成数据库的操作)
9)释放资源,关闭连接(session.close())

5.mybatis核心配置

【mybatis全局配置介绍】
mybatis-config.xml，是MyBatis的全局配置文件，包含全局配置信息，如数据库连接参数、插件等。整个框架中只需要一个即可。

参考:https://mybatis.org/mybatis-3/zh/configuration.html

说明:上述标签在实际使用过程中,要严格遵循使用顺讯,否则报错;

5.1 properties(属性)

1.作用:

1、通过子标签property设置属性；
2、加载外部的java资源文件（properties文件）；

2.两种使用标签的方式

方式1(了解即可):
1、通过properties的子标签设置属性；
2、使用${key}获取设置的属性值；

方式2:
1.通过properties标签 resource属性引入加载外部properties文件

2.练习

练习1:使用properties下的内部配置全局参数(了解即可)

<!--文件内部定义全局参数-->
    <properties>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    </properties>

练习2:核心配置文件通过表中的resource属性引入外部jdbc.properties文件
第一步:创建jdbc.properties配置文件:

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///day06_2
jdbc.user=root
jdbc.password=1234

第二步:引入外部的配置文件

<!--通过properties引入外部配置文件,使用resource属性 推荐-->
    <properties resource="jdbc.properties"/>

第三步:加载value值

<environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

小结：
properties标签作用?

1.定义全局变量;
2.定义全局变量2中方式
2.1 内部定义
<properties>
    <property name="key" value="值"/>
</properties>
2.2 外部引入(推荐)
<properties resource="外部配置文件路径"/>

5.2 settings(设置)

settinngs是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

settings参数有很多，我们先学习驼峰匹配mapUnderscoreToCamelCase,翻译过来就是映射下划线到驼峰式命名。
练习1:修改数据库username字段名称为user_name,并建立与pojo映射关系,配置驼峰映射
1)pojo:

public class User {
    private Integer id;
    //表:user_name --->类:userName/username
    private String username;
    private Date birthday;
    private  String sex;
    private String address;
    //setter getter toString
}

2)设置开启驼峰映射

<!--开启驼峰映射-->
    <settings>
        <!--作用:表:user_name 类:userName/username 自动映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

3)测试

/**
     * 基于动态代理实现查询
     */
    @Test
    public void test2(){
        //1.加载核心配置文件,构建会话工厂
        String resource="mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        //2.获取会话对象
        SqlSession sqlSession = sessionFactory.openSession();
        //3.获取接口的代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //4.调用接口方法,进行处理
        User user = mapper.findUserById(1);
        System.out.println(user);
        //5.释放资源
        sqlSession.close();
    }

小结:
1.开启驼峰自动映射的配置和作用?

1)配置
<setttings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</setttings>
2)作用
自动将表中字段比如:user_name 映射到pojo属性:username/userName,无需给sql中字段取别名;

5.3 typeAliases(类型别名)

1.作用

类型别名是给类的全限定名称(包名.类名) 取一个短名称。存在的意义仅在于用来减少类完全限定名的冗余。

可以通过设置一些短名来代替全限定名,有两种方式:

方式一：使用typeAliases标签的子标签typeAlias手动设置类型别名(逐一设置维护)；
方式二：使用typeAliases标签的子标签package包扫描映射别名(推荐)；

2.需求

练习1:使用typeAliases标签的子标签typeAlias简化UserMapper.xml中pojo类的名称

<!--方式1:取别名,逐个取别名-->
    <typeAliases>
        <typeAlias type="com.heima.pojo.User" alias="user"/>
    </typeAliases>

练习2：使用typeAliases标签的子标签package包扫描映射别名

<!--方式2:通过扫包取指定包下的pojo类取别名 (推荐)-->
    <typeAliases>
        <!--package name指定要取别名的包名-->
        <package name="com.heima.pojo"/>
    </typeAliases>

3.内置别名

这是一些为常见的 Java 类型内建的相应的类型别名。它们都是不区分大小写的，注意对基本类型名称重复采取的特殊命名风格。

说明:
基本类型别名是_基本类型名称;
包装类型别名时包装类首字母小写;

练习3:完成根据id查询用户姓名的功能;
1)定义接口方法:

//练习3:完成根据id查询用户姓名的功能;
    String getNameById(Integer id);

2)接口方法与xml映射文件sql进行绑定

<select id="getNameById" resultType="string">
        select user_name from user where id=#{id}
    </select>

3)测试

@Test
    public void test3(){
        //1.加载核心配置文件,构建会话工厂
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream("mybatis-config.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        //2.获取会话对象
        SqlSession session = sessionFactory.openSession();
        //3.获取代理对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        String name = mapper.getNameById(1);
        System.out.println(name);
        //4.关闭资源
        session.close();
    }

5.4 typeHandlers和environments(了解)

1)typeHandlers(类型处理器)【了解】

 MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器。<br />![](https://cdn.nlark.com/yuque/0/2021/png/280648/1640162301194-395b0fd1-0bbb-49a9-ae3b-205c015e78a0.png#)<br />**提示** 从 3.4.5 开始，MyBatis 默认支持 JSR-310（日期和时间 API） 。

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

说明:mybatis内置的一些类型处理器,企业开发中使用默认的类型处理器;

2)environments【了解】

MyBatis 可以配置成适应多种环境，例如，开发、测试和生产环境需要有不同的配置；
尽管可以配置多个环境，每个 SqlSessionFactory 实例只能选择其一。
虽然，这种方式也可以做到很方便的分离多个环境，但是实际使用场景下，我们更多的是选择使用spring来管理数据源，来做到环境的分离。

父标签： environments（环境配置）
            子标签：
                environment（环境变量）
                transactionManager（事务管理器）
                dataSource（数据源）

练习:
练习1.xml配置多环境数据源,比如dev,test.online等,并在xml下指定online为默认环境运行;

<!--environments内部可以配置多个数据源,default指定默认数据源-->
    <environments default="online">
        <!--environment配置具体数据源 id表示数据源的唯一表示-->
        <environment id="dev">
            <!--transactionManager事务管理器,type="jdbc":表示事务交给jdbc取管理-->
            <transactionManager type="JDBC"/>
            <!--dataSource表示数据源 type="POOLED"表示使用mybatis自带的连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
        <environment id="online">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="jdbc:mysql:///day06_3"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

练习2.xml配置多环境数据源,比如dev,test.online等,并使用会话构建工厂指定dev运行环境;
说明:在构建会话工厂的build方法中指定运行环境;

/**
     * 在build方法下指定数据源
     */
    @Test
    public void test4(){
        //1.加载核心配置文件,构建会话工厂
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream("mybatis-config.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //在build方法下指定要切换的数据源的标识,会覆盖默认的数据源配置
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in,"dev");
        //2.获取会话对象
        SqlSession session = sessionFactory.openSession();
        //3.获取代理对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        String name = mapper.getNameById(1);
        System.out.println(name);
        //4.关闭资源
        session.close();
    }

小结：
Mybatis2种切换数据源的方式?

1)在核心配置文件下指定
格式:
<environments default="dev">
    <environment id="dev">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        .....
    </environment>
</environments>
2)方式2:在build方法指定
 new SqlSessionFactoryBuilder().build(in,"数据源标识");

5.5 mappers(映射器)

1.介绍

mappers（映射器）：UserMapper.xml====>UserMapper.java接口 关联.
作用：维护接口和映射文件之间的关系.
使用方式：
1、加载XML映射文件，关联UserMapper.java接口
【1】 从src下加载映射文件；
【2】 从本地磁盘中加载映射文件,但是需要添加file:///协议
说明:如果项目采用基于xml的开发模式,建议使用方式1开发;
2、加载接口，关联映射文件
条件：1、接口名和映射文件名保持一致；2、路径保持一致；
【3】class：加载单独的接口：
【4】批量加载class：
说明:如果基于注解开发的开发的话,推荐使用方式4开发

2.练习

1)使用mapper下resource属性加载xml映射文件关联接口

<mappers>
        <!--通过resource属性加载工程下相对路径下的映射文件-->
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>

2)使用完全限定资源符加载映射文件(了解即可)

<!--通过url属性指定xml映射文件的绝对路径 [了解]-->
        <mapper url="file:///E:\上课视频资料\121\day06\mybatisday06\src\mapper\UserMapper.xml"/>

3)使用映射器接口实现类的完全限定类名 (了解即可)

前提条件：
1、接口名和映射文件名保持一致；
2、路径保持一致；
3.映射文件中的namespace必须与接口的全限定名称一致;

<!--class指定接口的全限定名称,mybatis底层就可以获取接口的名称,然后因为
         接口与xml文件名称相同且同路径,所以就可以获取xml映射文件; [了解]
        -->
        <mapper class="com.heima.mapper.UserMapper"/>

4)加载接口，关联映射文件方式package(推荐)

前提条件：
1.接口与映射文件名称必须相同;
2.接口与映射文件路径必须相同;
3.映射文件中的namespace必须与接口的全限定名称一致;

<!--package表示通过扫包加载接口,然后获取接口名称,就获取了xml映射文件名称
           name属性指定接口的路径-->
        <package name="com.heima.mapper"/>

说明:package扫包加载的方式是mybatis注解开发优先推荐的方式;
如果基于xml开发,推荐使用方式1:resouce加载外部资源;

5.6 mappers映射器小结

1.加载xml映射文件的4种方式：

1)通过resource属性,相对路径加载(基于xml开发推荐的)
eg:
<mappers>
    <mapper resource="xml的相对路径"/>
</mappers>
2)通过url绝对路径加载(了解即可)
 弊端:路径是绝对的,可维护性很差
 eg:
 <mappers>
    <mapper url="file:///xml的绝对路径"/>
</mappers>
3)通过class属性加载(了解即可)
 约束条件:
 3.1 接口名称与xml映射文件名称要一致;
 3.2 接口路径与xml映射文件路径也要一致;
eg:
<mappers>
    <mapper class="接口的全限定名称"/>
</mappers>
4)通过package扫包方式(基于注解开发推荐使用)
 约束条件:
 3.1 接口名称与xml映射文件名称要一致;
 3.2 接口路径与xml映射文件路径也要一致;
eg:
<mappers>
    <package name="接口的包路径"/>
</mappers>

2.基于package扫描的原理?

前提:
1.接口名称与xml映射文件名称要一致;
2.接口路径与xml映射文件路径也要一致;
通过package指定接口的路径之后,mybatis就会加载这个包下的接口,获取接口的名称,因为接口名称和路径与xml一致,所以也就获取xml映射文件;

3.思考:基于package扫描存在的缺点?

1)约束条件太多了;
2)java文件与xml文件存放在同一个路径下,可维护性差;

6.编写会话工具类

1. 在静态代码块中创建会话工厂对象
2. 编写静态方法得到会话对象
3. 编写静态方法得到会话工厂对象

   public class MybatisUtil {
    //全局维护一个会话工厂
    private static SqlSessionFactory sqlSessionFactory;
    private static ThreadLocal<SqlSession> threadLocal=new ThreadLocal<>();
    //在静态代码块中加载mybatis核心配置文件,初始化sqlSessionFactory
    static {
        //抽取初始化工厂的方法
        initFactory();
    }
    //封装初始化session工厂的方法
    private static void initFactory() {
        String resource="mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSessionFactory= new SqlSessionFactoryBuilder().build(in);
    }
    /**
     * 获取sqlSession对象
     * @return
     */
    private static SqlSession getSqlSession(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession==null){
            sqlSession=sqlSessionFactory.openSession();
            //放回线程中 通过threadLocal为每一个线程都维护一个私有的会话对象,防止出现并发问题
            threadLocal.set(sqlSession);
        }
        return sqlSession;
    }
    /**
     * 封装获取动态代理对象的方法
     * @param tClass
     * @param <T>
     * @return
     */
    public static  <T> T getMapper(Class<T> tClass){
        SqlSession sqlSession = getSqlSession();
        T mapper = sqlSession.getMapper(tClass);
        return mapper;
    }
    /**
     * 关闭资源
     */
    public static void close(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession!=null){
            sqlSession.close();
        }
    }
    /**
     * 事务提交
     */
    public static void commit(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession!=null){
            sqlSession.commit();
        }
    }
    /**
     * 事务回滚
     */
    public static void rollback(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession!=null){
            sqlSession.rollback();
        }
    }
   }

7.Mybatis环境搭建

1.需求
搭建mybatis环境，完成dao层根据id查询用户数据功能；
2.数据准备:

create table user (
  id int primary key auto_increment,
  username varchar(20) not null,
  age int,
  birthday date,
  sex char(1) default '男',
  address varchar(50)
);
insert into user values (null, '孙悟空',30,'1980-10-24','男','花果山水帘洞');
insert into user values (null, '白骨精',20,'1992-11-12','女','白虎岭白骨洞');
insert into user values (null, '猪八戒',20,'1983-05-20','男','福临山云栈洞');
insert into user values (null, '蜘蛛精',30,'1995-03-22','女','盤丝洞');
select * from user;

3.具体操作步骤

1.创建工程
2.导入依赖jar包;
3.创建接口和实体类;
4.配置mybatis全局配置文件和映射文件;
5.测试;

8.Mybatis映射文件配置

Mapper映射文件中定义了操作数据库的sql,**每一个sql都被包含在一个statement**中。映射文件是mybatis操作数据库的核心。<br />SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：<br />![](https://cdn.nlark.com/yuque/0/2021/png/280648/1640162301274-a7ab4eb6-9e37-4970-96c9-d81b379ec65d.png#)<br />    映射文件中需要直接书写SQL语句对数据库进行操作，对数据库操作SQL语句主要有**CRUD这四类**。这四类对应到映射文件中的配置为四类标签：`select`，`insert`,`update`，`delete` 。

8.1.select标签

select标签属性:

练习1:根据id查询用户生日;
1)定义接口方法

/**
     * 根据用户id查询用户的生日
     * @param id
     * @return
     */
    Date findBirthdayByUserId(Integer id);

2)xml文件sql绑定接口方法

<select id="findBirthdayByUserId" resultType="java.sql.Date">
        select birthday from user where id=#{id}
    </select>

3)测试

@Test
    public void test6(){
        UserMapper userMapper = MybatisUtil.getMapper(UserMapper.class);
        Date birthday = userMapper.findBirthdayByUserId(3);
        System.out.println(birthday);
        MybatisUtil.close();
    }

8.2.insert标签

属性:

说明:#{username},#{birthday},#{sex},#{address} 大括号里面的值必须和pojo的实体类User类中的属性名一致，否则会报错。
注意事项:Mybatis默认事务手动提交,可设置事务自动提交:

SqlSession sqlSession = sqlSessionFactory.openSession(true);

1)定义接口方法：
2)绑定映射文件
3)测试
小结:
1.insert标签插入pojo注意事项?

8.3.update标签

1)定义接口方法
2)绑定映射文件
3)测试

8.4.delete标签

属性:

1)定义接口方法
2)映射文件绑定接口方法
3)测试

总结：

1)核心配置文件配置标签mybatis-config.xml（要求：能理解即可）
<configuration>
  <properties resource="外部的properties文件"/>
  <settings>
    <setting name="xxx" value="布尔值，表示开启或者关闭"/>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
  </settings>
  <typeAliases>
     <typeAlias type="pojo的全限定名称" alias="别名" />
     <package name="pojo的包路径"/>
  </typeAliases>
  <!-- 2种指定数据源的方式1） default  2)SqlSesionFactoryBuilder ---> build(in,数据源唯一标识) -->
  <environments default="指定默认的数据库环境">
     <environment id="xxx 要唯一">
            <!--transactionManager标识事务交给jdbc去管理-->
            <transactionManager type="JDBC"/>
            <!--数据源配置标签  type="POOLED" 表示使用mybatis自带的连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
     </environment>
  </environments>
  <mappers>
    <!-- 共4中加载xml映射文件的方式 -->
    <mapper resource="外部的映射文件路径"/>
    <package name="接口的包路径"/>
  </mappers>
</configuration>
2）映射文件中常用标签
1.select
   格式：
   <select id="对应接口中的方法名称" resultType="pojo名称默认首字符小写/_基本类型/jdk对象类型小写">
      select * from t where id=#{任意变量}
   </select>
2.insert
   格式：
   <insert id="xx">
      insert into t values(null,#{对应pojo中属性名称}，....)
   </insert>
3.update
    格式：
    <update id="xxx">
      update t set 字段1=#{对应pojo中属性名称}，.... where id=#{id}
    </update>
4.delete
   格式：
   <delete id="xxx">
     delete from t where id=#{id}
   </delete>