Mybatis

什么是 MyBatis？

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。

MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。

MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

第一个Mybatis程序

创建数据库环境

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


INSERT into `user`(`id`,`name`,`pwd`) VALUES
(1,'ylc','123'),
(2,'ww','123'),
(3,'张三','123')

新建一个项目

1.建一个普通的maven项目

2.删除src目录，作为父工程使用

3.去官网下载Mysql驱动jar包，在pom文件中写入

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ylc</groupId>
    <artifactId>Mybatis-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Mybatis-01</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

创建一个模块

编写Mybatis的核心配置文件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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value=""/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>
     <mappers>
        <mapper resource="com/ylc/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

编写Mybatis工具类MybatisUtils

public class MybatisUtils {
    public  static SqlSessionFactory sqlSessionFactory=null;
    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就可以创建实例了
    public  static SqlSession getSqlSeeionFactory()
    {
        SqlSession sqlSession = sqlSessionFactory.openSession();//这里设置为true可以自动提交事务
        return  sqlSession;
    }
}

编写代码

实体类

package com.ylc.pojo;

public class User {
    private  int id;
    private  String name;
    private  String pwd;

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

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

接口实现配置文件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">
<!--namespace绑定一个对应的Dao、Mapper接口 resultType；返回结果类型-->
<mapper namespace="com.ylc.Dao.UserDao">
    <select id="getUserlist" resultType="com.ylc.pojo.User">
        select * from student.user
    </select>
</mapper>

student是数据库名

生成测试类

public class UserDaoTest{
    @Test
    public void testGetUserlist() {
        //获取sqlSeeionFactory对象
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        //执行sql
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);

         //方式二
        //List<User> userlist = sqlSeeionFactory.selectList("com.ylc.Dao.UserDao.getUserlist");
        List<User> userlist = mapper.getUserlist();
        for (User user : userlist) {
            System.out.println(user);
        }
        sqlSeeionFactory.close();

    }
}

整体项目结构

增删改实现

接口

public interface UserDao {
    List<User> getUserlist();

    User getUserByID(int id);

    int AddUser(User user);

    int UpdateUser(User user);

    int DeleteUser(int id);
}

Select

• id：就是namespace中的方法名

• resultType：sql语句执行的返回值

• parameterType:传入参数类型

    <select id="getUserByID" resultType="com.ylc.pojo.User" parameterType="int">
          select * from student.user where id = #{id}
      </select>
  

  @Test
  public void testTestGetUserByID() {
      SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory();
      UserDao mapper = sqlSeenFactors.getMapper(UserDao.class);
      User userById = mapper.getUserByID(1);
      System.out.println(userById);
  
      sqlSeenFactors.close();
  }
  

Insert

<insert id="AddUser"  parameterType="com.ylc.pojo.User" >
    insert into student.user(id,name,pwd) values(#{id},#{name},#{pwd});
</insert>

    @Test
    public void addUser() {
        User user1=new User(4,"yy","123456");
        SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeenFactors.getMapper(UserDao.class);
        Object object = mapper.AddUser(user1);
        sqlSeenFactors.commit();
        System.out.println(object);
        sqlSeenFactors.close();
    }

Update

<update id="UpdateUser" parameterType="com.ylc.pojo.User">
    update student.user set name=#{name},pwd=#{pwd}  where id=#{id};
</update>

public  void  UpdateUser()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
    System.out.println(mapper);
    int updateUser = mapper.UpdateUser(new User(3, "yyy", "11111"));
    sqlSeeionFactory.commit();
    System.out.println(updateUser);
    sqlSeeionFactory.close();
}

Delete

<delete id="DeleteUser" parameterType="int">
    delete from student.user where id=#{id};
</delete>

@Test
public void  DeleteUser()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
    int i = mapper.DeleteUser(4);
    sqlSeeionFactory.commit();
    System.out.println(i);
    sqlSeeionFactory.close();
}

核心配置文件

mybatis-config.xml

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

环境变量environment

Mybatis可以配置多个环境，但是SqlsessionFactory实例只能选择一个环境

默认环境设置，更改default为其他environment的id就可以了

<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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="19990729Yy"/>
        </dataSource>
    </environment>
    <environment id="text">
        <transactionManager type=""></transactionManager>
        <dataSource type=""></dataSource>
    </environment>
</environments>

transactionManager事务管理器

有JDBC和MANAGED两种类型:

• JDBC：使用了JDBC的提交和回滚
• MANAGED：配置几乎没做什么, 默认情况下它会关闭连接

dataSource数据源

有三种数据类型:UNPOOLED、POOLED、JNDI

默认的是POOLED

property属性

可以通过properties来引用配置文件

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

在核心配置文件中映入

    <!--引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="pwd" value="11111"/>
    </properties>

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

类型别名typeAliases

存在的意义仅在于用来减少类完全限定名的冗余

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

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

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：

@Alias("author")
public class Author {
}

设置Setting

映射器Mappers

注册绑定Mapper文件

方式一：对于相对路径的资源引用

<mappers>
    <mapper resource="com/ylc/Dao/UserMapper.xml"/>
</mappers>

方式二：通过Class文件绑定注册

接口和Mapper文件必须同名和在同一个包下

<mappers>
    <mapper resource="com.ylc.Dao.UserMapper"/>
</mappers>

方式三：使用扫描包注入

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

接口和Mapper文件必须同名和在同一个包下

生命周期和作用域

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

SqlSessionFactoryBuilder：

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

SqlSessionFactory：

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

SqlSession

• 连接到连接池的一个请求！

• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

• 用完之后需要赶紧关闭，否则资源被占用！

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

结果映射

数据库中字段和实体类中字段不对应，会找不到数据，因为类型处理器会直接找数据库中的字段

解决方法：起别名

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

但是这个方法还不太灵活

<!--结果集映射-->
<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 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

日志

如果数据库发生了异常怎么可以查看到，需要排错，这时候就需要日志

具体在核心配置文件中设置，但注意日志名称不能输入错误

标准STDOUT_LOGGING日志配置：

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

可以查看到数据库连接情况，以及sql语句和传入的参数，以及返回行数

LOG4J

什么是Log4j？

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

导入Log4j包，在Maven官网找到包

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

log4j配置文件

#将等级为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/kuang.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

配置实现

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

最后效果

基本使用

如果要使用LOG4J，需要导入import org.apache.log4j.Logger;

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

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

public class UserDaoTest {
    static Logger logger = Logger.getLogger(UserDaoTest.class);
    @Test
    public  void  TextLOG4J()
    {
        logger.info("进入了TextLOG4J");
        logger.debug("进入了TextLOG4J");
        logger.error("进入了TextLOG4J");
    }
}

分页

使用limit分页

接口

void gerLimitUser();

Mapper.xml

    <select id="gerLimitUser" parameterType="map" resultType="com.ylc.pojo.User">
        select * from student.user limit  #{startindex},#{pagesize}
    </select>

测试

    @Test
    public  void  gerLimitUser()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);

        HashMap<String, Integer> map = new HashMap<>();
        map.put("startindex",2);
        map.put("pagesize",2);
        List<User> users = mapper.gerLimitUser(map);
        for (User user : users) {
            System.out.println(user);
        }
        sqlSeeionFactory.close();
    }

使用RowBounds分页

不再使用SQL实现分页

接口

List<User> getUserByRowBounds();

mapper.xml

<select id="getUserByRowBounds" resultMap="UserMap">
    select * from  student.user
</select>

测试

@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(0, 2);

List<User> userList = sqlSession.selectList("com.ylc.dao.UserMapper.getUserByRowBounds",null,rowBounds);

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

使用插件分页

PageHelper

使用注解开发

在接口上写一个注解

@Select("select * from student.user")
List<User> getUsers();

测试

    @Test
    public  void  getUsers()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }

这样的注解适合简单的sql语句，复杂的还是适合放在XMl里面

Lombok

Project Lombok是一个java库，它可以自动插入编辑器和构建工具，为java增添乐趣。永远不要再编写另一个getter或equals方法，只要有一个注释，您的类就有一个功能齐全的构建器、自动记录变量等等。

比如我们的类中手写了大量的get、set方法，Lombok可以帮助我们简化操作

安装Lombok

导入LomBoK的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

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

测试：

在我们类名前面加上@Data就可以自动生成相应的结构

优点:

能通过注解形式自定生成构造器：无参构造、get set、hascode、ToString等等

让代码更加简洁，便于维护

缺点：

不支持多种参数构造去重载

降低了源代码的可读性和完整性

多对一

关联查询

配置文件

<?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>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="19990729Yy"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="StudentMapper.xml"/>
        <mapper resource="TeacherMapper.xml"/>
    </mappers>
</configuration>

proj类

package com.ylc.pojo;
import lombok.Data;

@Data
public class Student {
    private  int id;
    private String name;
    private  Teacher teacher;
}

package com.ylc.pojo;
import lombok.Data;

@Data
public class Teacher {
    private  int id;
    private  String name;
}

StudentMapper.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.ylc.Dao.StudentMapper">

    <select id="getStudent" resultMap="StudentTeacher">
      select * from student.student
    </select>

    <resultMap id="StudentTeacher" type="com.ylc.pojo.Student">
        <result property="id" column="id"></result>
        <result property="name" column="name"></result>
        <association property="teacher" column="tid" javaType="com.ylc.pojo.Teacher" select="getTeacher">
        </association>
    </resultMap>

    <select id="getTeacher" resultType="com.ylc.pojo.Teacher">
        select * from student.teacher where id = #{id}
    </select>
</mapper>

测试类

    @Test
    public void getStudent()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class);
        List<Student> student = mapper.getStudent();
        for (Student student1 : student) {
            System.out.println(student1);
        }
        sqlSeeionFactory.close();
    }

嵌套查询

 <select id="getstudent2" resultMap="StudentTeacher2">
        select s.id sid, s.name sname, t.name tname,t.id tid
        from student.student s,student.teacher t
        where s.tid = t.id ;
    </select>
    <resultMap id="StudentTeacher2" type="com.ylc.pojo.Student">
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <association property="teacher" javaType="com.ylc.pojo.Teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>

@Test
public  void  getstudent2()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class);
    List<Student> student = mapper.getstudent2();
    for (Student student1 : student) {
        System.out.println(student1);
    }
    sqlSeeionFactory.close();
}

一对多

实体类

@Data
public class Teacher {
    private  int id;
    private  String name;
    private List<Student> studentList;
}

@Data
public class Student {
    private  int id;
    private String name;
    private  int  tid;
}

接口

public interface TeacherMapper {
    Teacher getTeacher(@Param("tid") int id);
}

mapper.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.ylc.Dao.TeacherMapper">

    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname, t.name tname,t.id tid
        from student.student s,student.teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>
    <resultMap id="TeacherStudent" type="com.ylc.pojo.Teacher">
        <result column="tid" property="id"></result>
        <result column="tname" property="name"></result>
        <collection property="studentList"  ofType="com.ylc.pojo.Student">
            <result column="sid" property="id"></result>
            <result column="sname" property="name"></result>
            <result column="tid" property="tid"></result>
        </collection>
    </resultMap>
</mapper>

测试类

@Test
public void getTeacher() {
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    TeacherMapper mapper = sqlSeeionFactory.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher(1);
    System.out.println(teacher);
    sqlSeeionFactory.close();
}

动态SQL

IF

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

choose (when, otherwise)

    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from mybatis.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 * from mybatis.blog
<where>
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</where>

<update id="updateBlog" parameterType="map">
    update mybatis.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="if-title-author">
       <if test="title != null">
           title = #{title}
       </if>
       <if test="author != null">
           and author = #{author}
       </if>
   </sql>
   

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

   <select id="queryBlogIF" parameterType="map" resultType="blog">
       select * from mybatis.blog
       <where>
           <include refid="if-title-author"></include>
       </where>
   </select>
   

注意事项：

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

Foreach

select * from user where 1=1 and 

  <foreach item="id" collection="ids"
      open="(" separator="or" close=")">
        #{id}
  </foreach>

(id=1 or id=2 or id=3)

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

        我们现在传递一个万能的map ， 这map中可以存在一个集合！
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from mybatis.blog

    <where>
        <foreach collection="ids" item="id" open="and (" close=")" separator="or">
            id = #{id}
        </foreach>
    </where>

</select>

缓存

经常查询并且不经常改变的数据。可以使用缓存

MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存

• 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）

• 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。

• 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

缓存失效的情况：

1. 查询不同的东西

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

   

3. 查询不同的Mapper.xml

4. 手动清理缓存！

   

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

一级缓存就是一个Map。

二级缓存

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

步骤：

1. 开启全局缓存

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

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

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

   也可以自定义参数

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

3. 测试

   1. 问题:我们需要将实体类序列化！否则就会报错！

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

小结：

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

缓存原理

自定义缓存-ehcache

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存

要在程序中使用ehcache，先要导包！

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

在mapper中指定使用我们的ehcache缓存实现！

<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->

</ehcache>