MyBatis详解 一篇就够啦

第1章MyBatis框架配置文件详解

1.1 typeHandlers类型转换器

　　每当MyBatis 设置参数到PreparedStatement 或者从ResultSet 结果集中取得值时，就会使用TypeHandler 来处理数据库类型与java 类型之间转换。下表描述了默认

TypeHandlers

 1.1.1 自定义类型转换器

假设表中字段是int类型,而实体类与之对应的属性是boolean类型,此时可以采用自定义类型转换器进行对应

(1)实体类

 1 package com.chenyanbin.beans;
 2 
 3 public class Dept {
 4     private Integer deptNo;
 5     private String dname;
 6     private String loc;
 7     private boolean flag;
 8     public Integer getDeptNo() {
 9         return deptNo;
10     }
11     public boolean isFlag() {
12         return flag;
13     }
14     public void setFlag(boolean flag) {
15         this.flag = flag;
16     }
17     public void setDeptNo(Integer deptNo) {
18         this.deptNo = deptNo;
19     }
20     public String getDname() {
21         return dname;
22     }
23     public void setDname(String dname) {
24         this.dname = dname;
25     }
26     public String getLoc() {
27         return loc;
28     }
29     public void setLoc(String loc) {
30         this.loc = loc;
31     }
32 }

(2) 表中字段

 (3) 开发自定义类型转换器：MyTypeHandler.java

继承并实现接口:TypeHandler.java

 1 package com.chenyanbin.util;
 2 
 3 import java.sql.CallableStatement;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 
 8 import org.apache.ibatis.jdbc.Null;
 9 import org.apache.ibatis.type.JdbcType;
10 import org.apache.ibatis.type.TypeHandler;
11 /*
12  * setParameter:这个方法在生成SQL语句时才被调用
13  * 
14  * getResult:查询结束之后，在将ResultSet数据行转换为实体类对象时，通知TypeHandler将当前数据行某个字段转换为何种类型
15  * 
16  * 
17  */
18 public class MyTypeHandler implements TypeHandler {
19 
20     public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) throws SQLException {
21         if (parameter==null) { //dept.flag=null insertsql flag设置0
22             ps.setInt(i, 0);
23             return;
24         }
25         Boolean flag=(Boolean)parameter;
26         if (flag==true) {
27             ps.setInt(i, 1);
28         }
29         else {
30             ps.setInt(i, 0);
31         }
32     }
33 
34     public Object getResult(ResultSet rs, String columnName) throws SQLException {
35         int flag = rs.getInt(columnName); //1 or 0
36         Boolean myFlag=Boolean.FALSE;
37         if (flag==1) {
38             myFlag=Boolean.TRUE;
39         }
40         return myFlag;
41     }
42 
43     public Object getResult(ResultSet rs, int columnIndex) throws SQLException {
44         // TODO Auto-generated method stub
45         return null;
46     }
47 
48     public Object getResult(CallableStatement cs, int columnIndex) throws SQLException {
49         // TODO Auto-generated method stub
50         return null;
51     }
52 
53 }

(4) 在MyBatis核心配置文件注册自定义类型转换器：

myBatis-config.xml

 1 "1.0" encoding="UTF-8"?>
 2 DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 
 6     
 7     "config.properties">
 8     
 9     
10         "com.chenyanbin.beans" />
11         "com.chenyanbin.dao" />
12     
13     
14     
15         
16         "com.chenyanbin.util.MyTypeHandler"
17             javaType="Boolean" jdbcType="NUMERIC" />
18     
19     
20     default="development">
21         
22         "development">
23             
24             "JDBC">
25             
26             "pooled">
27                 "driver" value="${jdbc.driver}" />
28                 "url" value="${jdbc.url}" />
29                 "username" value="${jdbc.username}" />
30                 "password" value="${jdbc.password}" />
31             
32         
33     
34     
35     
36         "com.chenyanbin.dao" />
37     
38 

config.properties

1 jdbc.driver=com.mysql.jdbc.Driver
2 jdbc.url=jdbc:mysql://localhost:3306/sam
3 jdbc.username=root
4 jdbc.password=root

(5) 创建接口:DeptMapper.java

 1 package com.chenyanbin.dao;
 2 
 3 import java.util.List;
 4 import com.chenyanbin.beans.Dept;
 5 
 6 public interface DeptMapper {
 7     public void deptSave(Dept dept);
 8 
 9     public List deptFind();
10 }

(6)  DeptMapper.xml

 1 "1.0" encoding="UTF-8"?>
 2 DOCTYPE mapper
 3   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 namespace="com.chenyanbin.dao.DeptMapper">
 6     "deptSave">
 7         insert into dept (DEPTNO,DNAME,LOC,flag)
 8         values(#{deptNo},#{dname},#{loc},#{flag})
 9     
10     <select id="deptFind" resultType="Dept">
11         select deptNo,dname,loc,flag from dept
12     select>
13 

 1 
 2 DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 
 6     
 7     
 8     
 9     
10         <package name="com.chenyanbin.beans" />
11         <package name="com.chenyanbin.dao" />
12     
13     
14     default="development">
15         
16         
17             
18             
19             
20             
21                 
22                 
23                 
24                 
25             
26         
27     
28     
29     
30         <package name="com.chenyanbin.dao" />
31     
32 

方式二：myBatis-config.xml

 1 
 2 DOCTYPE mapper
 3   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 
 6     
 7         insert into dept (DEPTNO,DNAME,LOC,flag)
 8         values(#{deptNo},#{dname},#{loc},#{flag})
 9     
10     
11     
12     
13     
14         select deptNo,dname,loc,flag from dept
15     
16 

方式二：DeptMapper.xml

(7) 执行单元测试:TestMain_01.java

 1 package com.chenyanbin.test;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.util.List;
 6 import org.apache.ibatis.io.Resources;
 7 import org.apache.ibatis.session.SqlSession;
 8 import org.apache.ibatis.session.SqlSessionFactory;
 9 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
10 import org.junit.After;
11 import org.junit.Before;
12 import org.junit.Test;
13 import com.chenyanbin.beans.Dept;
14 import com.chenyanbin.dao.DeptMapper;
15 
16 public class TestMain_01 {
17     private SqlSession session;
18 
19     @Before
20     public void Start() {
21         try {
22             InputStream inputStream = Resources.getResourceAsStream("myBatis-config.xml");
23             SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
24             session = factory.openSession();
25         } catch (Exception e) {
26             e.printStackTrace();
27         }
28     }
29 
30     @After
31     public void end() {
32         if (session == null) {
33             session.close();
34         }
35     }
36 
37     @Test
38     public void test01() throws IOException {
39         Dept d2 = new Dept();
40         d2.setDname("上海事业部");
41         d2.setLoc("上海");
42         d2.setFlag(false);
43         session.insert("deptSave", d2);
44         session.commit();
45         session.close();
46     }
47 
48     @Test
49     public void test02() {        
50           DeptMapper dao=session.getMapper(DeptMapper.class);
51           List deptList=dao.deptFind();
52           System.out.println("ok");         
53     }
54 
55 }

(8) 项目目录结构

 1.2 objectFactory 对象工厂

　　MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。 如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现。

1.2.1 自定义对象工厂

表结构:dept

 实体类:Dept.java

 1 package com.chenyanbin.beans;
 2 
 3 public class Dept {
 4     private Integer deptNo;
 5     private String dname;
 6     private String loc;
 7     private Boolean flag;
 8     private String country;
 9     public String getCountry() {
10         return country;
11     }
12     public void setCountry(String country) {
13         this.country = country;
14     }
15     public Integer getDeptNo() {
16         return deptNo;
17     }
18     public Boolean getFlag() {
19         return flag;
20     }
21     public void setFlag(Boolean flag) {
22         this.flag = flag;
23     }
24     public void setDeptNo(Integer deptNo) {
25         this.deptNo = deptNo;
26     }
27     public String getDname() {
28         return dname;
29     }
30     public void setDname(String dname) {
31         this.dname = dname;
32     }
33     public String getLoc() {
34         return loc;
35     }
36     public void setLoc(String loc) {
37         this.loc = loc;
38     }
39 }

(1) 继承与DefaultObjectFactory：MyObjectFactory.java

 1 package com.chenyanbin.util;
 2 
 3 import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
 4 
 5 import com.chenyanbin.beans.Dept;
 6 
 7 public class MyObjectFactory extends DefaultObjectFactory {
 8 
 9     @Override
10     public Object create(Class type) {// 重新定义Dept类实例对象创建规则，其他类实例对象创建规则不想改变
11         if (Dept.class == type) {
12             // 依靠父类提供create方法创建Dept对象
13             Dept dept = (Dept) super.create(type);
14             // 设置自定义规则
15             dept.setCountry("China");
16             return dept;
17         }
18         return super.create(type);
19     }
20 
21 }

(2) 在MyBatis核心文件中注册自定义工厂

 1 
 2 DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 
 6     
 7     
 8     
 9     
10         <package name="com.chenyanbin.beans" />
11         <package name="com.chenyanbin.dao" />
12     
13     
14     
15     
16 
21     
22     default="development">
23         
24         
25             
26             
27             
28             
29                 
30                 
31                 
32                 
33             
34         
35     
36     
37     
38         <package name="com.chenyanbin.dao" />
39     
40 

 1.3 Plugins 拦截器

　　拦截器的一个作用就是我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。Mybatis拦截器设计的一个初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。打个比方，对于Executor，Mybatis中有几种实现：BatchExecutor、ReuseExecutor、SimpleExecutor和CachingExecutor。这个时候如果你觉得这几种实现对于Executor接口的query方法都不能满足你的要求，那怎么办呢？是要去改源码吗？当然不。我们可以建立一个Mybatis拦截器用于拦截Executor接口的query方法，在拦截之后实现自己的query方法逻辑，之后可以选择是否继续执行原来的query方法。

　　对于拦截器Mybatis为我们提供了一个Interceptor接口，通过实现该接口就可以定义我们自己的拦截器。我们先来看一下这个接口的定义：

　　我们可以看到在该接口中一共定义有三个方法，intercept、plugin和setProperties。plugin方法是拦截器用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理。当返回的是代理的时候我们可以对其中的方法进行拦截来调用intercept方法，当然也可以调用其他方法，这点将在后文讲解。setProperties方法是用于在Mybatis配置文件中指定一些属性的。

       定义自己的Interceptor最重要的是要实现plugin方法和intercept方法，在plugin方法中我们可以决定是否要进行拦截进而决定要返回一个什么样的目标对象。而intercept方法就是要进行拦截的时候要执行的方法。

       对于plugin方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做Plugin的类，里面有一个静态方法wrap(Object target,Interceptor interceptor)，通过该方法可以决定要返回的对象是目标对象还是对应的代理。

对于实现自己的Interceptor而言有两个很重要的注解，一个是@Intercepts，其值是一个@Signature数组。@Intercepts用于表明当前的对象是一个Interceptor，而@Signature则表明要拦截的接口、方法以及对应的参数类型。

 

 创建自己的拦截器：MySimpleInterceptor.java

 1 package com.chenyanbin.util;
 2 
 3 import java.util.Properties;
 4 
 5 import org.apache.ibatis.executor.Executor;
 6 import org.apache.ibatis.mapping.MappedStatement;
 7 import org.apache.ibatis.plugin.Interceptor;
 8 import org.apache.ibatis.plugin.Intercepts;
 9 import org.apache.ibatis.plugin.Invocation;
10 import org.apache.ibatis.plugin.Plugin;
11 import org.apache.ibatis.plugin.Signature;
12 import org.apache.ibatis.session.ResultHandler;
13 import org.apache.ibatis.session.RowBounds;
14 
15 @Intercepts({ @Signature(method = "query", type = Executor.class, args = { MappedStatement.class, Object.class,
16         RowBounds.class, ResultHandler.class }) })
17 public class MySimpleInterceptor implements Interceptor {
18     /*
19      * 参数：Invocation {代理对象，被监控的方法对象，当前被监控方法运行时需要实参}
20      */
21     public Object intercept(Invocation invocation) throws Throwable {
22         // TODO Auto-generated method stub
23         System.out.println("被拦截方法执行之前，做的辅助服务。。。。。");
24         Object object = invocation.proceed(); // 执行被拦截方法
25         System.out.println("被拦截方法执行之后，做的辅助服务。。。。。");
26         return object;
27     }
28 
29     /*
30      * 参数：target 表示被拦截的对象，应该是Executor接口实例对象 作用： 如果 被拦截的对象所在的类是有实现接口就为当前拦截对象生成一个代理对象
31      * 如果被拦截的对象所在的类没有指定接口，这个对象之后的行为不会被代理操作
32      */
33     public Object plugin(Object target) {
34         // TODO Auto-generated method stub
35         return Plugin.wrap(target, this);
36     }
37 
38     public void setProperties(Properties properties) {
39         // TODO Auto-generated method stub
40 
41     }
42 
43 }

MyBatis核心配置文件：myBatis-config.xml

 1 
 2 DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 
 6     
 7     
 8     
 9     
10         <package name="com.chenyanbin.beans" />
11         <package name="com.chenyanbin.dao" />
12     
13     
14     
15     
16     
17         
18     
19     
20     
22     
23     default="development">
24         
25         
26             
27             
28             
29             
30                 
31                 
32                 
33                 
34             
35         
36     
37     
38     
39         <package name="com.chenyanbin.dao" />
40     
41 

单元测试

 1 package com.chenyanbin.test;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.util.List;
 6 import org.apache.ibatis.io.Resources;
 7 import org.apache.ibatis.plugin.Interceptor;
 8 import org.apache.ibatis.session.SqlSession;
 9 import org.apache.ibatis.session.SqlSessionFactory;
10 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
11 import org.junit.After;
12 import org.junit.Before;
13 import org.junit.Test;
14 import com.chenyanbin.beans.Dept;
15 import com.chenyanbin.dao.DeptMapper;
16 
17 public class TestMain_01 {
18     private SqlSession session;
19 
20     @Before
21     public void Start() {
22         try {
23             InputStream inputStream = Resources.getResourceAsStream("myBatis-config.xml");
24             SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
25             session = factory.openSession();
26         } catch (Exception e) {
27             e.printStackTrace();
28         }
29     }
30 
31     @After
32     public void end() {
33         if (session == null) {
34             session.close();
35         }
36     }
37 
38     @Test
39     public void test01() throws IOException {
40         Dept d2 = new Dept();
41         d2.setDname("上海事业部");
42         d2.setLoc("上海");
43         d2.setFlag(false);
44         session.insert("deptSave", d2);
45         session.commit();
46         session.close();
47     }
48 
49     @Test
50     public void test02() {    
51         Interceptor ccInterceptor;
52           DeptMapper dao=session.getMapper(DeptMapper.class);
53           List deptList=dao.deptFind();
54           System.out.println("ok");         
55     }
56 
57 }

 1 ##define an appender named console
 2 log4j.appender.console=org.apache.log4j.ConsoleAppender
 3 #The Target value is System.out or System.err
 4 log4j.appender.console.Target=System.out
 5 #set the layout type of the apperder
 6 log4j.appender.console.layout=org.apache.log4j.PatternLayout
 7 #set the layout format pattern
 8 log4j.appender.console.layout.ConversionPattern=[%-5p] %m%n
 9 
10 ##define a logger
11 log4j.rootLogger=debug,console

log4j.properties

MyBatis自定义拦截器，可以拦截接口只有四种.

• Executor.class
• StatementHandler.class
• ParameterHandler.class
• ResultSetHandler.class

 第二章 MyBatis框架Mapper配置文件详解

2.1 参数(#{参数名})

 #{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?

使用#{参数名},将参数的内容添加到sql语句中指定位置.

如果当前sql语句中只有一个参数,此时参数名称可以随意定义

    但是,如果当前sql语句有多个参数,此时参数名称应该是与当前表关联[实体类的属性名]或则[Map集合关键字]

上述SQL语句在调用时,我们可以分别采用如下两种方式输入参数

使用#{}读取实体类对象属性内容

使用#{}读取map集合中关键字的值

2.2 #{}和${}区别

在MyBatis中提供了两种方式读取参数的内容到SQL语句中,分别是

#{参数名} :实体类对象或则Map集合读取内容

 ${参数名} :实体类对象或则Map集合读取内容

 

为了能够看到两种方式的区别,需要看到MyBatis执行时输送的SQL情况.因此

需要借助Log4J日志进行观察

 

第一步: 加载Log4j日志工具包到项目

第二步:将Log4j配置文件添加到src/main/resources下

接下来,我们可以查看

输出结果

 从这里我们可以看出两者的区别:

 #{} : 采用预编译方式,可以防止SQL注入

 ${}:  采用直接赋值方式,无法阻止SQL注入攻击

在大多数情况下,我们都是采用#{}读取参数内容.但是在一些特殊的情况下,我们还是需要使用${}读取参数的.

比如 有两张表,分别是emp_2017 和 emp_2018 .如果需要在查询语句中动态指定表名,就只能使用${}

      select *  from emp_${year}

1     
2         select * from ${value}
3     

动态表名，此处只能:value

再比如.需要动态的指定查询中的排序字段,此时也只能使用${}

       select  *  from dept order by ${name}

简单来说,在JDBC不支持使用占位符的地方,都可以使用${}

2.3 resultMap

　　MyBatis框架中是根据表中字段名到实体类定位同名属性的.如果出现了实体类属性名与表中字段名不一致的情况,则无法自动进行对应.此时可以使用resultMap来重新建立实体类与字段名之间对应关系.

映射表没有的字段

表结构

 

 EmpMapper.xml

 1 
 2 DOCTYPE mapper
 3   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 
 6     
 7         
 8             
 9         
10     
11     
12         select * from emp2
13     
14 

EmpMapper.java

1 package com.chenyanbin.dao;
2 
3 import java.util.List;
4 
5 public interface EmpMapper {
6     public List empFind();
7 }

Employee.java

 1 package com.chenyanbin.beans;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 
 6 public class Employee {
 7     private Integer empNo;
 8     private String ename;
 9     private String job;
10     private Double sal;
11     private Date hireDate;
12     // 职员工作年限
13     private int workAge;
14 
15     // 构造函数
16     public Employee(Date tempDate) {
17         this.hireDate = tempDate;
18         SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
19         this.workAge = Integer.valueOf(sdf.format(new Date())) - Integer.valueOf(sdf.format(tempDate));
20 
21     }
22 
23     public int getWorkAge() {
24         return workAge;
25     }
26 
27     public void setWorkAge(int workAge) {
28         this.workAge = workAge;
29     }
30 
31     public Integer getEmpNo() {
32         return empNo;
33     }
34 
35     public void setEmpNo(Integer empNo) {
36         this.empNo = empNo;
37     }
38 
39     public String getEname() {
40         return ename;
41     }
42 
43     public void setEname(String ename) {
44         this.ename = ename;
45     }
46 
47     public String getJob() {
48         return job;
49     }
50 
51     public void setJob(String job) {
52         this.job = job;
53     }
54 
55     public Double getSal() {
56         return sal;
57     }
58 
59     public void setSal(Double sal) {
60         this.sal = sal;
61     }
62 
63     public Date getHireDate() {
64         return hireDate;
65     }
66 
67     public void setHireDate(Date hireDate) {
68         this.hireDate = hireDate;
69     }
70 }

单元测试

 1 package com.chenyanbin.test;
 2 
 3 import java.io.InputStream;
 4 import java.util.List;
 5 import org.apache.ibatis.io.Resources;
 6 import org.apache.ibatis.session.SqlSession;
 7 import org.apache.ibatis.session.SqlSessionFactory;
 8 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 9 import org.junit.After;
10 import org.junit.Before;
11 import org.junit.Test;
12 
13 import com.chenyanbin.beans.Employee;
14 import com.chenyanbin.dao.DeptMapper;
15 import com.chenyanbin.dao.EmpMapper;
16 
17 public class TestMain_01 {
18     private SqlSession session;
19 
20     @Before
21     public void Start() {
22         try {
23             InputStream inputStream = Resources.getResourceAsStream("myBatis-config.xml");
24             SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
25             session = factory.openSession();
26         } catch (Exception e) {
27             e.printStackTrace();
28         }
29     }
30 
31     @After
32     public void end() {
33         if (session == null) {
34             session.close();
35         }
36     }
37     @Test
38     public void test01() {        
39         try {
40             EmpMapper dao=session.getMapper(EmpMapper.class);
41               List deptList=dao.empFind();
42               System.out.println("sssss");
43         } catch (Exception e) {
44             e.printStackTrace();
45         }
46     }
47 }

项目结构

 2.4 Sql标签

首先,我们如下两条SQL映射

这两条查询映射中要查询的表以及查询的字段是完全一致的.因此可以标签

 将[select  *  from dept]进行抽取.

在需要使用到这个查询的地方,通过标签进行引用

 第三章 MyBatis动态SQL

3.1 什么是MyBatis动态SQL

 根据用户提供的参数,动态决定查询语句依赖的查询条件或则SQL语句的内容

3.2 动态SQL依赖标签

• if
• choose、when、otherwise
• trim、where、set
• foreach

if使用

 

 choose、when、otherwise

　　类似于Java中的switch case default. 只有一个条件生效,也就是只执行满足的条件when,没有满足的条件就执行otherwise,表示默认条件

 

 when的使用

 

 set使用

会在成功拼接的条件前加上SET单词且最后一个”,”号会被无视掉

 

 trim使用

 

 foreach的使用

foreach标签用于对集合内容进行遍历,将得到内容作为SQL语句的一部分.

在实际开发过程中主要用于in语句的构建和批量添加操作

foreach元素的属性主要有 item，index，collection，open，separator，close。

案例1.使用foreach实现批处理添加

 案例2.使用foreach遍历list集合作为查询条件

 案例3.使用foreach遍历数组作为查询条件

案例4.使用foreach遍历Map作为查询条件