嘿！Mybatis

简介

什么是Mybatis

• MyBatis 是一款优秀的持久层框架
• 它支持自定义 SQL、存储过程以及高级映射。
• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
• MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。
• 2013年11月迁移到Github。

如何获得Mybatis?

• Maven仓库

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

• Github：https://github.com/mybatis/mybatis-3/releases

• 中文文档：https://mybatis.org/mybatis-3/zh/index.html

持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库(JDBC)，io文件持久化。
• 生活：冷藏,罐头。

为什么需要持久化？

• 有一些对象，不能让他丢掉。

• 内存太贵了(外在原因)

持久层

Dao层，Service层，Controller层....

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

为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中。
• 方便
• 传统的JDBC代码太复杂了。简化。框架。自动化。
• 不用Mybatis也可以。更容易上手。技术没有高低之分，只有使用这项技术的人有高低之分
• 优点：
  • 简单易学
  • 灵活
  • 降低sql与程序代码的耦合，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。

最重要的一点：使用的人多！

第一个Mybatis程序

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

搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`; 

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

INSERT INTO `user` (`id`,`name`,`pwd`)VALUES
(1,'魏延','123456'),
(2,'马超','232315'),
(3,'赵云','123216');

新建项目

1.新建一个普通的maven项目

2.删除src目录

3.导入maven依赖

<!--导入依赖-->
    <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.4.6</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
    </dependencies>

创建一个模块

• 编写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核心配置文件-->
<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;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

      <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/wow/dao/UserMapper.xml"/>
    </mappers>

</configuration>

• 编写mybatis的工具类

public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static{
        try {
            //使用Mybatis第一步:获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
    * 既然有了 SqlSessionFactory，顾名思义。
    * 我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    * 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    * */
    public static SqlSession getSqlSession(){
        return  sqlSessionFactory.openSession();      //return 中可以传参数true 即设置为自动提交事务 也可以不设置 后面会提到
    }

}

编写代码

• 实体类

//实体类
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 + '\'' +
                '}';
    }
}

• Dao接口

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

• 接口实现类由原来的UserDaoImpl转变为一个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.wow.dao.UserDao">

    <!--select查询语句-->
    <select id="getUserList" resultType="com.wow.pojo.User">
        select * from user
    </select>
</mapper>

测试

注意点（可能会报错）：

MapperRegistry是什么？

核心配置文件中注册mappers

• junit测试

public class UserDaoTest {
    @Test
    public void Test1(){

        //第一步：获得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();
    }
}

记录两个坑：第一个异常：

第二个异常：

因为IDEA的Maven是不会编译src的java目录的xml文件，所以在Mybatis的配置文件中找不到xml文件！

我的项目文件目录：

如果建立的是普通的java项目src下的xml文件是可以读到的：

解决方法：在pom.xml文件中添加就应该解决了

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

CRUD

namespace

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

select

选择,查询语句：

• id：就是对应的namespace中的方法名；
• resultType：SQL语句执行的返回值；
• parameterType：参数类型；

1.编写接口

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

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

下面sql语句中mybatis.user是在IDEA中已经连接上数据库了

没有连接的话需要写原生的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.wow.dao.UserMapper">

    <!--select查询语句-->
    <select id="getUserList" resultType="com.wow.pojo.User" >
        select * from mybatis.user
    </select>

    <select id="getUserById" parameterType="int" resultType="com.wow.pojo.User">
        select * from  mybatis.user where id = #{id}
    </select>

</mapper>

3.测试

 //第一步：获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper 查询所有用户信息
        UserMapper userDao = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
		//根据用户id查询
 		 User user = mapper.getUserById(1);

        System.out.println(user);

        //关闭sqlSession
        sqlSession.close();

Insert

Xml:

 <insert id="addUser" parameterType="com.wow.pojo.User" >
        insert into mybatis.user (id, name, pwd) values(#{id},#{name},#{pwd})
    </insert>

测试：

SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        int i = mapper.addUser(new User(4, "吕布", "1231325"));

        if (i > 0) {
            System.out.println("插入成功！");
        }
        sqlSession.commit();
        sqlSession.close();

update

 <update id="updateUser" parameterType="com.wow.pojo.User">
        update mybatis.user set name= #{name},pwd=#{pwd} where id = #{id}
 </update>

Delete

<delete id="deleteUser" parameterType="int">
        delete  from  mybatis.user where id = #{id}
    </delete>

注意点：

• 增删改需要提交事务！

分析错误

• 标签不要匹配错
• resource绑定mapper，需要使用路径:xxx/xxx/xxx/xxx.xml
• 程序匹配文件必须符合规范！(如果有异常的话从后往前读)
• NullPointerException,没有注册到资源！
• 输出的xml文件中存在中文乱码问题！
• maven资源没有导出！

万能的Map

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

 //万能的Map
    int addUser2(Map<String,Object> map);

<insert id="addUser2" parameterType="map" >
        insert into mybatis.user (id, pwd) values(#{userid},#{password})
    </insert>

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

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

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("userid",8);
        map.put("password","123547");
        mapper.addUser2(map);
        sqlSession.commit();
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可！【parameterType="map" 】

对象传递参数，直接在sql中取对象的属性即可！【parameterType="Object" 】

只有一个基本类型参数的情况下，可以直接在sql中取到！

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

模糊查询

模糊查询怎么写？

1.Java代码执行的时候，传递通配符 % %

List<User> userList = userDao.getUserLike("%布%");

//查询结果
/*
User{id=1, name='吕布', pwd='203457'}
User{id=5, name='布小蛮', pwd='667841'}
*/

2.在sql拼接中使用通配符！

<select id="getUserLike" resultType="com.wow.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%"
    </select>

List<User> userList = userDao.getUserLike("布");
/*
查询结果
User{id=1, name='吕布', pwd='203457'}
User{id=5, name='布小蛮', pwd='667841'}
*/

配置解析

核心配置文件

• mybatis-config.xml
• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
• configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
      • transactionManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识)
  • mappers（映射器)

环境配置（environments）

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

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

学会使用配置多套运行环境！

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

属性（properties）

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

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

编写一个配置文件

db.properties

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&userUnicode=true&characterEncoding=UTF-8
db.user=root
db.password=root

在核心配置文件中引入

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

类型别名（typeAliases）

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

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

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写！

 <typeAliases>
        <package name="com.wow.pojo"/>
 </typeAliases>

在实体类比较少的情况下，使用第一种。

如果实体类比较多，建议第二种。

第一种可以DIY(自定义)别名，第二种不能DIY，如果非要改，需要在实体类上增加注解:

@Alias("user")
public class User {
    ...
}

设置

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

其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件：

方式一：

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/wow/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper class="com.wow.dao.UserMapper"/>
    </mappers>

注意点：

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

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

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <package name="com.wow.dao"/>
    </mappers>

注意点：

• 接口和它的Mapper配置文件必须同名！
• 接口和它的Mapper配置文件必须在同一个包下！
• 保证UserMapper接口和UserMapper.xm改为一致，并在同一包下！

作用域（Scope）和生命周期

生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder：

• 一旦创建了 SqlSessionFactory，就不再需要它了。
• 局部变量

SqlSessionFactory：

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

SqlSession：

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

这里的每一个Mapper，就代表了一个具体的业务！

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

问题

数据库中的字段：

新建一个项目，拷贝之前的，情况测试实体类字段不一致的：

//实体类
public class User {

    private int id;
    private String name;
    private String password;
}

测试出现问题：

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

解决方案:

• 起别名

<select id="getUserById" parameterType="int" resultType="wow.pojo.User">
        select id,name,pwd as password from  mybatis.user where id = #{id}
    </select>

resultMap

结果集映射：

id name pwd

id name password

<!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <!--column：数据库中的字段,property：实体类的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>

    <select id="getUserById"  resultMap="UserMap">
        select * from  mybatis.user where id = #{id}
    </select>

• ResultMap 元素是 MyBatis 中最重要最强大的元素
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
• 你不需要显式配置 ResultMap，这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。
• 如果这个世界总是这么简单就好了。

日志

日志工厂

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

曾经：sout，debug

现在：日志工厂来实现

• SLF4J
• LOG4J 【掌握使用】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握使用】
• NO_LOGGING

在mybatis中具体使用哪一个日志实现，在设置中设定！

STDOUT_LOGGING 标准日志输出

在mybatis核心配置文件中，配置我们的日志!

<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

LOG4J

什么是log4j?

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

1.先导入log4j的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2.log4j.properties

#将等级为DEBUG的日志信息输出到console和file这个两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file
#log4j.ignoreTCL=true
#控制台输出的相关设置
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.RollingCalendar
log4j.appender.file.File = ./log/kuang.log
log4j.appender.file.MaxFilesSize = 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为日志的实现

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

4.Log4j的使用，测试运行

简单使用

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

2.日志对象，参数为当前类class

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

3.日志级别

@Test
    public void testLog4j(){
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }

分页

为什么要分页？

• 减少数据的处理量

使用Limit分页

语法：SELECT * from 表名 limit startIndex,pageSize;
select * from user limit 3; #[0,n]

使用mybatis实现分页，核心SQL

1.接口

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

2.Mapper.xml

<!--结果集映射-->
    <resultMap id="UserMap" type="com.kuang.pojo.User">
        <!--column=数据库中的字段,property=实体类的属性-->
        <!--<result column="id" property="id"/>-->
        <!--<result column="name" property="name"/>-->
        <result column="pwd" property="password"/>
    </resultMap>

  <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from mybatis.user limit #{startIndex},#{pageSize};
    </select>

3.Demo

@Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",1);
        map.put("pageSize",2);
        List<User> list = mapper.getUserByLimit(map);
        for (User user : list) {
            System.out.println(user);
        }
          sqlSession.close();
    }

RowBounds分页

​不在使用SQL实现分页

1.接口

//分页2
    List<User> getUserByRowBounds();

2.Mapper.xml

<!--分页2-->
    <select id="getUserByRowBounds"  resultMap="UserMap">
        select * from mybatis.user
    </select>

3.demo

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

        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 3);

        //通过Java代码层面实现分页
        List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds", null, rowBounds);

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

分页插件

使用注解开发

面向接口编程

• 在之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
• 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体实现，大家都遵守共同的标准，使得开发变得容易，规范性更好。
• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了。
• 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作。面向接口 编程就是指按照这种思想来编程。

关于接口的理解

• 接口更深层次的理解，应是定义(规范,约束)与实现(名实分离的原则)的分离。
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两种：
  • 第一类是对一个个体的抽象，它可对应一个抽象体(abstract class)。
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面(interface)。
  • 一个个体有可能有多个抽象面，抽象体和抽象面是有区别的。

三个面向区别

• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。
• 面向过程是指，我们考虑问题时，以一个具体的流程(事务过程)为单位，考虑它的实现。
• 接口设计与非接口设计是针对复用技术而言的，与面向对象(过程)不是一个问题，更多的体现就是对系统整体的架构

使用注解开发

1.注解在接口上实现

public interface UserMapper {
   @Select("select * from user")
   public List<User> getUsers();
}

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

<mappers>
        <!--<mapper resource="com/wow/dao/UserMapper.xml"/>-->
        <mapper class="kuang.dao.UserMapper"/>
        <!--<package name="com.kuang.dao"/>-->
    </mappers>

3.demo

 @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

本质：反射机制实现

底层：动态代理！

Mybatis详细的执行流程！

CRUD

可以直接在工具类创建的时候实现自动提交事务！

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

编写接口，增加注解

public interface UserMapper {
   @Select("select * from user")
   public List<User> getUsers();

   // 方法存在多个参数，所有的参数前面必须加上@Param("id")注解
   @Select("select * from user where id = #{id}")
   User getUserByID(@Param("id") int id);

   @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);

   @Delete("delete from user where id = #{uid}")
   int deleteUser(@Param("uid") int id);
}

测试的话：

【注意：必须要将接口注册绑定到核心配置文件中！】

关于@Param()注解

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

关于 #{} 与 ${}的区别

• 用来传入参数，sql在解析的时候会加上" ",当成字符串来解析 ，如这里 u_id = "uid"。
• #{}能够很大程度上防止sql注入。
• ${}方式无法防止sql注入;

多对一处理

多对一(例)：

• 多个学生，对应一个老师
• 对于学生而言，关联..多个学生，关联一个老师【多对一】
• 对于老师而言，集合，一个老师，有很多学生【一对多】

SQL：

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');

测试环境搭建

• 新建实体类Teacher，Student

public class Student {

    private int id;
    private String name;
    private Teacher teacher ;

    /*
    get,set,toString...
    */
}

public class Teacher {
    private int id;
    private String name;
}
/*
	get,set,toString..
*/

• 新建相对应的Mapper接口
• 新建Mapper.xml文件
  
  
• 在核心配置文件中绑定注册我们的Mapper接口或者文件！
• 测试

按照查询嵌套处理

<mapper namespace="kuang.dao.StudentMapper">
    <!--
        思路：
            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>
</mapper>

按照结果嵌套处理

 <!--按照结果嵌套处理-->
    <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="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

一对多

例：一个老师对应多个学生

对于老师而言，就是一对多的关系

环境搭建

实体类

public class Student {
    private int id;
    private String name;
    private int tid;

    /*
    set,get,toString..
    */
}

public class Teacher {
    private int id;
    private String name;
    //一个老师有多个学生
    private List<Student> students;

    /*
    set,get,toString...
    */
}

接口

public interface TeacherMapper {

    //获取指定老师下的所有学生及老师信息
    Teacher getTeacher(@Param("tid") int id);

    Teacher getTeacher2(@Param("tid") int id);
}

按照结果嵌套处理

<mapper namespace="kuang.dao.TeacherMapper">
<!--按结果嵌套查询-->
    <select id="getTeacher" resultMap="StudentTeacher">
        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="StudentTeacher" 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>
    </mapper>

按照查询嵌套处理

<mapper namespace="kuang.dao.TeacherMapper">
    <!--按照嵌套查询-->
    <select id="getTeacher2" resultMap="StudentTeacher2">
        select * from teacher where id = #{tid}
    </select>

    <resultMap id="StudentTeacher2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>

    <select id="getStudentByTeacherId" resultType="Student">
        select * from student where tid = #{tid}
    </select>
</mapper>

小结

1.关联 - association 【多对一】

2.集合 - collection【一对多】

3.javaType & ofType

​ 1.javaType 用来指定实体类中属性的类型

​ 2.ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型！

注意点：

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志 ，建议使用Log4j

慢SQL的问题

面试高频

• Mysql引擎
• InnoDB底层原理
• 索引
• 索引优化

动态SQL

什么是动态SQL：动态SQL就是指根据不同的条件生成不同的SQL语句

利用动态 SQL，可以彻底摆脱这种痛苦。

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

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

搭建环境

SQL语句：

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.编写实体类

public class Blog {
    private int id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

    /**
    get ， set  ， toString...
    */
}

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

IF

<mapper namespace="com.kuang.dao.BlogMapper">
    <insert id="addBlog" parameterType="blog">
        insert into blog values (#{id},#{title},#{author},#{createTime},#{views})
    </insert>

    <select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog where 1 = 1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>
</mapper>

choose (when, otherwise)

<select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from 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>

trim (where, set)

<select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog
        <where>
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
        </where>
    </select>

<update id="updateBlog" parameterType="map">
        update blog
        <set>
            <if test="title != null">
                title = #{title},
            </if>
            <if test="author != null">
                author = #{author}
            </if>
        </set>
        where id = #{id}
    </update>

所谓的动态SQL，本质还是SQL语句，只是我们可以再SQL层面，去执行一个逻辑代码

SQL片段

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

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

<sql id="ifif">
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </sql>

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

<select id="queryBlogIf" parameterType="map" resultType="blog">
        select * from blog
       <where>
           <include refid="ifif"></include>
       </where>
    </select>

注意事项：

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

Foreach

测试：定义接口

//查询1、2、3号记录的博客
    List<Blog> queryBlogForeach(Map map);

Mapper

 <!--
        select * from blog where 1 = 1 and (id=1 or id=2 or id=3)

        现在往这个接口中传一个map,这个map中可以存在一个集合
    -->
     <select id="queryBlogForeach" parameterType="map" resultType="blog">
         select * from blog
         <where>
             <foreach collection="ids" item="id" open="(" close=")" separator="or">
                 id = #{id}
             </foreach>
         </where>
     </select>

测试：

 @Test
    public void test3(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        ArrayList list = new ArrayList();
            list.add(1);
            list.add(2);
            list.add(3);

        Map map = new HashMap();
            map.put("ids",list);

        List<Blog> blogs = mapper.queryBlogForeach(map);

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

结果：

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

建议：

• 现在MySQL中写出完整的SQL，在对应的去修改成为我们的动态sql实现通用即可！！

缓存

简介

1.什么是缓存[Cache]？

• 存在内存中的临时数据。
• 将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)中查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2.为什么使用缓存？

• 减少和数据库的交互次数，减少系统开销，提高系统效率。

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

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

Mybatis缓存

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

一级缓存

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

测试：

1.开启日志

2.测试在一个Session中查询两次相同记录

3.查看日志输出

缓存失效的情况：

1.查询不同的东西

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

3.查询不同的Mapper.xml

4.手动清理缓存！

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

一级缓存相当于一个map

二级缓存

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

步骤：

1.开启全局缓存

 <settings>
       <!--显示的开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>
</settings>

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

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

也可以自定义参数

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

3.测试：

​ 可能出现的问题：如果在中没有设置相关参数可能会报错，得需要将实体类序列化！否则会报错。

Caused by: java.io.NotSerializableException: com.kuang.pojo.User

小结：

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

缓存原理