MyBatis-逆向工程
简称MBG，是一个专门为MyBatis框架使用者定制的代码生成器，可以快速的根据表生成对应的映射文件，接口，以及bean类。支持基本的增删改查，以及QBC风格的条件查询。但是表连接、存储过程等这些复杂sql的定义需要我们手工编写
所需框架
结构
主要代码（详细代码初始化）：
///mbg/mbg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!--
targetRuntime="MyBatis3Simple":生成简单版的CRUD
MyBatis3:豪华版
-->
<context id="DB2Tables" targetRuntime="MyBatis3">
<!-- jdbcConnection：指定如何连接到目标数据库 -->
<jdbcConnection driverClass="org.apache.derby.jdbc.ClientDriver"
connectionURL="jdbc:derby://localhost:1527/myeclipse"
userId="classiccars"
password="myeclipse">
</jdbcConnection>
<!-- -->
<javaTypeResolver >
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- javaModelGenerator：指定javaBean的生成策略
targetPackage="test.model"：目标包名
targetProject="\MBGTestProject\src"：目标工程
-->
<javaModelGenerator targetPackage="com.mybatis.bean"
targetProject=".\src">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- sqlMapGenerator：sql映射生成策略： -->
<sqlMapGenerator targetPackage="com.mybatis.dao"
targetProject=".\conf">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- javaClientGenerator:指定mapper接口所在的位置 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.mybatis.dao"
targetProject=".\src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 指定要逆向分析哪些表：根据表要创建javaBean -->
<table tableName="DEPARTMENT" domainObjectName="Department"></table>
<table tableName="USER1" domainObjectName="Employee"></table>
</context>
</generatorConfiguration>
//////////////////////////////////////////////////////
//测试/mbg/src/com/mybatis/test/MyBatisTest.java
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void testMbg() throws Exception {
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
File configFile = new File("mbg.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
callback, warnings);
myBatisGenerator.generate(null);
}
//简单查寻
@Test
@Test
public void testMyBatis3Simple() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee list = mapper.selectByPrimaryKey(1);
System.out.println(list);
}finally{
openSession.close();
}
}
//QBC风格的带条件查询
@Test
public void testMyBatis3() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//xxxExample就是封装查询条件的
//1、查询所有
//List<Employee> list = mapper.selectByExample(null);
//2、查询员工名字中有ell字母的，和did是2的
//封装员工查询条件的example
EmployeeExample example = new EmployeeExample();
//创建一个Criteria，这个Criteria就是拼装查询条件
// select USERNAME, PASSWORD, DID from USER1 WHERE ( PASSWORD like ? and DID = ? )
Criteria criteria = example.createCriteria();
criteria.andPasswordLike("%ell%");
criteria.andDidEqualTo(2L);
Criteria criteria2 = example.createCriteria();
criteria2.andPasswordLike("%oai%");
example.or(criteria2);
//select USERNAME, PASSWORD, DID from USER1 WHERE ( PASSWORD like ? and DID = ? ) or( PASSWORD like ?
List<Employee> list = mapper.selectByExample(example);
for (Employee employee : list) {
System.out.println(employee.toString());
}
}finally{
openSession.close();
}
}
MyBatis-工作原理
运行框架
过程
1、根据配置文件创建SQL SessionFactory
2.2、返回SqISession的实现类DefaultSqlSession对象。他里面包含了Executor和Configuration;Executor会在这一步被创建
3.
4.查询流程
/**
* 1、获取sqlSessionFactory对象:
* 解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；
* 注意：【MappedStatement】：代表一个增删改查的详细信息
*
* 2、获取sqlSession对象
* 返回一个DefaultSQlSession对象，包含Executor和Configuration;
* 这一步会创建Executor对象；
*
* 3、获取接口的代理对象（MapperProxy）
* getMapper，使用MapperProxyFactory创建一个MapperProxy的代理对象
* 代理对象里面包含了，DefaultSqlSession（Executor）
* 4、执行增删改查方法
*
* 总结：
* 1、根据配置文件（全局，sql映射）初始化出Configuration对象
* 2、创建一个DefaultSqlSession对象，
* 他里面包含Configuration以及
* Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
* 3、DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；
* 4、MapperProxy里面有（DefaultSqlSession）；
* 5、执行增删改查方法：
* 1）、调用DefaultSqlSession的增删改查（Executor）；
* 2）、会创建一个StatementHandler对象。
* （同时也会创建出ParameterHandler和ResultSetHandler）
* 3）、调用StatementHandler预编译参数以及设置参数值;
* 使用ParameterHandler来给sql设置参数
* 4）、调用StatementHandler的增删改查方法；
* 5）、ResultSetHandler封装结果
* 注意：
* 四大对象每个创建的时候都有一个interceptorChain.pluginAll(parameterHandler);
*
MyBatis-插件开发
MyBatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。
• MyBatis 允许在已映射语句执行过程中的某一点进行
拦截调用。
• 默认情况下，MyBatis 允许使用插件来拦截的方法调
用包括：
• Executor (update, query, flushStatements, commit, rollback,
getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)
例子代码
//javabean/chanjian/src/com/mybatis/bean/Employee.java
package com.mybatis.bean;
import java.io.Serializable;
import org.apache.ibatis.type.Alias;
public class Employee implements Serializable{
/**
*
*/
private int id;
private String name;
private String email;
private String salary;
private int deptid;
public Employee() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getSalary() {
return salary;
}
public void setSalary(String salary) {
this.salary = salary;
}
public int getDeptid() {
return deptid;
}
public void setDeptid(int deptid) {
this.deptid = deptid;
}
@Override
public String toString() {
return "Employee [deptid=" + deptid + ", email=" + email + ", id=" + id
+ ", name=" + name + ", salary=" + salary + "]";
}
public Employee(int id, String name, String email, String salary, int deptid) {
super();
this.id = id;
this.name = name;
this.email = email;
this.salary = salary;
this.deptid = deptid;
}
}
////////////////////////////////////////////////////////////////
///chanjian/src/com/mybatis/dao/EmployeeMapper.java
package com.mybatis.dao;
import com.mybatis.bean.Employee;
public interface EmployeeMapper {
public Employee getEmpById(int id);
}
/////////////////////////////////////////////////////
///映射文件chanjian/conf/EmployeeMapper.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.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.bean.Employee"
>
select * from EMPLOYEES where id = #{id}
</select>
</mapper>
////////////////////////////////////////////////////
//全局配置文件/chanjian/conf/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>
<!--plugins：注册插件 -->
<plugins>
<plugin interceptor="com.mybatis.dao.MyFirstPlugin">
<property name="username" value="classiccars"/>
<property name="password" value="myeclipse"/>
</plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="org.apache.derby.jdbc.ClientDriver" />
<property name="url" value="jdbc:derby://localhost:1527/myeclipse" />
<property name="username" value="classiccars" />
<property name="password" value="myeclipse" />
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
///////////////////////////////////////////////////////
///chanjian/src/com/mybatis/test/MyBatisTest.java测试
package com.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import com.mybatis.bean.Employee;
import com.mybatis.dao.EmployeeMapper;
public class MyBatisTest {
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
/**
* 1、获取sqlSessionFactory对象:
* 解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；
* 注意：【MappedStatement】：代表一个增删改查的详细信息
*
* 2、获取sqlSession对象
* 返回一个DefaultSQlSession对象，包含Executor和Configuration;
* 这一步会创建Executor对象；
*
* 3、获取接口的代理对象（MapperProxy）
* getMapper，使用MapperProxyFactory创建一个MapperProxy的代理对象
* 代理对象里面包含了，DefaultSqlSession（Executor）
* 4、执行增删改查方法
*
* 总结：
* 1、根据配置文件（全局，sql映射）初始化出Configuration对象
* 2、创建一个DefaultSqlSession对象，
* 他里面包含Configuration以及
* Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
* 3、DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；
* 4、MapperProxy里面有（DefaultSqlSession）；
* 5、执行增删改查方法：
* 1）、调用DefaultSqlSession的增删改查（Executor）；
* 2）、会创建一个StatementHandler对象。
* （同时也会创建出ParameterHandler和ResultSetHandler）
* 3）、调用StatementHandler预编译参数以及设置参数值;
* 使用ParameterHandler来给sql设置参数
* 4）、调用StatementHandler的增删改查方法；
* 5）、ResultSetHandler封装结果
* 注意：
* 四大对象每个创建的时候都有一个interceptorChain.pluginAll(parameterHandler);
*
* @throws IOException
*/
@Test
public void test01() throws IOException {
// 1、获取sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
// 2、获取sqlSession对象
SqlSession openSession = sqlSessionFactory.openSession();
try {
// 3、获取接口的实现类对象
//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = mapper.getEmpById(2);
System.out.println(mapper);
System.out.println(employee);
} finally {
openSession.close();
}
}
/**
* 插件原理
* 在四大对象创建的时候
* 1、每个创建出来的对象不是直接返回的，而是
* interceptorChain.pluginAll(parameterHandler);
* 2、获取到所有的Interceptor（拦截器）（插件需要实现的接口）；
* 调用interceptor.plugin(target);返回target包装后的对象
* 3、插件机制，我们可以使用插件为目标对象创建一个代理对象；AOP（面向切面）
* 我们的插件可以为四大对象创建出代理对象；
* 代理对象就可以拦截到四大对象的每一个执行；
*
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
*/
/**
* 插件编写：
* 1、编写Interceptor的实现类
* 2、使用@Intercepts注解完成插件签名
* 3、将写好的插件注册到全局配置文件中
*
*/
@Test
public void testPlugin(){
}
}
////////////////////////////////////////////////////////////////
//拦截器/chanjian/src/com/mybatis/dao/MyFirstPlugin.java
package com.atguigu.mybatis.dao;
import java.util.Properties;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
/**
* 完成插件签名：
* 告诉MyBatis当前插件用来拦截哪个对象的哪个方法
*/
@Intercepts(
{
@Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
})
public class MyFirstPlugin implements Interceptor{
/**
* intercept：拦截：
* 拦截目标对象的目标方法的执行；
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
// TODO Auto-generated method stub
System.out.println("MyFirstPlugin...intercept:"+invocation.getMethod());
//动态的改变一下sql运行的参数：以前1号员工，实际从数据库查询3号员工
Object target = invocation.getTarget();
System.out.println("当前拦截到的对象："+target);
//拿到：StatementHandler==>ParameterHandler===>parameterObject
//拿到target的元数据
MetaObject metaObject = SystemMetaObject.forObject(target);
Object value = metaObject.getValue("parameterHandler.parameterObject");
System.out.println("sql语句用的参数是："+value);
//修改完sql语句要用的参数
metaObject.setValue("parameterHandler.parameterObject", 11);
//执行目标方法
Object proceed = invocation.proceed();
//返回执行后的返回值
return proceed;
}
/**
* plugin：
* 包装目标对象的：包装：为目标对象创建一个代理对象
*/
@Override
public Object plugin(Object target) {
// TODO Auto-generated method stub
//我们可以借助Plugin的wrap方法来使用当前Interceptor包装我们目标对象
System.out.println("MyFirstPlugin...plugin:mybatis将要包装的对象"+target);
Object wrap = Plugin.wrap(target, this);
//返回为当前target创建的动态代理
return wrap;
}
/**
* setProperties：
* 将插件注册时 的property属性设置进来
*/
@Override
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
System.out.println("插件配置的信息："+properties);
}
}
多个拦截器
例子（在之前的基础上）：
//全局配置文件/chanjian/conf/mybatis-config.xml
<!--plugins：注册插件 -->
<plugins>
<plugin interceptor="com.atguigu.mybatis.dao.MyFirstPlugin">
<property name="username" value="classiccars"/>
<property name="password" value="myeclipse"/>
</plugin>
<plugin interceptor="com.mybatis.dao.MySecondPlugin"></plugin>
</plugins>
////////////////////////////////////////////////////////////////
///chanjian/src/com/mybatis/dao/MySecondPlugin.java
package com.atguigu.mybatis.dao;
import java.util.Properties;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
@Intercepts(
{
@Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
})
public class MySecondPlugin implements Interceptor{
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("MySecondPlugin...intercept:"+invocation.getMethod());
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
// TODO Auto-generated method stub
System.out.println("MySecondPlugin...plugin:"+target);
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
}
}
创建动态代理的时候，是按照插件配置顺序创建层层代理对象。
执行目标方法的之后，按照逆向顺序执行
MyBatis实用场景
1）、PageHelper插件进行分页
• PageHelper是MyBatis中非常方便的第三方分页
插件。
• 官方文档：
https://github.com/pagehelper/MybatisPageHelper/blob/master/README_zh.md
例子：
//javabeancom.mybatis.bean
package com.mybatis.bean;
import java.io.Serializable;
import org.apache.ibatis.type.Alias;
public class Employee implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private int id;
private String name;
private String email;
private double salary;
private int deptid;
public Employee() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public int getDeptid() {
return deptid;
}
public void setDeptid(int deptid) {
this.deptid = deptid;
}
@Override
public String toString() {
return "Employee [deptid=" + deptid + ", email=" + email + ", id=" + id
+ ", name=" + name + ", salary=" + salary + "]";
}
public Employee(int id, String name, String email, double salary, int deptid) {
super();
this.id = id;
this.name = name;
this.email = email;
this.salary = salary;
this.deptid = deptid;
}
}
////////////////////////////////////////////////////////////////
///fenye/src/com/mybatis/dao/EmployeeMapper.java
package com.mybatis.dao;
import java.util.List;
import com.mybatis.bean.Employee;
import com.mybatis.bean.OraclePage;
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
public List<Employee> getEmps();
public Long addEmp(Employee employee);
public void getPageByProcedure(OraclePage page);
}
////////////////////////////////////
//映射文件/fenye/conf/EmployeeMapper.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.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.mybatis.bean.Employee">
select id,last_name lastName,email,gender,empStatus from tbl_employee where id = #{id}
</select>
<!--public List<Employee> getEmps(); -->
<select id="getEmps" resultType="com.mybatis.bean.Employee">
select * from EMPLOYEES
</select>
<!--public Long addEmp(Employee employee); -->
<insert id="addEmp" useGeneratedKeys="true" keyProperty="id">
insert into tbl_employee(last_name,email,gender,empStatus)
values(#{lastName},#{email},#{gender},#{empStatus})
</insert>
<!-- public void getPageByProcedure();
1、使用select标签定义调用存储过程
2、statementType="CALLABLE":表示要调用存储过程
3、{call procedure_name(params)}
-->
<select id="getPageByProcedure" statementType="CALLABLE" databaseId="oracle">
{call hello_test(
#{start,mode=IN,jdbcType=INTEGER},
#{end,mode=IN,jdbcType=INTEGER},
#{count,mode=OUT,jdbcType=INTEGER},
#{emps,mode=OUT,jdbcType=CURSOR,javaType=ResultSet,resultMap=PageEmp}
)}
</select>
<resultMap type="com.mybatis.bean.Employee" id="PageEmp">
<id column="EMPLOYEE_ID" property="id"/>
<result column="LAST_NAME" property="email"/>
<result column="EMAIL" property="email"/>
</resultMap>
</mapper>
////////////////////////////////////////////////
//全局配置文件/fenye/conf/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>
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="org.apache.derby.jdbc.ClientDriver" />
<property name="url" value="jdbc:derby://localhost:1527/myeclipse" />
<property name="username" value="classiccars" />
<property name="password" value="myeclipse" />
</dataSource>
</environment>
<environment id="dev_mysql">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
<property name="username" value="root" />
<property name="password" value="123456" />
</dataSource>
</environment>
<environment id="dev_oracle">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${orcl.driver}" />
<property name="url" value="${orcl.url}" />
<property name="username" value="${orcl.username}" />
<property name="password" value="${orcl.password}" />
</dataSource>
</environment>
</environments>
<databaseIdProvider type="DB_VENDOR">
<property name="MySQL" value="mysql"/>
<property name="Oracle" value="oracle"/>
<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>
/////////////////////////////////////////
//测试/fenye/src/com/mybatis/test/MyBatisTest.java
package com.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mybatis.bean.Employee;
import com.mybatis.dao.EmployeeMapper;
/**
* 1、接口式编程
* 原生： Dao ====> DaoImpl
* mybatis： Mapper ====> xxMapper.xml
*
* 2、SqlSession代表和数据库的一次会话；用完必须关闭；
* 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
* 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
* （将接口和xml进行绑定）
* EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
* 5、两个重要的配置文件：
* mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
* sql映射文件：保存了每一个sql语句的映射信息：
* 将sql抽取出来。
*
*
* @author lfy
*
*/
public class MyBatisTest {
public SqlSessionFactory getSqlSessionFactory() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
return new SqlSessionFactoryBuilder().build(inputStream);
}
/**
* 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
* 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。
* 3、将sql映射文件注册在全局配置文件中
* 4、写代码：
* 1）、根据全局配置文件得到SqlSessionFactory；
* 2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
* 一个sqlSession就是代表和数据库的一次会话，用完关闭
* 3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
*
* @throws IOException
*/
@Test
public void test01() throws IOException {
// 1、获取sqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
// 2、获取sqlSession对象
SqlSession openSession = sqlSessionFactory.openSession();
try {
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//Page<Object> page = PageHelper.startPage(1, 1);
List<Employee> emps = mapper.getEmps();
//传入要连续显示多少页
PageInfo<Employee> info = new PageInfo<Employee>(emps, 5);
for (Employee employee : emps) {
System.out.println(employee);
}
/*System.out.println("当前页码："+page.getPageNum());
System.out.println("总记录数："+page.getTotal());
System.out.println("每页的记录数："+page.getPageSize());
System.out.println("总页码："+page.getPages());*/
///xxx
System.out.println("当前页码："+info.getPageNum());
System.out.println("总记录数："+info.getTotal());
System.out.println("每页的记录数："+info.getPageSize());
System.out.println("总页码："+info.getPages());
System.out.println("是否第一页："+info.isIsFirstPage());
System.out.println("连续显示的页码：");
int[] nums = info.getNavigatepageNums();
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
//xxxx
} finally {
openSession.close();
}
}
}
• 2）、批量操作
例子（在前面的基础上）：
///fenye/conf/EmployeeMapper.xml改
<!--public Long addEmp(Employee employee); -->
<insert id="addEmp">
insert into EMPLOYEES(ID,NAME,SALARY,EMAIL,DEPT_ID)
values(#{id},#{name},#{salary},#{email},#{deptid})
</insert>
////////////////////////////////////////////////////////
//测试/fenye/src/com/mybatis/test/MyBatisTest.java
@Test
public void testBatch() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
//可以执行批量操作的sqlSession
SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
//long start = System.currentTimeMillis();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
for (int i = 12; i < 20; i++) {
mapper.addEmp(new Employee(i, "b", "1",10.6,1));
}
openSession.commit();
//long end = System.currentTimeMillis();
//批量：（预编译sql一次==>设置参数===>10000次===>执行（1次））
//Parameters: 616c1(String), b(String), 1(String)==>4598
//非批量：（预编译sql=设置参数=执行）==》10000 10200
//System.out.println("执行时长："+(end-start));
}finally{
openSession.close();
}
}
• 3）、存储过程
实际开发中，我们通常也会写一些存储过程，MyBatis也支持对存储过程的调用
例子（在前面的基础上）：
///fenye/src/com/mybatis/bean/OraclePage.java
package com.mybatis.bean;
import java.util.List;
/**
* 封装分页查询数据
* @author lfy
*
*/
public class OraclePage {
private int start;
private int end;
private int count;
private List<Employee> emps;
public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public List<Employee> getEmps() {
return emps;
}
public void setEmps(List<Employee> emps) {
this.emps = emps;
}
}
////////////////////////////////////////////////////////////
//测试增加/fenye/src/com/mybatis/test/MyBatisTest.java
/**
* oracle分页：
* 借助rownum：行号；子查询；
* 存储过程包装分页逻辑
* @throws IOException
*/
@Test
public void testProcedure() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
OraclePage page = new OraclePage();
page.setStart(1);
page.setEnd(5);
mapper.getPageByProcedure(page);
System.out.println("总记录数："+page.getCount());
System.out.println("查出的数据："+page.getEmps().size());
System.out.println("查出的数据："+page.getEmps());
}finally{
openSession.close();
}
}
• 4）、typeHandler处理枚举
自定义TypeHandler处理枚举
我们可以通过自定义TypeHandler的形式来在设置参数或
者取出结果集的时候自定义参数封装策略。 • 步骤：
– 1、实现TypeHandler接口或者继承BaseTypeHandler
– 2、使用@MappedTypes定义处理的java类型
使用@MappedJdbcTypes定义jdbcType类型
– 3、在自定义结果集标签或者参数处理的时候声明使用自定义
TypeHandler进行处理
或者在全局配置TypeHandler要处理的javaType
例子（在前面的基础上）：
///fenye/src/com/mybatis/bean/EmpStatus.java
package com.mybatis.bean;
import com.sun.org.apache.bcel.internal.generic.RETURN;
/**
* 希望数据库保存的是100,200这些状态码，而不是默认0,1或者枚举的名
* @author lfy
*
*/
public enum EmpStatus {
LOGIN(100,"用户登录"),LOGOUT(200,"用户登出"),REMOVE(300,"用户不存在");
private Integer code;
private String msg;
private EmpStatus(Integer code,String msg){
this.code = code;
this.msg = msg;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
//按照状态码返回枚举对象
public static EmpStatus getEmpStatusByCode(Integer code){
switch (code) {
case 100:
return LOGIN;
case 200:
return LOGOUT;
case 300:
return REMOVE;
default:
return LOGOUT;
}
}
}
///////////////////////////////////////////////////////////////
///fenye/src/com/mybatis/typehandler/MyEnumEmpStatusTypeHandler.java
package com.mybatis.typehandler;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;
import com.mybatis.bean.EmpStatus;
/**
* 1、实现TypeHandler接口。或者继承BaseTypeHandler
* @author lfy
*
*/
public class MyEnumEmpStatusTypeHandler implements TypeHandler<EmpStatus> {
/**
* 定义当前数据如何保存到数据库中
*/
@Override
public void setParameter(PreparedStatement ps, int i, EmpStatus parameter,
JdbcType jdbcType) throws SQLException {
// TODO Auto-generated method stub
System.out.println("要保存的状态码："+parameter.getCode());
ps.setString(i, parameter.getCode().toString());
}
@Override
//从数据库中获取状态码
public EmpStatus getResult(ResultSet rs, String columnName)
throws SQLException {
// TODO Auto-generated method stub
//需要根据从数据库中拿到的枚举的状态码返回一个枚举对象
int code = rs.getInt(columnName);
System.out.println("从数据库中获取的状态码："+code);
EmpStatus status = EmpStatus.getEmpStatusByCode(code);
return status;
}
@Override
//从数据库中获取相应索引值
public EmpStatus getResult(ResultSet rs, int columnIndex)
throws SQLException {
// TODO Auto-generated method stub
int code = rs.getInt(columnIndex);
System.out.println("从数据库中获取的状态码："+code);
EmpStatus status = EmpStatus.getEmpStatusByCode(code);
return status;
}
@Override
//从数据库存储过程中获取相应索引值
public EmpStatus getResult(CallableStatement cs, int columnIndex)
throws SQLException {
// TODO Auto-generated method stub
int code = cs.getInt(columnIndex);
System.out.println("从数据库中获取的状态码："+code);
EmpStatus status = EmpStatus.getEmpStatusByCode(code);
return status;
}
}
////////////////////////////////////////////////////////////////
//映射文件/fenye/conf/EmployeeMapper.xml改
<select id="getEmpById" resultType="com.mybatis.bean.Employee">
select * from employees where id = #{id}
</select>
<!--public List<Employee> getEmps(); -->
<select id="getEmps" resultType="com.mybatis.bean.Employee">
select * from EMPLOYEES
</select>
<!--public Long addEmp(Employee employee); -->
<insert id="addEmp" useGeneratedKeys="true" keyProperty="id">
insert into EMPLOYEES(ID,NAME,SALARY,EMAIL,DEPT_ID,e)
values(#{id},#{name},#{salary},#{email},#{deptid},#{e})
</insert>
///////////////////////////////////////////////
//全局配置文件/fenye/conf/mybatis-config.xml增加
<typeHandlers>
<!--1、配置我们自定义的TypeHandler -->
<typeHandler handler="com.mybatis.typehandler.MyEnumEmpStatusTypeHandler" javaType="com.mybatis.bean.EmpStatus"/>
<!--2、也可以在处理某个字段的时候告诉MyBatis用什么类型处理器
在映射文件中
保存：#{empStatus,typeHandler=xxxx}
查询：
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmp">
<id column="id" property="id"/>
<result column="empStatus" property="empStatus" typeHandler=""/>
</resultMap>
注意：如果在参数位置修改TypeHandler，应该保证保存数据和查询数据用的TypeHandler是一样的。
-->
</typeHandlers>
////////////////////////////////////////////////////////////////
//测试/fenye/src/com/mybatis/test/MyBatisTest.java增加
@Test
public void testEnumUse(){
EmpStatus login = EmpStatus.LOGIN;
System.out.println("枚举的索引："+login.ordinal());
System.out.println("枚举的名字："+login.name());
System.out.println("枚举的状态码："+login.getCode());
System.out.println("枚举的提示消息："+login.getMsg());
}
/**
* 默认mybatis在处理枚举对象的时候保存的是枚举的名字：EnumTypeHandler
* 改变使用：EnumOrdinalTypeHandler：
* @throws IOException
*/
@Test
public void testEnum() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
// Employee employee = new Employee(23,"test_enum", "[email protected]",26.6,3);
// mapper.addEmp(employee);
// System.out.println("保存成功"+employee.getId());
// openSession.commit();
Employee empById = mapper.getEmpById(23);
System.out.println(empById.getE());
}finally{
openSession.close();
}
}
