前言

JDBC存在问题

1、在使用JDBC操作数据库前进行连接、操作完成之后关闭连接、并发性能有大的影响
解决：为了达到连接复用，采用连接池
2、SQL语句硬编码在Java代码中，需求改变需要改变Java代码本身
3、返回的结果集也存在硬编码的问题。

Mybatis的介绍

• Mybatis前身ibatis,是Apache旗下的开源的数据持久层框架。
  它支持自定义 SQL、存储过程以及高级映射。
• MyBatis免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
• MyBatis可以通过 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain OldJava Objects，普通老式 Java 对象）为数据库中的记录。

Mybatis原理

1. 全局配置文件：配置数据源、事务、引入映射文件（mapper1.xml、mapper2.xml…多个，查询SQL、参数类型、结果集的封装）。
2. SqlSessionFactory：会话工厂。打开SqlSession。
3. SqlSession：会话，操作CRUD。
4. Executor：执行器，缓存实现。
5. MappedStatement：在配置文件中。

Mybatis的使用Demo

通过实际业务来研究：通过SID查询学生信息

引入依赖

<dependency>    <groupId>mysql</groupId>    <artifactId>mysql-connector-java</artifactId>    <version>5.1.32</version>    
</dependency> 
<!--mybatis配置-->    
<dependency>    <groupId>org.mybatis</groupId>    <artifactId>mybatis</artifactId>    <version>3.4.1</version>    
</dependency>   

全局的配置文件(mybatis-config.xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//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/test"/><property name="username" value="root"/><property name="password" value="123456"/></dataSource></environment></environments></configuration>

POJO类（Student.java）

//数据库中Student表对应的映射Java对象类
public class Student {private Integer SID;private  String Sname;private  String Ssex;private Integer Sage;//省略getter和setter方法
}

Mapper接口文件(StudentMapper.java)

public interface StudentMapper {/*** 通过SID查询数据实体* @param sid* @return*/public Student selectStudentByID(int sid);
}

配置Mapper.xml文件(StudentMapper.xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<!--mapper:根标签，namespace命令空间，随便写，一般保证命名空间唯一 -->
<mapper namespace="com.tulun.MybatisDemo.StudentMapper"><!--查询标签：select--><select id="selectStudentByID" resultType="com.tulun.MybatisDemo.Student">select * from Student where SID = #{sid}</select>
</mapper>

修改全局配置文件(mybatis-config.xml)

    <!--配置映射--><mappers><mapper resource="mapper/StudentMapper.xml"/></mappers>

执行查询操作

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;public class MybatisTLDemo {public static void main(String[] args) throws IOException {//mybatis配置文件String resource = "mybatis-config.xml";//通过mybatis提供的Resources类来得到配置文件流InputStream inputStream = Resources.getResourceAsStream(resource);//创建会话工厂，传输mybatis配置文件信息SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);//通过工厂得到SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();//通过反射机制来获取对应mapper实例StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);//调用mapper实例下方法Student student = mapper.selectStudentByID(1);System.out.println(student);}
}

步骤总结：

1. 配置mybatis-config.xml全局配置文件（数据源、mapper）
2. 创建SQLSessionFactory
3. 通过SqlSessionFactory创建SqlSession对象
4. 通过SqlSession操作数据库CRUD

添加日志

日志依赖jar包

    <dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency>

日志配置文件

创建log4j.properties文件

## debug 级别
log4j.rootLogger=DEBUG,Console  
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.Target=System.out  
log4j.appender.Console.layout = org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=%d{yyyy-MM-dd-HH\:mm\:ss,SSS} [%t]  [%c] [%p] - %m%n  
log4j.logger.com.mybatis=DEBUG  /  ##输出sql 语句
log4j.logger.java.sql.Connection=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG 

日志打印

 2020-05-11-10:38:34,366 [main]  [org.apache.ibatis.transaction.jdbc.JdbcTransaction] [DEBUG] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@d4004b]2020-05-11-10:38:34,367 [main]  [com.tl.MyBatisDemo.CourseMapper.selectCourseByCourseId] [DEBUG] - ==>  Preparing: select * from course where course_id = ? 2020-05-11-10:38:34,388 [main]  [com.tl.MyBatisDemo.CourseMapper.selectCourseByCourseId] [DEBUG] - ==> Parameters: 1(Integer)2020-05-11-10:38:34,405 [main]  [com.tl.MyBatisDemo.CourseMapper.selectCourseByCourseId] [DEBUG] - <==      Total: 1

配置详解

全局配置文件：Mybatis-config详解

properties:读取外部资源

properties属性可以对外部配置进行动态替换

<!--读取配置，value是默认值--><properties resource="db.properties"><property name="passwd" value="000000"/><!--<property name="username" value="123"/>--></properties>

配置中的属性可以在整个配置文件中被用来替换需要动态配置的属性值。

<!--数据源配置--><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/school"/><property name="username" value="${username}"/><property name="password" value="${passwd}"/></dataSource></environment></environments>

注意：${passwd}中的passwd要和上面的propertries中的name一致，username也是如此。
如果属性不只一个地方进行配置，mybatis将按照以下的顺序来加载：

• 首先读取在properties元素中指定的属性
• 然后根据properties元素中的resource/url属性指定的文件内容，并覆盖之前读取的同名的属性
• 最后读取作为方法参数传递的属性，并覆盖之前读取的同名属性

通过方法参数传递的属性具有最高优先级，resource或URL加载的属性次之，最低级的是properties元素内的属性。

Settings：全局的参数配置

Setting配置参数较多，这里介绍常用的三个参数

cacheEnabled：在Mybatis中耳机缓存的开关，true为开启。
lazyLoadingEnabled和aggressiveLazyEnabled：配置懒加载的开关配置。

    <settings><!--开启二级缓存开关--><setting name="cacheEnabled" value="true"/><setting name="lazyLoadingEnabled" value="true"/></settings>

typeAliases：类型别名

类型别名是为java类型设置一个短的名字，和XML配置文件有关，用来减少类完全限定名的冗余。

	<typeAliases><!--单个别名定义  type：pojo类的路径（全限定名）  alias：别名的名称--><typeAlias type="com.tl.MyBatisDemo.Course" alias="course"/><!--批量别名定义  name：指定的包名，将包下面的所有pojo类取别名 别名默认为类名（首字母大小写都可以）--><!--<package name="com.tl.pojo"/>--></typeAliases>

在mapper.xml 文件中，定义了很多的Statement，Statement需要parameterType指定输入参数类型，需要resultType指定输出参数类型，如果指定类型为全路径，开发不方便，可以针对parameterType和resultType指定的类型取别名，别名在配置文件（mybatis-config.xml）中配置typeAliases没在mapper.xml文件中使用。

typeHandlers：类型处理器

在进行参数映射成数据库表字段时或者是数据库字段映射成返回java类型时，涉及到类型映射问题，mybatis提供了合适的转换方式，如果不满足需求，可以重写类型处理器。

plugins：插件

MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。

environments：环境配置

mybatis可以配置成适应多讴种环境，这种机制有主与SQL映射应用到多种数据库中，如开发，测试，线上环境需要不同的配置。
可以配置多个环境，SQLSessionFactory实例是只能选取其中一种环境。

<!--数据源配置  只加载一个环境，看默认设置--><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/school"/><property name="username" value="${username}"/><property name="password" value="${passwd}"/></dataSource></environment><environment id="test"><transactionManager type="JDBC"/> <dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/school"/><property name="username" value="${username}"/><property name="password" value="${passwd}"/></dataSource></environment><environment id="online"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/school"/><property name="username" value="${username}"/><property name="password" value="${passwd}"/></dataSource></environment></environments>

默认使用的环境 ID（比如：default=“development”）。
每个 environment 元素定义的环境 ID（比如：id=“development”）。
事务管理器的配置（比如：type=“JDBC”）。
数据源的配置（比如：type=“POOLED”）。

mappers：映射器

定义的SQL，需要告诉mybatis到哪里寻找SQL，使用相对类路径的资源引用，有三种映射方式。

<!--配置映射   告诉mybatis SQl语句的位置--><mappers><!--resource方式：在CourseMapper.xml中定义namespace为mapper接口的地址，映射文件通过namespace来找到mapper接口文件--><mapper resource="mapper/CourseMapper.xml"/><!--class方式：指定mapper接口的地址遵循规则将mapper.xml和mapper.java放在同一个目录下，且文件名相同--><!--<mapper class="com.tl.MyBatisDemo.CourseMapper"/>--><!--package方式：批量的mapper映射需要遵循的规则：将mapper.xml和mapper.java吻技安放在同一个目录且文件名相同--><!--<package name="com.tl.MyBatisDemo"/>--></mappers>

Mapper XML详解

Mapper XML文件的根标签：mapper，根标签存在属性：namespace（命名空间，一般是接口类的全限定名）
主要介绍增< insert >删< delete >改< update >查< select >标签

select标签

select：查询操作的标签，是一个statement。
id属性（必须）：当前命名空间下Statement的唯一标识，要求id和mapper接口中的方法保持一致。
resultType(必须)：将结果集映射为Java的对象，该属性值为映射对象的全限定名或者是别名（和resultMap二选一）
resultMap：当数据库的字段和pojo类中的字段不一致的时候，提供的一种结果集映射。

<!--resultMap 标签：处理显性的结果集映射id（必填）：作为结果集的标识type：指定要映射的Java类型的全限定名--><!--column:数据库字段，property:pojo类中的字段--><resultMap id="studentMap" type="com.tl.MyBatisDemo.Course"><id column="course_name" property="name"/></resultMap><!--查询标签：select,resultMap和resultType二选一 --><select id="selectCourseByCourseId" resultMap="studentMap">select * from course where course_id = #{cid}</select>

parameterType(可以忽略)：传入参数类型（入参还有parameterMap）

insert 标签

常用属性：
id属性（必须），唯一标识
parameterType(可以忽略)传入参数类型（入参还有parameterMap）
useGeneratedKeys(可以忽略)开启主键回写

update 标签

常用属性：
id属性（必须） 唯一标识
resultType和parameterType（可以忽略）

delete标签

常用属性：
id属性（必须） 唯一标识
resultType和parameterType（可以忽略）

Jnuit测试介绍

Junit是用于编写和运行可重复的自动化测试的开源框架
Junit使用的步骤

引入Junit的依赖

    <dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency>

生成测试类

1. 在Idea下，在需要测试类的当前的窗口，直接快捷点：ctrl+shfit+t ,选择create New Test
2. 选择测试类
3. 生成测试类

对接口进行测试：

SqlSessionFactory sqlSessionFactory;SqlSession sqlSession;@Beforepublic void before(){String resource = "mybatis-config.xml";InputStream inputStream = null;try {inputStream = Resources.getResourceAsStream(resource);} catch (IOException e) {e.printStackTrace();}Properties properties = new Properties();properties.setProperty("db.properties","username");sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, properties);}@Afterpublic void after(){sqlSession.commit();sqlSession.close();}@Testpublic void selectCourseByCourseId() {

常用的注解

@Before

当在测试方法之前需要执行一些操作可以放在@Before注解中
读取配置信息

@Test

@Test注解的会被当做测试用例，Junit每一次会创建一个新的测试实例，调用@Test注解方法

@After

After 注解是在Test注解调用之后才会进行执行，一般是进行资源的回收

Mybatis的使用方法

XML配置形式用法

注解形式的用法

@Select
@Insert
@Update
@Delete

多个参数的传递

通过学生年龄和性别来查询学生信息
select * from Student where Sage=? and Ssex=?
mybatis配置如下：

@Select(select * from student where age=#{age} and sex=#{sex})
public getStudentByAgeAndSex(int age, String sex);

XML可用的参数只有0,1,param1和Param2，Mybatis根据位置自定义的名字，可以将#{sex}改为#{0}或者#{param1}
多参数传递是给参数配置@Param注解

public Student getStudentByAgeAndSex(@Param("age") int age, @Param("sex") String sex);

当结果有多条记录时，加上List<>

public List<Student> getStudentByAgeAndSex(@Param("age") int age, @Param("sex") String sex);

配置注解后，mybatis自动的将参数封装成Map类型，@Param注解值作为Map中的key,参数值作为Map中的value，通过这种形式可以识别多参数的对应关系>

#{}和${}的区别

{}的使用

@Select("select * from Student where SID=#{sid}")
public Student getStudentBySID(int sid);

日志打印：

Preparing: select * from Student where SID=? 
Parameters: 2(Integer)

#{}占位符在执行过程中将#{}替换成 ? 占位符,将参数值和SQL分开传递到服务器。
#{}使用类似于JDBC编程中preparedStatment。

${}的使用

参数的获取使用ognl表达式，使用的参数必须提供getteer方法

@Select("select * from Student where SID=${SID}")
public Student getStudentBySID(Student student);

打印日志：

Preparing: select * from Student where SID=1 
Parameters:

使用${}方式传递参数时，直接将参数拼接到SQL。
${}使用JDBC编程中的Statement的操作。

#{}不存在SQL注入问题，采用预编译机制，将SQL和参数分别传递给SQL服务器，而${}存在SQL注入问题，所以一般情况时使用#{}。

动态SQL

Mybatis的强大特征之一 在于动态SQL，采用ognl表达式来处理SQL，根据表达式的不同，能将SQL进行拼接和组装。
主要的动态SQL标签：if，where，trim（where，set），foreach。

if标签

根据年龄和性别查询学生

<!--if表达式一般放在where条件后，判断蚕食是否传递使用if test属性（必填）为true或falsetest使用OGNL表达式处理，返回true则进入到if标签的SQL，否则不会进入参数处理：1）都不传：select * from student where  ！！！要添加1=12）都传：select * from student where age = #{age} sex = #{sex}   ！！！要加and3）只传age：select * from student where 1=1 and age = #{age}4）只传sex：select * from student where 1=1 and sex = #{sex}--><select id="getStudentByAgeAndSex" parameterType="com.tl.pojo.Student" resultType="student">select * from student where 1=1<if test="age != 0 and age != null" >and age = #{age}</if><if test="sex != null"  >and sex = #{sex}</if></select>

测试：

1. 都传
   
2. 只传age
   
3. 只传sex
   
4. 都不传
   

where标签

where标签：一般和if标签一块使用，如果标签包含的元素有返回值就插入where，将紧随where后面的And或OR开头的，将他们剔除

    <!--where标签1）只传age：select * from Student where and(会自动剔除) age = #{age}2）都不传：select * from student3）都传：select * from student where age = #{age} and sex = #{sex}--><select id="getStudentByAgeAndSex" parameterType="com.tl.pojo.Student" resultType="student">select * from student<where><if test="age != 0 and age != null" >and age = #{age}</if><if test="sex != null"  >and sex = #{sex}</if></where></select>

测试：与if相同。

trim标签（where/set）标签

trim标签用于取出SQL中多余的and关键字、逗号，使用在where或set中。

属性	描述
prefix	给SQL语句拼接的前缀
suffix	给SQL语句拼接的后缀
prefixOverrides	去除SQL语句前的关键字或字符
suffixOverrides	去除SQL语句后的关键字或字符

    <!--trim标签（结合where）作用等同于直接使用where--><select id="getStudentByAgeAndSex" parameterType="com.tl.pojo.Student" resultType="student">select * from student<trim prefix="where" prefixOverrides="and"><if test="age != 0 and age != null" >and age = #{age}</if><if test="sex != null"  >and sex = #{sex}</if></trim></select>

foreach标签

批量处理（插入，查询等）
场景：通过一批ID查询用户信息
select * from Student where id in(1,2,3)
insert into Student (id,name) values(20,“zhangsan”),(21,“lisi”),(22,“wangwu”)

接口文件的方法：

public List<Student> batchSelectStudentByIds(List<Integer> ids);

Mapper.xml文件

    <!--批量查询SQLforeach表达式：collection(必填)：指定输入参数类型。list：列表。array：数组。map：map集合。item：给集合中单个元素的名称open：开始的字符串。close：结束的字符串。separator：数据之间的分隔符。--><select id="batchSelectStudentByIds" resultType="student">select * from Student where sid in<foreach collection="list" item="id" open="(" close=")" separator=",">#{id}</foreach></select>

测试：

模糊匹配

需求：查询Student表，表中含有"明”的所有用户
SQL：select * from Student where Sname like “%明%”；
方式1：直接在参数上拼接通配符
Mapper.xml配置：
测试用例：

日志打印：

方法2：Mysql中的concat(,)
concat(par1,par2) :进行字符串拼接。
Mapper.xml配置：

测试用例：

日志打印：

方法3：bind表达式处理
Mapper.xml配置：

接口方法：
测试用例：

日志打印：

动态代理：

原生的方法调用直接通过sqlSession方法调用：提供了selectOne,selectList,Insert,delete…方法
返回多个结果时，使用selectList，返回的结果不管是单个还是多个在resultType属性都是返回的Java对象全路径。返回单个结果对象使用selectOne。sqlSession.selectList(“com.tulun.dao.StudentMapper1.getStudentsByName”, “%L%”);

• 代理模式是Java中的一种设计模式。
• 代理模式中代理类和委托类具有相同的接口
• 代理类的主要职责是为委托类预处理消息，过滤消息等功能。
• 代理类的对象本身并不是真正的实现服务，而是通过委托类的对象的相- 关方法，来提供特定的一些服务。
• 代理类和委托类之间存在关联关系，一个代理类对象和一个委托类的对象相关联。
• 访问实际对象，是通过代理类方法的。

代理模式的话分为静态代理和动态代理。

• 静态代理是在程序编译阶段确定代理对象。
• 动态代理是在程序运行阶段确定代理对象
• 动态代理是在运行时根据Java代码指示动态生成的，相比较静态代理，优势在在于方便的对代理类的函数进行统一的处理，而不用修改每个代理类的方法。

Java中提供的动态代理方式有两种：JDK自带的动态代和CGLib实现代理。

JDK自带的代理方式

自定义演示

JDK自带的代理方式需要实现invocationHandler接口，实现invoke的方法。

1. 提供一个接口类
   
2. 提供一个委托类
   
3. 实现动态代理，首先创建一个实现了InvocationHandler接口的辅助类。‘

public class UserProxy implements InvocationHandler {private Object object;public UserProxy(Object object){this.object = object;}/*** 实现动态代理，就需要实现InvocationHandler接口中的invoke方法，该方法有三个参数* @param proxy ：就是动态代理生成的代理对象* @param method：就是调用的方法* @param args:表示该方法的参数* @return* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代理类特有!");method.invoke(object,args);System.out.println("代理类特有!");return null;}
}

4. 使用产生代理对象时，需要调用代理辅助类，调用委托方法。

public static void main(String[] args) {IUser iUser = (IUser) Proxy.newProxyInstance(UserProxy.class.getClassLoader(), new Class[]{IUser.class}, new UserProxy(new User()));iUser.fun();}

5. 结果：
   

结果显示：当前的代理类调用fun方法，调用到代理辅助类UserProxy中的invoke方法，还调用到了委托类的fun实现。
JVM是如何自动实现invoke方法的调用呢？

CGLib实现代理