Mybatis入门笔记(idea)

MyBatis 是一款优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的实体类【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
2013年11月迁移到Github .
Mybatis官方文档 : mybatis – MyBatis 3 | 简介
GitHub : https://github.com/mybatis/mybatis-3

1.1 持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。
在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。

（其实也就是为了数据一直能够保存）

1.2 持久层

什么是持久层？

完成持久化工作的代码块 . ----> dao层【DAO (Data Access Object) 数据访问对象】
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】

说白了就是一个框架，我们只需要在框架里填东西即可，无需在一遍遍的重复了。

1.3 为什么需要Mybatis

Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等... , 通过框架可以减少重复代码,提高开发效率 .
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别
MyBatis的优点
- 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
- 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
- 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
- 提供xml标签，支持编写动态sql。

2.第一个Mybatis程序

步骤：搭建环境-->导入Mybatis--->编写代码--->测试

程序用idea和mysql编写，并使用了Maven

2.1 搭建环境

搭建好的的文件目录如下：

2.1.1 创建数据库，数据库代码如下

CREATE DATABASE mybatis;
 DROP TABLE IF EXISTS `user`;
 
 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,'关羽','12345'),(2,'杜甫','123456'),(3,'白居易','1234567'),(4,'王维','123456');

2.1.2 在pom.xml中导入相关包

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>UserDaotest</scope>
        </dependency>
    </dependencies>

2.1.3 编写Mybatis核心配置文件(mybtis-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://localhost:3306/mysql?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                 <property name="username" value="root"/>
                 <property name="password" value="123456"/>
             </dataSource>
         </environment>
     </environments>
 <mappers>
  <mapper resource="UserDao.xml"/>
 </mappers>
 
 </configuration>

注意事项：

当连接数据库时 url的value是jdbc:mysql://localhost:3306/mysql?useSSL=false&useUnicode=true&characterEncoding=utf8用的是mysql时，则操作表的语句是库名.表名(本例中用的是mybatis.user)。如果value值是jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8用的是mybatis即库名时，则操作表的语句是要操作的表名(即user)
每一个mybatis.xml中必须要有<mappers>映射器，其中映射的是sql语句。

2.1.4 编写Mybatis工具类(mybatisUntils.class)

package com.fbw.untils;
 
 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 
 import java.io.IOException;
 import java.io.InputStream;
 
 //获取sqlSessionFactory
 public class mybatisUntils {
 
     private static SqlSessionFactory sqlSessionFactory;
 
     static {
         try {
             //使用mybatis第一步：获取sqlsessionFactory对象
             String resource = "mybatis-config.xml";
             InputStream inputStream = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     //第二步：有了sqlsessionFactory，可以用它来获得sqlsession实例
     //sqlsession完全包含了面向数据库执行SQL的所有方法
     public static SqlSession getSqlsession() {
 //        SqlSession sqlSession = sqlSessionFactory.openSession();
 //        return sqlSession;
        return sqlSessionFactory.openSession();
     }
 }

用sqlsessionFactory获得sqlsession实例来对库进行操作

2.1.5 创建实体类 User.class

package com.fbw.pojo;
 
 import lombok.Data;
 
 @Data
 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;
     }
 }

用了lombok插件简化了get set toString 有参无参的方法，下面详细说。

2.1.6 编写接口类 UserDao.interface

package com.fbw.Dao;
 
 import com.fbw.pojo.User;
 
 import java.util.List;
 import java.util.Map;
 
 public interface UserDao {
    //模糊查询
    List<User> getUserLike(String name);
    //查询所有的用户
    List<User> getUserlist();
    //根据id查询用户
    User selectUserById(int id);
    //添加用户
    int addUser(User user);
    //修改用户信息
    int UpdateUser(User user);
    //删除用户
    int deleteUser(int id);
    //当参数过多时可以用Map
    User selectByIdNp2(Map<String,Object> map);
 }

定义了各种查询的方法，方法的实现在UserDao.xml中

2.1.7 编写UserDao.xml配置文件

resultType的值是接口中函数的类型

parameterType的值是接口中函数传递的值的类型

resultMap的值是当实体类的字段和数据库中字段不一样时，定义的resultMap的id值

<?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.fbw.Dao.UserDao">
     <select id="getUserlist" resultType="com.fbw.pojo.User">
 select * from mybatis.user
 </select>
     <select id="selectUserById" resultType="com.fbw.pojo.User">
         select *from mybatis.user where id=#{id}
     </select>
     <insert id="addUser" parameterType="com.fbw.pojo.User">
         insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd})
     </insert>
     <update id="UpdateUser" parameterType="com.fbw.pojo.User">
         update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
     </update>
     <delete id="deleteUser" parameterType="com.fbw.pojo.User">
         delete from mybatis.user where id=#{id}
     </delete>
     <select id="selectByIdNp2" parameterType="map" resultType="com.fbw.pojo.User">
         select *
         from mybatis.user where name=#{username} and pwd=#{password}
     </select>
     <select id="getUserLike" resultType="com.fbw.pojo.User">
 select * from mybatis.user where name like #{value}
     </select>
 </mapper>

实现了UserDao接口中的方法

2.1.8 编写测试类

package com.fbw.dao;
 
 import com.fbw.Dao.UserDao;
 import com.fbw.pojo.User;
 import com.fbw.untils.mybatisUntils;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 public class test {
     @Test
     public void testgetUserList(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         List<User> userlist = mapper.getUserlist();
         for (User user : userlist) {
             System.out.println(user);
         }
         sqlsession.close();
     }
     @Test
     public void testselectUserById(){
         //获取SqlSession连接
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user=mapper.selectUserById(1);
         System.out.println(user);
         //关闭流
         sqlsession.close();
     }
     @Test
     public void testaddUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user=new User(4,"王维","123456");
         int i=mapper.addUser(user);
         System.out.println(i);
         //需要提交事务
         sqlsession.commit();
         sqlsession.close();
     }
     @Test
     public void testUpdateUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user = mapper.selectUserById(1);
         user.setName("关羽");
         int i=mapper.UpdateUser(user);
         sqlsession.commit();
         sqlsession.commit();
     }
     @Test
     public void testdeleteUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         int i = mapper.deleteUser(4);
         System.out.println(i);
         sqlsession.commit();
         sqlsession.close();
     }
     @Test
     public void testselectByIdNP2(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         Map<String,Object> map=new HashMap<String,Object>();
         map.put("username","关羽");
         map.put("password","12345");
         User user = mapper.selectByIdNp2(map);
         System.out.println(user);
         sqlsession.close();
     }
     @Test
     public void testgetUserLike(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         //别忘了通配符%value%
         List<User> userLike = mapper.getUserLike("%关%");
         for (User user : userLike) {
             System.out.println(user);
         }
         sqlsession.close();
     }
     }

基本流程就是这些，我们在需要操作其他库时可以方便很多。

3.解析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>
     <!--引入外部文件 配置属性-->
     <properties resource="db.properties">
         <property name="username" value="root"/>
         <property name="password" value="11111"/>
     </properties>
 
    <!-- 给实体类起别名-->
     <typeAliases>
         <!--指定包来起别名-->
         <!--<typeAlias type="com.fbw.pojo.User" alias="User"/>-->
         <!--指定一个包，mybatis会在包下面搜索java bean，如果没有注解则会用bean的首字母小写的非限定类名作为它的别名,有注解用注解名-->
         <!--当然用这两种的同时也可以用指定找-->
         <package name="com.fbw.pojo"/>
     </typeAliases>
 
     <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC"/>
             <dataSource type="POOLED">
                 <property name="driver" value="${driver}"/>
                 <property name="url" value="${url}"/>
                 <property name="username" value="${username}"/>
                 <property name="password" value="${password}"/>
             </dataSource>
         </environment>
     </environments>
    <!-- 相对于类路径的资源引入，-->
 <mappers>
  <mapper resource="UserDao.xml"/>
 </mappers>
     <!--使用映射器接口实现类的完全限定类名需要配置文件名称和接口名完全一致，并且位于同一目录下-->
 <!--<mappers>
     <mapper class="com.fbw.Dao.UserDao"/>
 </mappers>-->
     <!--和方式二一样-->
   <!--  <mappers>
         <package name="com.fbw.Dao"/>
     </mappers>-->
 </configuration>

3.1 mybatis配置属性

mybatis-config.xml 是mybatis系统核心配置文件
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
能配置的内容如下：

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

如果需要在configuration中配置如下属性要注意元素节点的顺序！顺序不对会报错

3.2 properties

3.2.1 引入外部文件

properties中的resource属性可以引入外部文件来简化和保护数据库，新建db.properties：

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

则在引入时就直接可以用db.properties中的名称(此时db.properties和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>
     <!--引入外部文件 配置属性-->
     <properties resource="db.properties"/>
      <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC"/>
             <dataSource type="POOLED">
                 <property name="driver" value="${driver}"/>
                 <property name="url" value="${url}"/>
                 <property name="username" value="${username}"/>
                 <property name="password" value="${password}"/>
             </dataSource>
         </environment>
     </environments>
    <!-- 相对于类路径的资源引入，-->
 <mappers>
  <mapper resource="UserDao.xml"/>
 </mappers>
 </configuration>

3.2.2 直接使用property属性配置

当然，properties中也有property属性，如果没有引入外部文件，其中的name和value值也可以设置name，url，username，password

如：

<?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>
 
     <properties resource="db.properties"/>  <properties>
         <property name="driver" value="com.mysql.jdbc.Driver"/>
         <property name="url" value="jdbc:mysql://localhost:3306/mysql?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
         <property name="username" value="root"/>
         <property name="password" value="123456"/>
     </properties>
     
     
      <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC"/>
             <dataSource type="POOLED">
                 <property name="driver" value="${driver}"/>
                 <property name="url" value="${url}"/>
                 <property name="username" value="${username}"/>
                 <property name="password" value="${password}"/>
             </dataSource>
         </environment>
     </environments>
    <!-- 相对于类路径的资源引入，-->
 <mappers>
  <mapper resource="UserDao.xml"/>
 </mappers>
 </configuration>

当同时引入外部文件和设置值时，其优先顺序是：先读取properties体内指定的属性，然后读取引入的外部文件并覆盖体内指定的属性。

3.2 setting配置日志

Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：

SLF4J
Apache Commons Logging
Log4j 2
Log4j
JDK logging

具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用

以下会实现标准日志实现和Log4j实现

3.2.1 标准日志实现

配置代码

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

输出：

会有大量输出，可以判断在哪出错

3.2.2 使用Log4j日志

1.先导入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.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

3、setting设置日志实现

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

4.测试

package com.fbw.test;
 
 import com.fbw.Dao.UserDao;
 import com.fbw.pojo.User;
 import com.fbw.untils.mybatisUntils;
 import org.apache.ibatis.session.RowBounds;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.log4j.Logger;
 import org.junit.Test;
 
 import java.util.*;
 
 public class test {
 
     //注意导包：org.apache.log4j.Logger
     static Logger logger = Logger.getLogger(test.class);
 
     @Test
     public void selectUser() {
         logger.info("info：进入selectUser方法");
         logger.debug("debug：进入selectUser方法");
         logger.error("error: 进入selectUser方法");
         SqlSession session =mybatisUntils.getSqlsession();
         UserDao mapper = session.getMapper(UserDao.class);
         List<User> users = mapper.getUserlist();
         for (User user : users) {
             System.out.println(user);
         }
         session.close();
     }
    }

看控制台输出！

使用Log4j 输出日志
可以看到还生成了一个日志的文件【需要修改file的日志级别】

3.3 typeAliases（类型别名）

3.3.1 使用type

类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。

 <!--指定包来起别名-->
         <typeAlias type="com.fbw.pojo.User" alias="User"/>

当这样配置时，User可以用在任何使用com.fbw.pojo.User的地方

如：

 <select id="selectUserById" resultType="com.fbw.pojo.User">
         select *from mybatis.user where id=#{id}
     </select>
     //可换为
  <select id="selectUserById" resultType="User">
         select *from mybatis.user where id=#{id}
     </select>

3.3.2 使用name(推荐)

每一个在包 com.fbw.pojo 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。

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

如：

<select id="selectUserById" resultType="com.fbw.pojo.User">
         select *from mybatis.user where id=#{id}
     </select>
     //可换为
  <select id="selectUserById" resultType="user">
         select *from mybatis.user where id=#{id}
     </select>

3.3.3 使用注解

若有注解，则别名为其注解值。见下面的例子：

package com.fbw.pojo;
 
 import lombok.Data;
 import org.apache.ibatis.type.Alias;
 
 @Data
 //用注解取别名,和package一块用
 @Alias("u")
 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;
     }
 }

如：

<select id="selectUserById" resultType="com.fbw.pojo.User">
         select *from mybatis.user where id=#{id}
     </select>
     //可换为
  <select id="selectUserById" resultType="u">
         select *from mybatis.user where id=#{id}
     </select>

注意的是：

当使用注解时要和package一块使用，也就是要引入

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

这时候注解的名字也就代替了类名，当不引入package时会出错。

3.4 environments(环境配置)和environment(环境变量)

environments元素

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

environments属性可以说是核心属性了

配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，必须指定其中一个为默认运行环境（通过default指定）
子元素节点：environment
- dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
- 数据源是必须配置的。
- 有三种内建的数据源类型
```
 type="[UNPOOLED|POOLED|JNDI]"）
```
- unpooled：这个数据源的实现只是每次被请求时打开和关闭连接。
- pooled：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得并发 Web 应用快速响应请求的流行处理方式。
- jndi：这个数据源的实现是为了能在如 Spring 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
- 数据源也有很多第三方的实现，比如dbcp，c3p0，druid等等....
- 详情：点击查看官方文档
- 这两种事务管理器类型都不需要设置任何属性。
- 具体的一套环境，通过设置id进行区别，id保证唯一！
- 子元素节点：transactionManager - [ 事务管理器 ]
```
 
 <transactionManager type="[ JDBC | MANAGED ]"/>
```
- 子元素节点：数据源（dataSource）

3.5 mappers（映射器）

映射器 : 定义映射SQL语句文件
既然 MyBatis 的行为其他元素已经配置完了，我们现在就要定义 SQL 映射语句了。但是首先我们需要告诉 MyBatis 到哪里去找到这些语句。Java 在自动查找这方面没有提供一个很好的方法，所以最佳的方式是告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 的 URL），或类名和包名等。映射器是MyBatis中最核心的组件之一，在MyBatis 3之前，只支持xml映射器，即：所有的SQL语句都必须在xml文件中配置。而从MyBatis 3开始，还支持接口映射器，这种映射器方式允许以Java代码的方式注解定义SQL语句，非常简洁。

3.5.1 使用映射器接口实现类的完全限定类名

<mappers>
     <mapper class="com.fbw.Dao.UserDao"/>
 </mappers>

使用class要注意需要配置文件名称和接口名完全一致，并且位于同一目录下，就是要把xml文件和要实现的接口名字一样，并且在同一文件下。

3.5.2 使用相对于类路径的资源引用(推荐使用)

 <mappers>
  <mapper resource="UserDao.xml"/>
 </mappers>

注意resource时路径要用”/“表示，如com/fbw/Dao/UserDao.xml

3.5.3 使用完全限定资源定位符（URL）

<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
 </mappers>

直接按路径去找

3.5.4 使用name属性

<mappers>
         <package name="com.fbw.Dao"/>
 </mappers>

要注意需要配置文件名称和接口名完全一致，并且位于同一目录下,要求和class一样。

4.解析实体类User.class(引入lombok)

User.class内容：

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

实体类一般都是对应数据库的字段，然后引入get、set、有参无参等方法。注意实体类中的字段最好要和数据库中的字段对应，不然的话查询的结果会是null，当然不对应的情况下也有解决的方法，那就是引入resultMap，这在解析UserDao.xml时会说到。

在我们写get、set、有参无参等方法时会感到很枯燥，这时我们就可以使用一个插件—lombok，使用lombok插件可以大大的减少我们的工作量，以下是使用lombok的步骤。（先安装Lombok的插件）

在pom.xml引入Lombok的依赖

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

在代码中增加注解

 package com.fbw.pojo;
 
 import lombok.Data;
 
 
 
 @Data
 public class User {
     private int id;
     private String name;
     private String password;
 }

这时我们可以看到，User.class中的get、set、有参无参等方法已经被写了

Lombok的其他注解：

1.@Getter/@Setter: 作用类上，生成所有成员变量的getter/setter方法；作用于成员变量上，生成该成员变量的getter/setter方法。可以设定访问权限及是否懒加载等。

2.@ToString：作用于类，覆盖默认的toString()方法，可以通过of属性限定显示某些字段，通过exclude属性排除某些字段。

3.@EqualsAndHashCode：作用于类，覆盖默认的equals和hashCode

4.@NonNull：主要作用于成员变量和参数中，标识不能为空，否则抛出空指针异常。

5.@NoArgsConstructor：生成无参构造器

6.@AllArgsConstructor：生成全参构造器

5.解析接口UserDao.interface

UserDao.interface:

package com.fbw.Dao;
 
 import com.fbw.pojo.User;
 
 import java.util.List;
 import java.util.Map;
 
 public interface UserDao {
        //模糊查询
    List<User> getUserLike(String name);
    //查询所有的用户
    List<User> getUserlist();
    //根据id查询用户
    User selectUserById(int id);
    //添加用户
    int addUser(User user);
    //修改用户信息
    int UpdateUser(User user);
    //删除用户
    int deleteUser(int id);
    //当参数过多时可以用Map
    User selectByIdNp2(Map<String,Object> map);
 
    //选择页面分页
    List<User> selectUser(Map<String,Integer> map);
 
    //使用RowBounds分页
    List<User> getUserByBounds();
 }

UserDao.interface中定义的是对数据库中的表的各种操作的方法，而实现这些方法有两种方式，一种是使用注解(不推荐)，另一种是运用xml文件来实现。

5.1使用注解来实现接口(不推荐)

首先要注意当使用注解时就不需要UserDao.xml文件了

sql 类型的注解主要分成 :
- @select ()
- @update ()
- @Insert ()
- @delete ()

1. 在接口中加入注解

@Select("select * from mybatis.user")
 List<User> getlist();

2、在mybatis-config.xml核心配置文件中注入

 <mappers>
 <!-- <mapper resource="UserDao.xml"/>-->
 <mapper class="com.fbw.Dao.UserDao"/>
 </mappers>

3.测试

import com.fbw.Dao.UserDao;
 import com.fbw.pojo.User;
 import com.fbw.untils.mybatisUntils;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;
 
 import java.util.List;
 
 public class test {
     @Test
     public void testgetlist(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         List<User> getlist = mapper.getlist();
         for (User user : getlist) {
             System.out.println(user);
         }
         sqlsession.close();
     }
 }

4.测试

//当有多个参数时要用Param注解来说明
    @Select("select * from mybatis.user where id=#{id1}")
    User selectbyid(@Param("id1") int id);

如果没有@Param注解的话id=#{id}，@Param相当于给形参重新命了名。

测试：

   @Test
     public void testselectbyid(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User selectbyid = mapper.selectbyid(1);
         System.out.println(selectbyid);
         sqlsession.close();
     }

插入：

@Insert("insert into mybatis.user values(#{id},#{name},#{pwd})")
 int adduser(User user);

 @Test
     public void testadduser(){
     SqlSession sqlsession = mybatisUntils.getSqlsession();
     UserDao mapper = sqlsession.getMapper(UserDao.class);
     User user=new User(6,"张飞","1234567");
     int adduser = mapper.adduser(user);
     System.out.println(adduser);
     sqlsession.commit();
     sqlsession.close();
 }

更新：

@Update("update mybatis.user set pwd=#{pwd} where id=#{id}")
 int updateuser(User user);
 
 @Test
     public void testupdateuser(){
     SqlSession sqlsession = mybatisUntils.getSqlsession();
     UserDao mapper = sqlsession.getMapper(UserDao.class);
     User user=new User(6,"张飞","123");
     int updateuser = mapper.updateuser(user);
     System.out.println(updateuser);
     sqlsession.commit();
     sqlsession.close();
 }

删除：

 @Delete("delete from mybatis.user where id=#{id2}")
 int deluser(@Param("id2") int id);
 
 @Test
     public void testdeluser(){
     SqlSession sqlsession = mybatisUntils.getSqlsession();
     UserDao mapper = sqlsession.getMapper(UserDao.class);
     int deluser = mapper.deluser(6);
     System.out.println(deluser);
         sqlsession.commmit();
         sqlsession.close();
     }

【注意点：增删改一定记得对事务的处理，要对事务进行提交和关闭】

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

在方法只接受一个参数的情况下，可以不使用@Param。
在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
如果参数是 JavaBean ，则不能使用@Param。
不使用@Param注解时，参数只能有一个，并且是Javabean。

#{}和${}的区别：

#{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】，其可以防止sql注入
```
 INSERT INTO user (name) VALUES (#{name});
 INSERT INTO user (name) VALUES (?);
```

${} 的作用是直接进行字符串替换

 INSERT INTO user (name) VALUES ('${name}');
 INSERT INTO user (name) VALUES ('kuangshen');

5.2 使用xml文件来实现接口(推荐)

当使用xml文件来实现时，要建立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.fbw.Dao.UserDao">
 
     
     <select id="getUserlist" resultType="user">
 select * from mybatis.user
 </select>
     <select id="selectUserById" resultType="com.fbw.pojo.User" resultMap="UserMap">
         select * from mybatis.user where id=#{id}
 -- select id,name,pwd as password from mybatis.user where id=#{id}
     </select>
     <insert id="addUser" parameterType="com.fbw.pojo.User">
         insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd})
     </insert>
     <update id="UpdateUser" parameterType="com.fbw.pojo.User">
         update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
     </update>
     <delete id="deleteUser" parameterType="com.fbw.pojo.User">
         delete from mybatis.user where id=#{id}
     </delete>
     <select id="selectByIdNp2" parameterType="map" resultType="com.fbw.pojo.User">
         select *
         from mybatis.user where name=#{username} and pwd=#{password}
     </select>
 </mapper>

xml文件的详解下面会说

6.解析UserDao.xml文件

UserDao.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.fbw.Dao.UserDao">
     
     <resultMap id="UserMap" type="User">
         <id column="id" property="id"/>
         <result column="name" property="name"/>
         <result column="pwd" property="password"/>
     </resultMap>
     
     
     <select id="getUserlist" resultType="user">
 select * from mybatis.user
 </select>
     <select id="selectUserById" resultType="com.fbw.pojo.User" resultMap="UserMap">
         select * from mybatis.user where id=#{id}
 -- select id,name,pwd as password from mybatis.user where id=#{id}
     </select>
     <insert id="addUser" parameterType="com.fbw.pojo.User">
         insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd})
     </insert>
     <update id="UpdateUser" parameterType="com.fbw.pojo.User">
         update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
     </update>
     <delete id="deleteUser" parameterType="com.fbw.pojo.User">
         delete from mybatis.user where id=#{id}
     </delete>
     <select id="selectByIdNp2" parameterType="map" resultType="com.fbw.pojo.User">
         select *
         from mybatis.user where name=#{username} and pwd=#{password}
     </select>
 </mapper>

6.1 实现方法的各种类型

select是实现查找的方法，同理insert、update、delete、分别对应了插入、更新、删除。而实现时的id对应的时接口中的方法，resultType对应的时方法返回值的类型，parameterType对应的方法中输入值的类型，resultMap对应的是resultMap的类型

6.2 resultMap

当实体类的字段和数据库中表的字段不一致时，要用resultMap来映射实体类和数据库表的字段如：

实体类：

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

数据库中表的字段：

可以看到实体类的password和表中的pwd并不对应，此时我们可以用resultMap来映射

<resultMap id="UserMap" type="User">
         <id column="id" property="id"/>
         <result column="name" property="name"/>
         <result column="pwd" property="password"/>
     </resultMap>
 
 <mapper namespace="com.fbw.Dao.UserDao">

其中resultMap中的 id为这个映射的名字，type为要映射的实体类
resultMap中的id属性对应的时表中的主键，result属性对应的是表中的普通键，column对应的是表中的字段，property对应的是实体类的字段，相当于给表中的字段起了个别名，而别名就是实体类中的字段
namespace中文意思：命名空间，作用如下：
- namespace的命名必须跟某个接口同名
- 接口中的方法与映射文件中sql语句id应该一一对应
1. namespace和子元素的id联合保证唯一 , 区别不同的mapper
2. 绑定DAO接口
3. namespace命名规则 : 包名+类名

测试

@Test
     public void testgetUserList(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         List<User> userlist = mapper.getUserlist();
         for (User user : userlist) {
             System.out.println(user);
         }
         sqlsession.close();
     }
     @Test
     public void testselectUserById(){
         //获取SqlSession连接
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user=mapper.selectUserById(1);
         System.out.println(user);
         //关闭流
         sqlsession.close();
     }
     @Test
     public void testaddUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user=new User(4,"王维","123456");
         int i=mapper.addUser(user);
         System.out.println(i);
         //需要提交事务
         sqlsession.commit();
         sqlsession.close();
     }
     @Test
     public void testUpdateUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         User user = mapper.selectUserById(1);
         user.setName("关羽");
         int i=mapper.UpdateUser(user);
         sqlsession.commit();
         sqlsession.close();
     }
     @Test
     public void testdeleteUser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         int i = mapper.deleteUser(4);
         System.out.println(i);
         sqlsession.commit();
         sqlsession.close();
     }
     @Test
     public void testselectByIdNP2(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         Map<String,Object> map=new HashMap<String,Object>();
         map.put("username","关羽");
         map.put("password","12345");
         User user = mapper.selectByIdNp2(map);
         System.out.println(user);
         sqlsession.close();
     }

注意点：增、删、改操作需要提交事务！

6.3 模糊查询

当使用模糊查询时有两种方法：

接口：

//模糊查询
    List<User> getUserLike(String name);

1.在Java代码中添加sql通配符

 <select id=”getUserLike” parameterType="String">
 select * from mybatis.user where name like #{value}
 </select>

test.class

 @Test
     public void testgetUserList(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         string name = “%李%”;
         List<User> userlist = mapper.selectlike(name);
         for (User user : userlist) {
             System.out.println(user);
         }
         sqlsession.close();
     }

2.在sql语句中拼接通配符，会引起sql注入(不推荐)

 <select id=”selectlike”>
     select * from foo where bar like "%"#{value}"%"
 </select>

test.class

 @Test
     public void testgetUserList(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         string name = “李”;
         List<User> userlist = mapper.selectlike(name);
         for (User user : userlist) {
             System.out.println(user);
         }
         sqlsession.close();
     }

6.4 分页

为什么引入分页？

在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

1.limit实现分页

limit语法：

#语法
 SELECT * FROM table LIMIT stratIndex，pageSize
 
 SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15  
 
 #为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：   
 SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.  
 
 #如果只给定一个参数，它表示返回最大的记录行数目：   
 SELECT * FROM table LIMIT 5; //检索前 5 个记录行  
 
 #换句话说，LIMIT n 等价于 LIMIT 0,n。

接口：

//选择页面分页
    List<User> selectUser(Map<String,Integer> map);

xml:

 <select id="selectUser" parameterType="map" resultType="user">
         select *
         from mybatis.user limit #{startIndex},#{pageSize}
     </select>

test.class

起始位置 = （当前页面 - 1 ） * 页面大小

@Test
     public void testselectuser(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         UserDao mapper = sqlsession.getMapper(UserDao.class);
         int currentPage = 1;  //第几页
         int pageSize = 2;  //每页显示几个
         Map<String,Integer> map = new HashMap<String,Integer>();
         map.put("startIndex",(currentPage-1)*pageSize);
         map.put("pageSize",pageSize);
 
         List<User> user=mapper.selectUser(map);
         for (User user1 : user) {
             System.out.println(user1);
         }
     }

2.RowBounds分页

我们除了使用Limit在SQL层面实现分页，也可以使用RowBounds在Java代码层面实现分页，当然此种方式作为了解即可。我们来看下如何实现的！

接口：

 //使用RowBounds分页
    List<User> getUserByBounds();

xml：

  <select id="getUserByRowBounds" resultType="user" resultMap="UserMap">
         select * from mybatis.user;
     </select>

在测试时要引入RowBounds类

 @Test
     public void testUserByRowBounds(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         int currentPage = 2;  //第几页
         int pageSize = 2;  //每页显示几个
         RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize);
 
         //通过session.**方法进行传递rowBounds，[此种方式现在已经不推荐使用了]
         List<User> users = sqlsession.selectList("com.fbw.Dao.UserDao.getUserByRowBounds", null, rowBounds);
 
         for (User user: users){
             System.out.println(user);
         }
         sqlsession.close();

7.一对多和多对一，多对多

7.1 一对多

举个不恰当的例子，对于一个老师来说他可以教很多学生，所以我们用这个例子来说明一对多。(实际上老师和学生是多对多的关系，一个老师可以有很多学生，一个学生也可以有多个老师，为了好表现，先用错的例子)

7.1.1 首先先建立表

老师表：

CREATE TABLE `teacher` (
 `id` INT(10) NOT NULL,
 `name` VARCHAR(30) DEFAULT NULL,
 PRIMARY KEY (`id`)
 ) ENGINE=INNODB DEFAULT CHARSET=utf8

学生表：

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

7.1.2 建立实体类

Student.class

package com.fbw.pojo;
 
 import lombok.Data;
 
 @Data
 public class Student {
     private int id;
     private String name;
     private int tid;
 }

Teacher.class

 package com.fbw.pojo;
 
 import lombok.Data;
 
 import java.util.List;
 
 @Data
 public class Teacher {
     private int id;
     private String name;
     private List<Student> student;
 }

因为是一对多，所以teacher.class中的student是List

7.1.3 建立接口

TeacherMapper.interface

 package com.fbw.Dao;
 
 import com.fbw.pojo.Teacher;
 
 public interface TeacherMapper {
     public Teacher getteacher(int id);
     }

对于实现接口有两种方式：

按结果嵌套处理
按查询嵌套处理

1.按结果嵌套处理

TeacherMapper.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.fbw.Dao.TeacherMapper">
  <!--
    思路:
        1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
        2. 对查询出来的操作做结果集映射
            1. 集合的话，使用collection！
                JavaType和ofType都是用来指定对象类型的
                JavaType是用来指定pojo中属性的类型
                ofType指定的是映射到list集合属性中pojo的类型。
    -->
     <select id="getteacher" resultMap="TeacherStudent">
         select s.id sid,s.name sname,t.name tname,t.id tid from mybatis.student s,mybatis.teacher t
         where s.tid=t.id and t.id=#{id}
     </select>
     <resultMap id="TeacherStudent" type="Teacher">
         <result property="name" column="tname"></result>
         <collection property="student" ofType="Student">
             <result property="id" column="sid"></result>
             <result property="name" column="sname"/>
             <result property="tid" column="tid"/>
         </collection>
     </resultMap>
 </mapper>

别忘了把mapper文件映射到mybatis-config里

测试：

@Test
     public void testgetteacher2(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         TeacherMapper mapper = sqlsession.getMapper(TeacherMapper.class);
         Teacher teacher = mapper.getteacher2(2);
         System.out.println(teacher.getName());
         System.out.println(teacher.getStudent());
     }

2.按查询嵌套处理

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.fbw.Dao.TeacherMapper">
 
 
     <!--一个mapper文件中只能有一个collection-->
 <select id="getteacher" resultMap="TeacherStudent">
     select * from mybatis.teacher where id=#{id}
 </select>
     <resultMap id="TeacherStudent" type="Teacher">
        javaType是实体类Teacher中student的类型
         ofType是映射到list集合中的类型
         <collection property="student" javaType="ArrayList"
                     ofType="Student" column="id" select="getStudentByTeacherid"/>
     </resultMap>
     <select id="getStudentByTeacherid" resultType="Student">
         select * from mybatis.student where tid=#{id}
     </select>
 </mapper>

测试：

@Test
     public void testgetstudent(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         TeacherMapper mapper = sqlsession.getMapper(TeacherMapper.class);
         Teacher teacher=mapper.getteacher(1);
         System.out.println(teacher.getName());
         System.out.println(teacher.getStudent());
     }

7.2 多对一

还是接着用上面的不恰当的例子，从学生的角度来看，就是多对一

1.建立实体类

Student.class

package com.fbw.pojo;
 
 import lombok.Data;
 
 @Data
 public class Student {
     private int id;
     private String name;
     //多个老师可以对一个老师，即多对一
     private Teacher teacher;
 }

Teacher.class

 package com.fbw.pojo;
 
 import lombok.Data;
 @Data
 public class Teacher {
     private int id;
     private String name;
 
 }

2.接口

 package com.fbw.Dao;
 
 import com.fbw.pojo.Student;
 
 import java.util.List;
 
 public interface StudentMapper {
     public List<Student> getstudents();
     public List<Student> getstudents2();
 }

按结果嵌套处理

 <?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.fbw.Dao.StudentMapper">
     <!--
    需求：获取所有学生及对应老师的信息
    思路：
        1. 获取所有学生的信息
        2. 根据获取的学生信息的老师ID->获取该老师的信息
        3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？
            1. 做一个结果集映射：StudentTeacher
            2. StudentTeacher结果集的类型为 Student
            3. 学生中老师的属性为teacher，对应数据库中为tid。
               多个 [1,...）学生关联一个老师=> 一对一，一对多
            4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
    -->
 <select id="getstudents" resultMap="StudentTeacher2">
     select s.id sid,s.name sname,t.name tname from mybatis.student s,mybatis.teacher t where s.tid=t.id
 </select>
     <resultMap id="StudentTeacher2" type="Student">
         <!--column对应库，property对应实体类
         id:是配置主键
         result：配置普通的属性
         association：配置结果集的映射
         collection:
         -->
         <id property="id" column="id"/>
         <result property="name" column="sname"/>
         <!--关联对象property 关联对象在Student实体类中的属性-->
         <association property="teacher" javaType="Teacher">
             <result property="name" column="tname"/>
         </association>
     </resultMap>
 </mapper>

测试：

@Test
     public void testgetstudents(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         StudentMapper mapper = sqlsession.getMapper(StudentMapper.class);
         List<Student> studentlist = mapper.getstudents();
         for (Student student : studentlist) {
             System.out.println("学生名字："+student.getName()+" 老师："+student.getTeacher().getName());
         }
         sqlsession.close();
     }

按查询嵌套处理

<?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.fbw.Dao.StudentMapper">
 
     
 <select id="getstudents" resultMap="StudentTeacher">
     select * from mybatis.student
 </select>
     <resultMap id="StudentTeacher" type="Student">
         <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
         <association property="teacher" column="tid" javaType="Teacher" select="getTeacher">
         </association>
     </resultMap>
     <!--
    这里传递过来的id，只有一个属性的时候，下面可以写任何值
    association中column多参数配置：
        column="{key=value,key=value}"
        其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
    -->
     <select id="getTeacher" resultType="teacher">
         select * from mybatis.teacher where id=#{id}
     </select>
 
 
 </mapper>

测试：

@Test
     public void testgetstudents(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         StudentMapper mapper = sqlsession.getMapper(StudentMapper.class);
         List<Student> studentlist = mapper.getstudents();
         for (Student student : studentlist) {
             System.out.println("学生名字："+student.getName()+" 老师："+student.getTeacher().getName());
         }
         sqlsession.close();
     }

7.3 多对多

7.4一对一

我们新引进两个表，一个是丈夫表，一个妻子表，而丈夫和妻子就是一对一的关系。我们由这两个表来举例一对一。

1.先建立丈夫表和妻子表：

注意：丈夫表的tid对应的是妻子表的id，也就是妻子表的id是丈夫表的外键。

2.建立实体类

h.class

 package com.fbw.pojo;
 
 import lombok.Data;
 
 @Data
 public class h {
     private int id;
     private String hname;
     private int age;
     private w tid;
 }

w.class

package com.fbw.pojo;
 
 import lombok.Data;
 
 @Data
 public class w {
     private int id;
     private String wname;
     private int age;
 }

2.建立接口

handwmapper.xml

 package com.fbw.Dao;
 
 import com.fbw.pojo.h;
 
 
 import java.util.List;
 
 public interface handwmapper {
     public h getwife();
 }

3.实现接口

<?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.fbw.Dao.handwmapper">
 <select id="getwife" resultMap="handw">
     select h.id hid,h.hname hname,h.age hage,w.wname wname,w.age wage from test.h h,test.w w where h.tid=w.id
 </select>
     <resultMap id="handw" type="h">
         <!--column对应库，property对应实体类
         id:是配置主键
         result：配置普通的属性
         association：配置结果集的映射
         collection:
         -->
         <id property="id" column="hid"/>
         <result property="hname" column="hname"/>
         <result property="age" column="hage"/>
         <!--关联对象property 关联对象在Student实体类中的属性-->
         <association property="tid" javaType="w">
             <result property="wname" column="wname"/>
             <result property="age" column="wage"/>
         </association>
     </resultMap>
 </mapper>

4.测试

import com.fbw.Dao.handwmapper;
 import com.fbw.pojo.h;
 import com.fbw.untils.mybatisUntils;
 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;
 
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.springframework.test.context.ContextConfiguration;
 
 import java.util.List;
 
 
 public class test {
     @Test
     public void testgetwife(){
         SqlSession sqlsession = mybatisUntils.getSqlsession();
         handwmapper mapper = sqlsession.getMapper(handwmapper.class);
         h getwife = mapper.getwife();
         System.out.println(getwife);
         sqlsession.close();
 
     }
 }

8.动态sql

什么是动态SQL：动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句。

我们之前写的 SQL 语句都比较简单，如果有比较复杂的业务，我们需要写复杂的 SQL 语句，往往需要拼接，而拼接 SQL ，稍微不注意，由于引号，空格等缺失可能都会导致错误。

那么怎么去解决这个问题呢？这就要使用 mybatis 动态SQL，通过 if, choose, when, otherwise, trim, where, set, foreach等标签，可组合成非常灵活的SQL语句，从而在提高 SQL 语句的准确性的同时，也大大提高了开发人员的效率。

新建一个数据库表：blog

 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.首先先建立实体类

 package com.fbw.pojo;
 
 import lombok.Data;
 
 import java.util.Date;
 
 @Data
 public class Blog {
     private String id;
     private String title;
     private String author;
     private Date createTime;
     private int views;
 }

2.接口BlogMapper.xml：

package com.fbw.mapper;
 
 import com.fbw.pojo.Blog;
 
 import java.util.List;
 import java.util.Map;
 
 public interface BlogMapper {
     List<Blog> queryBlogIf(Map map);
     int updateBlog(Map map);
     List<Blog> queryBlogchoose(Map map);
     List<Blog> queryBlogForeach(Map map);    
 }

8.1 if和where

需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询，

这时我们可以用if语句：

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

测试：

  @Test
     public void testaddBolg(){
         SqlSession session = mybatisUntils.getSqlsession();
         BlogMapper mapper = session.getMapper(BlogMapper.class);
 
         HashMap<String,Object> map=new HashMap<String,Object>;
             map.put("title","Mybatis如此简单");
         map.put("author","狂神说");
         List<Blog>  blogs=mapper.queryBlogIf(map);
         System.out.println(blogs);
         session.close();
     }

其实就是把语句拼接了一下，当都不为空时语句为select * from mybatis.blog where title=#{title} and author=#{author},当前者不为空后者为空时语句为select * from mybatis.blog where title=#{title}，反之则为select * from mybatis.blog where and author=#{author}，这时sql语句就出现了问题，此时我们引进了where语句

修改上面的语句：

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

这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。

8.2 set

当要进行数据库的更新时需要引入set

比如对上面的数据库进行更新(实现接口中的updateBlog)：

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

注意： set要用逗号隔开啊！！！！还有update要提交事务！！！

测试：

@Test
     public void testaddBolg(){
         SqlSession session = mybatisUntils.getSqlsession();
         BlogMapper mapper = session.getMapper(BlogMapper.class);
 
         HashMap<String,Object> map=new HashMap<String,Object>;
         map.put("title","动态SQL");
         map.put("author","李白");
         map.put("id","4");
         mapper.updateBlog(map);
         session.commit();
         session.close();
     }

8.4 choose语句

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

实现上面接口中的queryBlogchoose：

<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>
     views=#{views}
 </otherwise>
     </choose>
 </where>
 </select>

when就相当于switch中的case，otherwise相当于其中的otherwise

8.5 Foreach

将数据库中前三个数据的id修改为1,2,3；

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

实现接口中的 queryBlogForeach：

<select id="queryBlogForeach" parameterType="map" resultType="blog">
   select * from blog
    <where>
        <!--
        collection:指定输入对象中的集合属性
        item:每次遍历生成的对象
        open:开始遍历时的拼接字符串
        close:结束时拼接的字符串
        separator:遍历对象之间需要拼接的字符串
        select * from blog where 1=1 and (id=1 or id=2 or id=3)
      -->
        <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
           id=#{id}
        </foreach>
    </where>
 </select>

测试：

@Test
 public void testQueryBlogForeach(){
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
 
    HashMap map = new HashMap();
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    map.put("ids",ids);
 
    List<Blog> blogs = mapper.queryBlogForeach(map);
 
    System.out.println(blogs);
 
    session.close();
 }

8.6 SQL片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段

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

引用SQL片段

<select id="queryBlogIf" parameterType="map" resultType="blog">
   select * from blog
    <where>
        <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
        <include refid="if-title-author"></include>
        <!-- 在这里还可以引用其他的 sql 片段 -->
    </where>
 </select>

注意：

①、最好基于单表来定义 sql 片段，提高片段的可重用性

②、在 sql 片段中不要包括 where

终于写完了！！！！！

吃饭吃饭！！!

2021/11/23