什么是框架

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种
定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别
人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的
软件企业需要从 J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技
术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设
计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应
用的底层支撑，它不应该直接对应用产生影响。

框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

软件开发的分层重要性

框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现
软件工程中的“高内聚、低耦合”。把问题划分开来各个

MyBatis 框架概述

mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，
而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。

mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中
sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并
返回。

采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc 进行了封装，屏蔽了 jdbc api 底层访问细节，使我
们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

原始dbc编程的回顾

public static void main(String[] args) {
   Connection connection = null;
   PreparedStatement preparedStatement = null;
   ResultSet resultSet = null;
   try {
   //加载数据库驱动
   Class.forName("com.mysql.jdbc.Driver");
   //通过驱动管理类获取数据库链接
   connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8","root", "root");
   //定义 sql 语句 ?表示占位符
   String sql = "select * from user where username = ?";

   //获取预处理 statement
   preparedStatement = connection.prepareStatement(sql);
   //设置参数，第一个参数为 sql 语句中参数的序号（从 1 开始），第二个参数为设置的参数值
   preparedStatement.setString(1, "王五");
   //向数据库发出 sql 执行查询，查询出结果集
   resultSet = preparedStatement.executeQuery();
   //遍历查询结果集
   while(resultSet.next()){
    System.out.println(resultSet.getString("id")+"
    "+resultSet.getString("username"));
   }
   } catch (Exception e) {
   e.printStackTrace();
   }finally{
   //释放资源
   if(resultSet!=null){
   try {
   resultSet.close();
   } catch (SQLException e) {
   e.printStackTrace();
   } }
   if(preparedStatement!=null){
   try {
   preparedStatement.close();
   } catch (SQLException e) {
   e.printStackTrace();
   } }
   if(connection!=null){
   try {
   connection.close();
   } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();

   }
   } } }

jdbc 问题分析

• 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
• Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java
  代码。
• 使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能
  多也可能少，修改 sql 还要修改代码，系统不易维护。
• 对结果集解析存在硬编码（查询列名），sql 变化导致解析代码变化，系统不易维护，如果能将数据库记
  录封装成 pojo 对象解析比较方便

搭建 Mybatis 开发环境

创建 maven 工程

创建 mybatis01 的工程，工程信息如下：
Groupid:com.itheima
ArtifactId:mybatis01
Packing:jar

添加 Mybatis3.4.5 的坐标

  <dependencies>
     <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis</artifactId>
         <version>3.4.5</version>
     </dependency>
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.10</version>
         <scope>test</scope>
     </dependency>
     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.6</version>
         <scope>runtime</scope>
     </dependency>
     <dependency>
         <groupId>log4j</groupId>
         <artifactId>log4j</artifactId>
         <version>1.2.12</version>
     </dependency>
  </dependencies>

编写 User 实体类

/**
* 
* <p>Title: User</p>
* <p>Description: 用户的实体类</p>
*/
public class User implements Serializable {
    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; }
    
    
}

持久层接口 IUserDao

IUserDao 接口就是我们的持久层接口（也可以写成 UserDao 或者 UserMapper）

public interface IUserDao {
/**
* 查询所有用户
* @return
*/
List<User> findAll();
}

持久层接口的映射文件 IUserDao.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.itheima.dao.IUserDao">
    <!-- 配置查询所有操作 --> 
    <select id="findAll" resultType="com.itheima.domain.User">
        select * from user
    </select>

</mapper>

要求：
创建位置：必须和持久层接口在相同的包中。
名称：必须以持久层接口名称命名文件名，扩展名是.xml

微信截图_20210303092153.png

SqlMapConfig.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>
<!-- 配置 mybatis 的环境 --> 
<environments default="mysql">
    <!-- 配置 mysql 的环境 --> 
    <environment id="mysql">
    <!-- 配置事务的类型 --> 
    <transactionManager type="JDBC"></transactionManager>
    <!-- 配置连接数据库的信息：用的是数据源(连接池) --> 
    <dataSource type="POOLED"> 
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/test"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </dataSource>
    </environment>
</environments>
<!-- 告知 mybatis 映射配置的位置 --> 
<mappers> 
    <mapper resource="com/itheima/dao/IUserDao.xml"/>
</mappers>
</configuration>

编写测试类

public class MybatisTest {

    public static void main(String[] args)throws Exception {

        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = builder.build(in);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行查询所有方法
        List<User> users = userDao.findAll();
        for(User user : users) {
        System.out.println(user);
        }
        //7.释放资源
        session.close();
        in.close();
    } 
}

基于代理 Dao 实现 CRUD 操作

使用要求：
1、持久层接口和持久层接口的映射配置必须在相同的包下
2、持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名
3、SQL 语句的配置标签<select>,<insert>,<delete>,<update>的 id 属性必须和持久层接口的
方法名相同

根据 ID 查询

在持久层接口中添加 findById 方法

/**
* 根据 id 查询
* @param userId
* @return
*/
User findById(Integer userId);

配置映射文件

<!-- 根据 id 查询 --> 
<select id="findById" resultType="com.itheima.domain.User" parameterType="int">
  select * from user where id = #{uid}
</select>

映射文件中的属性

• resultType ： 用于指定结果集的类型。
• parameterType ：用于指定传入参数的类型。

sql 语句中使用#{}字符： 它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。
具体的数据是由#{}里面的内容决定的。#{}中内容的写法：由于数据类型是基本类型，所以此处可以随意写并不影响,但尽量按照开发规范填写。

编写测试类

public class MybastisCRUDTest {

    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;
    
    @Test
    public void testFindOne() {
    //6.执行操作
    User user = userDao.findById(41);
    System.out.println(user);
    }
    @Before//在测试方法执行之前执行
    public void init()throws Exception {
    //1.读取配置文件
    in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2.创建构建者对象
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //3.创建 SqlSession 工厂对象
    factory = builder.build(in);
    //4.创建 SqlSession 对象
    session = factory.openSession();
    //5.创建 Dao 的代理对象
    userDao = session.getMapper(IUserDao.class);
    }

    @After//在测试方法执行完成之后执行
    public void destroy() throws Exception{
    session.commit();
    //7.释放资源
    session.close();
    in.close();
    } 
}

添加操作

在持久层接口中添加新增方法

/**
* 保存用户
* @param user
* @return 影响数据库记录的行数
*/
int saveUser(User user)

配置映射文件

<!-- 保存用户--> 
<insert id="saveUser" parameterType="com.itheima.domain.User">
   insert into user(username,birthday,sex,address) 
   values(#{username},#{birthday},#{sex},#{address})
</insert>

parameterType 属性：
代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。
sql 语句中使用#{}字符： 它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。
具体的数据是由#{}里面的内容决定的。 #{}中内容的写法：由于我们保存方法的参数是 一个 User 对象，此处要写 User 对象中的属性名称。

编写测试类

public class MybastisCRUDTest {
private InputStream in ;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;

@Test
public void testSave(){
    User user = new User();
    user.setUsername("modify User property");
    user.setAddress("北京市顺义区");
    user.setSex("男");
    user.setBirthday(new Date());
    System.out.println("保存操作之前："+user);
    //5.执行保存方法
    userDao.saveUser(user);
    System.out.println("保存操作之后："+user);
}

打开 Mysql 数据库发现并没有添加任何记录，原因是什么？
这一点和 jdbc 是一样的，我们在实现增删改时一定要去控制事务的提交，那么在 mybatis 中如何控制事务
提交呢？
可以使用:session.commit();来实现事务提交。加入事务提交后的代码如下：
@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
    session.commit();
    //7.释放资源
    session.close();
    in.close();
}
}

问题扩展：如何获取新增用户 id 的返回值

新增用户后，同时还要返回当前新增用户的 id 值，因为 id 是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长 auto_increment 的值返回

<insert id="saveUser" parameterType="USER">
<!-- 配置保存时获取插入的 id --> 
<selectKey keyColumn="id" keyProperty="id" resultType="int">
select last_insert_id();
</selectKey>
insert into user(username,birthday,sex,address) 
values(#{username},#{birthday},#{sex},#{address})
</insert>

更新数据

在持久层接口中添加更新方法

/**
* 更新用户
* @param user
* @return 影响数据库记录的行数
*/
int updateUser(User user);

配置映射文件

<!-- 更新用户 --> 
<update id="updateUser" parameterType="com.itheima.domain.User">
  update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
</update>

编写测试类

@Test
public void testUpdateUser()throws Exception{
    //1.根据 id 查询
    User user = userDao.findById(52);
    //2.更新操作
    user.setAddress("北京市顺义区");
    int res = userDao.updateUser(user);
    System.out.println(res);
}

删除数据

在持久层接口中添加删除方法

/**
* 根据 id 删除用户
* @param userId
* @return
*/
int deleteUser(Integer userId);

配置映射文件

<!-- 删除用户 --> 
<delete id="deleteUser" parameterType="java.lang.Integer">
  delete from user where id = #{uid}
</delete>

编写测试类

@Test
public void testDeleteUser() throws Exception {
//6.执行操作
int res = userDao.deleteUser(52);
System.out.println(res);
}

模糊查询

在持久层接口中添加模糊查询方法

/**
* 根据名称模糊查询
* @param username
* @return
*/
List<User> findByName(String username);

配置映射文件

<!-- 根据名称模糊查询 --> 
<select id="findByName" resultType="com.itheima.domain.User" parameterType="String">
   select * from user where username like  '%${value}%'
</select>

我们在上面将原来的 #{}占位符，改成了${value}。注意如果用模糊查询的这种写法，那么${value}的写法就是固定的，不能写成其它名字

编写测试类

@Test
public void testFindByName(){
 //5.执行查询一个方法
List<User> users = userDao.findByName("王");
for(User user : users){
System.out.println(user);
} }

#{}与${}的区别

1.#{}表示一个占位符号
通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换，
#{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。
如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称。
2. 表示拼接 sql 串通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以接收简
单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

parameterType 配置参数

基 本 类 型 和 String 我 们 可 以 直 接 写 类 型 名 称 ， 也 可 以 使 用 包 名 . 类 名 的 方 式 ， 例 如 ：
java.lang.String。

实体类类型，目前我们只能使用全限定类名。

resultType 配置结果类型

resultType 属性可以指定结果集的类型，它支持基本类型和实体类类型。

/**
* 查询总记录条数
* @return
*/
int findTotal()

<!-- 查询总记录条数 -->
<select id="findTotal" resultType="int">
  select count(*) from user;
</select>

/**
* 查询所有用户
* @return
*/
List<User> findAll();

此时实体类属性和数据库表的列名要求一致

<!-- 配置查询所有操作 --> 
<select id="findAll" resultType="com.itheima.domain.User">
  select * from user
</select>

如果实体类属性与表字段不能完全一致,可以通过resultMap进行映射

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。

type 属性：指定实体类的全限定类名
id 属性：给定一个唯一标识，是给查询 select 标签引用用的。

<resultMap type="com.itheima.domain.User" id="userMap">
    <id column="id" property="userId"/>
    <result column="username" property="userName"/>
    <result column="sex" property="userSex"/>
    <result column="address" property="userAddress"/>
    <result column="birthday" property="userBirthday"/>
</resultMap>

id 标签：用于指定主键字段
result 标签：用于指定非主键字段
column 属性：用于指定数据库列名
property 属性：用于指定实体类属性名称

<!-- 配置查询所有操作 --> 
<select id="findAll" resultMap="userMap">
  select * from user
</select>

Mybatis 与 JDBC 编程的比较

数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
解决：在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。

Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。
解决：将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。

向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应。
解决：Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的
类型。

对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对
象解析比较方便。
解决：Mybatis 自动将 sql 执行结果映射至 java 对象，通过 statement 中的 resultType 定义输出结果的类型。

Mybatis 的动态 SQL 语句

Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL 是动态变
化的，此时在前面的学习中我们的 SQL 就不能满足要求了。

动态 SQL 之<if>标签

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，
如果 username 不同空时还要加入用户名作为条件。

<select id="findByUser" resultType="user" parameterType="user">
    select * from user where 1=1
    <if test="username!=null and username != '' ">
        and username like  '%${username}%'
    </if> <if test="address != null">
        and address like   '%${address}%'
    </if>
</select>

<if>标签的 test 属性中写的是对象的属性名

动态 SQL 之<where>标签

为了简化上面 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发。

<!-- 根据用户信息查询 --> 
<select id="findByUser" resultType="user" parameterType="user"> 
    select * from user
    <where> 
        <if test="username!=null and username != '' ">
            and username like #{username}
        </if> 
        <if test="address != null">
            and address like #{address}
        </if>
    </where>
</select>

动态标签之<foreach>标签

<!-- 查询所有用户在 id 的集合之中 --> 
<select id="findInIds" resultType="user" parameterType="queryvo">
    <!-- select * from user where id in (1,2,3,4,5); --> 
    <include refid="defaultSql"></include>
    <where> 
        <if test="ids != null and ids.size() > 0"> 
            <foreach collection="ids" open="id in ( " close=")" item="uid" separator=",">
            #{uid}
            </foreach>
        </if>
    </where>
</select>

<foreach>标签用于遍历集合，它的属性：

• collection:代表要遍历的集合元素，注意编写时不要写#{}
• open:代表语句的开始部分
• close:代表结束部分
• item:代表遍历集合的每个元素，生成的变量名
• sperator:代表分隔符

Mybatis 中简化编写的 SQL 片段

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的。

<!-- 抽取重复的语句代码片段 -->
<sql id="defaultSql">
  select * from user
</sql>

<!-- 配置查询所有操作 --> 
<select id="findAll" resultType="user"> 
    <include refid="defaultSql"></include>
</select>

<!-- 根据 id 查询 --> 
<select id="findById" resultType="UsEr" parameterType="int">
    <include refid="defaultSql"></include>
    where id = #{uid}
</select>

Mybatis 缓存

像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提
高性能。
Mybatis 中缓存分为一级缓存，二级缓存

微信截图_20210303141544.png

Mybatis 一级缓存

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等

Mybatis 二级缓存

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个
SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的

在 SqlMapConfig.xml 文件开启二级缓存

<settings>
<!-- 开启二级缓存的支持 --> 
<setting name="cacheEnabled" value="true"/>
</settings>

因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为
false 代表不开启二级缓存。

配置相关的 Mapper 映射文件

<cache>标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

<?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.itheima.dao.IUserDao">
<!-- 开启二级缓存的支持 -->
<cache></cache>
</mapper>

配置 statement 上面的 useCache 属性

将 UserDao.xml 映射文件中的<select>标签中设置 useCache=”true”代表当前这个 statement 要使用
二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

<!-- 根据 id 查询 --> 
<select id="findById" resultType="user" parameterType="int" useCache="true">
  select * from user where id = #{uid}
</select>

当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化
方式来保存对象