1.MyBatis_简介
2.MyBatis_下载
3.MyBatis_HelloWorld
(environments配置环(配置数据源)&SqlSessionFactory(通过sqlSessionFactoryBuilder()获取sqlSessionFactory.openSession()获取sqlSession.selectOne(“selectEmp”,1)可以直接执行已经映射的sql语句)&SqlSession&使用resultType实现(返回的数据类型)&mappers配置分析(#{id}从传递过来得到参数中取出id值，将写好的sql映射文件注册到全局mappers中，resource=”EmployeeMapper.xml”)&使用typeAliases配置别名)
4.MyBatis_接口式编程
(MyBatis注解配置(getSqlSessionFactory(),openSession.getMapper(EmployeeMappers.class)，mapper.getEmpById(1)象)&命名空间：Namespace (namespace指定接口的全类名，select的id要与方法进行绑定，通过生成代理对象，通过代理对象进行增删改查)&)
5.MyBatis_小结(1)
(Connection(非线程安全，不能写在成员变量里，每次使用获取新的对象)&)
6.MyBatis_全局配置文件_引入dtd约束
(为Web 资源设置安全约束(window perferences xm xml Catalog 添加进Mybatis的约束，以后在xml文件中就会有提示)&)
7.MyBatis_全局配置文件_properties_引入外部配置文件
(修改db.properties文件(通过url获取网络或者类路径下的配置文件，类路径通过resource引入，com/)&)
8.MyBatis_全局配置文件_settings_运行时行为设置
(用驼峰法命名属性(在settings中设置，mapUnderscoreToCamelCase不用起别名)&使用resultType实现&alias标签的解析&)
9.MyBatis_全局配置文件_typeAliases_别名
(typeAliases类型命名(<typeAliases> <typeAlias type=”com.Employee” alias=””> </typeAliases>，默认别名为类名小写,package name=”” 为包下的类批量起别名。通过@Alias(“”)为类指定类的别名)&)
10.MyBatis_全局配置文件_typeHandlers_类型处理器简介
(typeHandlers类型处理器(Java类型与数据库类型一一对应，)&)
11.MyBatis_全局配置文件_plugins_插件简介
(plugins配置分析(Executor执行器的方法，query，commit，update，rollback可以通过插件机制在executor执行增删改前执行默认的行为，ParameterHandler参数处理器，预编译需要设置参数，ResultSetHandler结果集处理器，StatementHandler对sql语句进行处理，插件可以拦截四大对象的方法)&)
12.MyBatis_全局配置文件_enviroments_运行环境
( default访问修饰符(通过environments的default指定某个环境进行切换)&DataSource(id是environment唯一标识，)&配置多个连接数据库环境(可以配置多个environment标签，environment中有<transactionManager type=”JDBC”>和<dataSource>两种标签，JDBC事务与Managed使用J2EE容器的事物处理方式，dataSource type=”POOLED”使用连接池技术)&)
13.MyBatis_全局配置文件_databaseIdProvider_多数据库支持
(databaseIdProvider数据库厂商标识(<databaseIdProvider type=”DB_VENDOR”>为不同数据库厂商起别名 <property name=”MySQL” value=”mysql”>)&在SQL映射的id值相同的情况下有无databaseId的优先级判断(<select databaseId=”mysql”>，只需要告诉mysql，对应的sql语句是在什么环境下的))
14.MyBatis_全局配置文件_mappers_sql映射注册
(使用Mapper接口对查询的数据进行分页(resource引用类路径下的sql映射文件，url应用网络或者磁盘路径下的资源，class直接引用接口，接口全类名，xml必须和接口放在同一目录下并且文件名一致，也可以直接将sql语句写在接口上，@Select,重要的需要映射文件<package name=””> 批量注册)&)
15.MyBatis_小结(2)
(@Configuration创世纪(映射文件的中标签要有一定的前后顺序，里面的一些标签可以没有)&)
16.MyBatis_映射文件_增删改查
(＜parameter＞标签和其处理类(parameterType参数类型可以指定全类名或者别名，#{email}取出对象中的属性值)&＜sql:update＞标签(<update id=””><delete >更新可以不写parameter，mybatis允许增删改直接定义以下类型的返回值 Integer，Long，Boolean)&)
17.MyBatis_映射文件_insert_获取自增主键的值
(sqlSessionFactory创建(ssqlSessionFactory.openSession(true)自动提交，)&获取后一个自动生成的ID值的函数(useGeneratedKeys=”true” keyProperty=”id” 指定属性对应的主键值,Oracle不支持自增)&)
18.MyBatis_映射文件_insert_Oracle使用序列生成主键演示
19.MyBatis_映射文件_insert_获取非自增主键的值_selectKey
(序列对象(oracle序列就是自增，<selectKey keyProperty=”” order=”BEFORE”></selectKey> 查询主键的sql语句，写sql不能带分号)&)
20.MyBatis_映射文件_参数处理_单个参数&多个参数&命名参数
( 参数（Parameters）(mybatis单个参数不会做特殊处理#{absa}，多个参数时mybatis会封装成一个Map，#{param1}获取指定的key，命名参数在接口方法上test(@Param(“id”) Integer id，@Param(“lastName”)String lastName) #{id})¶meters 指令支持的参数类型&请求参数与返回对象()&)
21.MyBatis_映射文件_参数处理_POJO&Map&TO
(POJO映射(直接传入POJO，通过#{属性名}获取POJO的值，也可以直接传入Map test(Map<String,Object> map)，#{key}取出key的值)&)
22.MyBatis_映射文件_参数处理_参数封装扩展思考
(ids日志源(test(@Param(“e”)Employee emp)e.lastName test(List<Integer> ids) 如果是数组或者集合类型会特殊处理，collection或者list或者array作为key #{list[0})&模糊查询((%ss%))&)
23.MyBatis_源码分析_参数处理_参数封装map的过程
()
24.MyBatis_映射文件_参数处理_#与$取值区别
(预编译(#{}会进行预编译处理，${}直接将值拼到sql中会有sql注入风险，大多分库分表的情况下，表名不能使用占位符需要使用${year}_salary,order by ${f_name} asc ${order})&防止SQL注入&分库分表解决方案&)
25.MyBatis_映射文件_参数处理_#取值时指定参数相关规则
(插入null值的第 1种方法——JdbcType(mybatis对于所有null映射为jdbcType为OTHER类型，#{jdbcType=null}处理null值，也可以全局配置<setting name=”jdbcTypeForNull” value=”Null”> 为null的时候oracle识别)&)
26.MyBatis_映射文件_select_返回List
(使用resultType实现(如果返回值为List，resultType要写集合中封装的类型，mybatis会自动封装集合返回)&)
27.MyBatis_映射文件_select_记录封装map
(主键(返回类型为map，resultType为map类型单个记录，多条记录封装一个map，Map<Integer,Employee> ，resultType始终是封装集合中元素的类型，接口上使用@MapKey(“id”)告诉Mybatis封装map时使用哪个属性做为主键)&)
28.MyBatis_映射文件_select_resultMap_自定义结果映射规则
(＜resultMap＞标签(如果列名与属性名不一致的情况下，resultMap=”MyEmp”可以自定义映射规则与resultType只能使用一个，@Alias(“emp”) <resultMap type=”emp”> )& COLUMN命令(<id column=”id” property=”id”>指定哪一列对应哪一个property，非主键使用result定义)&)
29.MyBatis_映射文件_select_resultMap_关联查询_环境搭建
(使用外键需要注意的问题(外键级联属性，<result column=”did” prototype=”dept.id”> <result column=”dept_name” prototype=”dept.departmentName”> )&)
30.MyBatis_映射文件_select_resultMap_关联查询_级联属性封装结果
(联合查询(<association property=”dept” javaType=””>指定javaBean中的属性值，JavaType指定联合主键的类型<id column=”did” property=”id”> sql查询来的did,对应JavaBean的属性值)&)
31.MyBatis_映射文件_select_resultMap_关联查询_association定义关联对象封装规则
32.MyBatis_映射文件_select_resultMap_关联查询_association分步查询
(排序查询(分布查询 <association property=”dept” select=”com.getDeptById” column=”d_id”> 当前属性是调用select指定的方法查出的结果，column指定将哪一列的值传给该方法,最后封装给dept)&)
33.MyBatis_映射文件_select_resultMap_关联查询_分步查询&延迟加载
(提前加载和延迟加载(分段查询希望使用的时候再去查询，节省资源，<setting name=”LazyLoadingEnabled” value=”true”>，)&)
34.MyBatis_映射文件_select_resultMap_关联查询_collection定义关联集合封装规则
(一对多查询(left Join <collection property=”emp” ofType=””> 定义关联集合类型的属性的封装规则，ofType指定集合里面元素额类型，在里面定义集合元素的封装对象规则)&)
35.MyBatis_映射文件_select_resultMap_关联查询_collection分步查询&延迟加载
(实体类定义与Mapper编写(一对多的分段查询<id column=”id” property=”id”/> <collection property=”emps” select=”com.getEmpsById” column=”id”> 将查询出的id列值传递给方法进行查询)&)
36.MyBatis_映射文件_select_resultMap_分步查询传递多列值&fetchType
(Columns分区(分布查询传入多列的值 column=”{deptId=id,key2=column2}” #{deptId})&使用fetchType属性设置局部加载策略(<collection fetchType=”lazy”> 延迟加载)&)
37.MyBatis_映射文件_select_resultMap_discriminator鉴别器
(鉴别非法电话号码(判断某列的值，根据值进行封装，<discriminator javaType=”string” column=”gender”> <case value=”0” resultType=””></case> 指定封装什么类型时开始进行判断)&)
38.MyBatis_动态sql_简介&环境搭建
(Namespace类型(namespace写接口的全类名)&)
39.MyBatis_动态sql_if_判断&OGNL
( if语句(<if text=”id!=null and && id!=’’ ""”> 根据参数中取值进行判断，转义字符处理特殊字符 and email.trim()!=" 会对字符串与数字进行自动转换)&)
40.MyBatis_动态sql_where_查询条件
(trim、where、set元素(where 1=1 <if test=”id!=null”> and id=#{id}</id>，或者通过<where>标签包含所有动态条件，不需要用1=1，自动去除第一个多出来的and或者or )&)
41.MyBatis_动态sql_trim_自定义字符串截取
(＜trim＞、＜where＞、＜set＞元素(将后面多出来的and或if去掉，prefix=”where”指定前缀，suffixOverrides=”and”去掉整个字符串后面多余的字符 )&)
42.MyBatis_动态sql_choose_分支选择
( choose、when和otherwise标签(choose相当于case <choose><when test=”id!=null”> <otherwise> 1=1 )&)
43.MyBatis_动态sql_set_与if结合的动态更新
(Set(<set> <if> last_name = #{lastName}, 取出更新后的逗号，<trim prefix=”set” suffixOverides=”,”>)&)
44.MyBatis_动态sql_foreach_遍历集合
(＜foreach＞标签的使用(<foreach collection=”ids” items=”item_id”>collection指定遍历的集合， list类型的参数会封装在map中，map的key对应list，separator元素之间的分隔符，open以什么开头，index就是索引，对应map的index就是key)&)
45.MyBatis_动态sql_foreach_mysql下foreach批量插入的两种方式
(实例26：“批量插入”与“逐条插入”数据，比较性能差异(values(),() #{emp.dept.id}属性的属性，new Department(1))&JDBC连接属性(jdbc.url=3306/mybatis?allowMultiQueries=true，多个sql之间;分隔)&)
46.MyBatis_动态sql_foreach_oracle下批量插入的两种方式
(针对Oracle的CURD(oracle不支持values(),()在begin end;中定义多条insert 语句，也可以通过中间表把数据一块拿出来，from dual union 连接上之后一块插入)&)
47.MyBatis_动态sql_foreach_oracle下foreach批量保存两种方式
(批量更新(oracle添加更新 open=”begin” close=”end;” begin <foreach> </foreach> end;)&)
48.MyBatis_动态sql_内置参数_parameter&_databaseId
(循环的内置参数(_paramete代码传入的参数，判断传入的参数是否为null，_databaseId当前数据库的别名 )&)
49.MyBatis_动态sql_bind_绑定
(使用bind()方法绑定事件(模糊查询 ’%${lastName}%’，将OGNL表达式的值绑定在一个变量中，<bind name=”_lastName” value=”’%’+lastName+’%’”> #{_lastName})&)
50.MyBatis_动态sql_sql_抽取可重用的sql片段
(SQL语言基础(<sql id=”insertColumn”> employee_id,last_name,email ,直接使用<include refid=”insertColumn”> 直接使用include引用外部定义的sql)&)
51.MyBatis_缓存_缓存介绍
52.MyBatis_缓存_一级缓存体验
(获取本地缓存数据(一级缓存为本地缓存与数据库同一次会话查询到的数据sqlSession级别的 mapper=openSession.getMapper(Employee.class) emp = mapper.getEmpById(1)，一级缓存一直会开启。二级缓存为全局缓存)&)
53.MyBatis_缓存_一级缓存失效的四种情况
(如何解决失效问题(sqlSession不同一级缓存失效，查询条件不同，两次查询之间进行了增删改等操作，)&)
54.MyBatis_缓存_二级缓存介绍
(namespace资源隔离(二级缓存namespacec级别的缓存，会话关闭一级缓存的数据会被保存到二级缓存中，)&)
55.MyBatis_缓存_二级缓存使用&细节
(二级缓存（mapper级别）(<setting name=”cacheEnabled” value=”true”> 开启全局二级缓冲， <cache eviction=”LRU”></cache>)&)
56.MyBatis_缓存_缓存有关的设置以及属性
(测试select、insert、update和delete操作(useCache=”false” 二级缓冲不适用，增删改flushCache=”true” 查询不会再使用缓存，清除1，2级缓存的数据，每次查询之后就会清除缓存)&clear( )清空缓冲区(只是清除一级缓存)&)
57.MyBatis_缓存_缓存原理图示
(二级缓存原理阐述(会话关闭，一级缓存的数据就会保存在二级缓存中，先查找二级缓存范围较大，之后再查询一级缓存与数据库)&)
58.MyBatis_缓存_第三方缓存整合原理&ehcache适配包下载
59.MyBatis_缓存_MyBatis整合ehcache&总结
(整合Ehcache(<cache type=”com.EhcacheCache” <cache-ref namespace=””> 和那个名称空间下的缓存一样>)&)
60.MyBatis_整合Spring_整合适配包下载
61.MyBatis_整合Spring_所有需要的jar包导入
62.MyBatis_整合Spring_引入MyBatis之前的配置
63.MyBatis_整合Spring_SpringMVC配置文件编写
64.MyBatis_整合Spring_Spring配置文件编写
65.MyBatis_整合Spring_Spring整合MyBatis关键配置
(datasourcetransactionmanager的实现(spring与mybatis用同样的事务管理器，通过控制连接池的连接达到控制事务的目的，)&FactoryBean的使用(sqlSessionFactoryBean实现了FactoryBean接口，调用getObject()方法来创建sqlSessionFactory对象，)& 创建Configuration对象(指定全局配置文件的位置<property name=”configuration” value=”classpath:mybatis-config.xml”>)&)
66.MyBatis_整合Spring_整合测试
67.MyBatis_逆向工程_mbg简介
68.MyBatis_逆向工程_mgb配置文件编写
69.MyBatis_逆向工程_使用mbg逆向生成所有代码及配置
70.MyBatis_逆向工程_测试简单查询&测试带条件复杂查询
71.MyBatis_运行原理_框架分层架构
(网络接口层（数据链路层）&Executor框架&)
72.MyBatis_运行原理_调试前注意
73.MyBatis_运行原理_SQLSessionFactory的初始化
(DeploymentBuilder对象&)
74.MyBatis_运行原理_openSession获取SqlSession对象
( Configuration介绍&使用--no-defaults选项&Statement接口&Statement接口)
75.MyBatis_运行原理_getMapper获取到接口的代理对象
76.MyBatis_运行原理_查询实现
77.MyBatis_运行原理_查询流程总结
78.MyBatis_运行原理_MyBatis原理总结
79.MyBatis_插件_插件原理
80.MyBatis_插件_插件编写&单个插件原理
81.MyBatis_插件_多个插件运行流程
82.MyBatis_插件_开发插件
83.MyBatis_扩展_分页_PageHelpler分页插件使用
84.MyBatis_扩展_批量_BatchExecutor&Spring中配置批量sqlSession
85.MyBatis_扩展_存储过程_oracle中创建一个带游标的存储过程
86.MyBatis_扩展_存储过程_MyBatis调用存储过程
87.MyBatis_扩展_自定义类型处理器_MyBatis中枚举类型的默认处理
88.MyBatis_扩展_自定义类型处理器_使用自定义的类型处理器处理枚举类型
66.MyBatis_整合Spring_整合测试
67.MyBatis_逆向工程_mbg简介
68.MyBatis_逆向工程_mgb配置文件编写
69.MyBatis_逆向工程_使用mbg逆向生成所有代码及配置
70.MyBatis_逆向工程_测试简单查询&测试带条件复杂查询
单个参数：mybatis不会做特殊处理，
#{参数名/任意名}：取出参数值。
多个参数：mybatis会做特殊处理。
多个参数会被封装成 一个map，
key：param1...paramN,或者参数的索引也可以
value：传入的参数值
#{}就是从map中获取指定的key的值；
异常：
org.apache.ibatis.binding.BindingException:
Parameter 'id' not found.
Available parameters are [1, 0, param1, param2]
操作：
方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
取值：#{id},#{lastName}
【命名参数】：明确指定封装参数时map的key；@Param("id")
多个参数会被封装成 一个map，
key：使用@Param注解指定的值
value：参数值
#{指定的key}取出对应的参数值
POJO：
如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo；
#{属性名}：取出传入的pojo的属性值
Map：
如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map
#{key}：取出map中对应的值
TO：
如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象
Page{
int index;
int size;
}
========================思考================================
public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}
public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}
##特别注意：如果是Collection（List、Set）类型或者是数组，
也会特殊处理。也是把传入的list或者数组封装在map中。
key：Collection（collection）,如果是List还可以使用这个key(list)
数组(array)
public Employee getEmpById(List<Integer> ids);
取值：取出第一个id的值： #{list[0]}
========================结合源码，mybatis怎么处理参数==========================
总结：参数多时会封装map，为了不混乱，我们可以使用@Param来指定封装时使用的key；
#{key}就可以取出map中的值；
(@Param("id")Integer id,@Param("lastName")String lastName);
ParamNameResolver解析参数封装map的；
//1、names：{0=id, 1=lastName}；构造器的时候就确定好了
确定流程：
1.获取每个标了param注解的参数的@Param的值：id，lastName； 赋值给name;
2.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
name的值：
标注了param注解：注解的值
没有标注：
1.全局配置：useActualParamName（jdk1.8）：name=参数名
2.name=map.size()；相当于当前元素的索引
{0=id, 1=lastName,2=2}
args【1，"Tom",'hello'】:
public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
//1、参数为null直接返回
if (args == null || paramCount == 0) {
return null;
//2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
//3、多个元素或者有Param标注
} else {
final Map<String, Object> param = new ParamMap<Object>();
int i = 0;
//4、遍历names集合；{0=id, 1=lastName,2=2}
for (Map.Entry<Integer, String> entry : names.entrySet()) {
//names集合的value作为key; names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
//eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)param
//额外的将每一个参数也保存到map中，使用新的key：param1...paramN
//效果：有Param注解可以#{指定的key}，或者#{param1}
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
}
===========================参数值的获取======================================
#{}：可以获取map中的值或者pojo对象属性的值；
${}：可以获取map中的值或者pojo对象属性的值；
select * from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select * from tbl_employee where id=2 and last_name=?
区别：
#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
${}:取出的值直接拼装在sql语句中；会有安全问题；
大多情况下，我们去参数的值都应该去使用#{}；
原生jdbc不支持占位符的地方我们就可以使用${}进行取值
比如分表、排序。。。；按照年份分表拆分
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}
#{}:更丰富的用法：
规定参数的一些规则：
javaType、 jdbcType、 mode（存储过程）、 numericScale、
resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；
jdbcType通常需要在某种特定的条件下被设置：
在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）；
JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理;
由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法
1、#{email,jdbcType=OTHER};
2、jdbcTypeForNull=NULL
<setting name="jdbcTypeForNull" value="NULL"/>
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="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true"
userId="root"
password="123456">
</jdbcConnection>
<!-- -->
<javaTypeResolver >
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- javaModelGenerator：指定javaBean的生成策略
targetPackage="test.model"：目标包名
targetProject="\MBGTestProject\src"：目标工程
-->
<javaModelGenerator targetPackage="com.atguigu.mybatis.bean"
targetProject=".\src">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- sqlMapGenerator：sql映射生成策略： -->
<sqlMapGenerator targetPackage="com.atguigu.mybatis.dao"
targetProject=".\conf">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- javaClientGenerator:指定mapper接口所在的位置 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.atguigu.mybatis.dao"
targetProject=".\src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 指定要逆向分析哪些表：根据表要创建javaBean -->
<table tableName="tbl_dept" domainObjectName="Department"></table>
<table tableName="tbl_employee" domainObjectName="Employee"></table>
</context>
</generatorConfiguration>
package com.atguigu.mybatis.test;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
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 org.junit.Test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.bean.EmployeeExample;
import com.atguigu.mybatis.bean.EmployeeExample.Criteria;
import com.atguigu.mybatis.dao.EmployeeMapper;
/*import com.atguigu.mybatis.bean.Employee;
import com.atguigu.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);
}
@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
public void testMyBatis3Simple() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
List<Employee> list = mapper.selectByExample(null);
for (Employee employee : list) {
System.out.println(employee.getId());
}
}finally{
openSession.close();
}
}
@Test
public void testMyBatis3() throws IOException{
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try{
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
//xxxExample就是封装查询条件的
//1、查询所有
//List<Employee> emps = mapper.selectByExample(null);
//2、查询员工名字中有e字母的，和员工性别是1的
//封装员工查询条件的example
EmployeeExample example = new EmployeeExample();
//创建一个Criteria，这个Criteria就是拼装查询条件
//select id, last_name, email, gender, d_id from tbl_employee
//WHERE ( last_name like ? and gender = ? ) or email like "%e%"
Criteria criteria = example.createCriteria();
criteria.andLastNameLike("%e%");
criteria.andGenderEqualTo("1");
Criteria criteria2 = example.createCriteria();
criteria2.andEmailLike("%e%");
example.or(criteria2);
List<Employee> list = mapper.selectByExample(example);
for (Employee employee : list) {
System.out.println(employee.getId());
}
}finally{
openSession.close();
}
}
}
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.bean.EmployeeExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface EmployeeMapper {
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int countByExample(EmployeeExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int deleteByExample(EmployeeExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int deleteByPrimaryKey(Integer id);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int insert(Employee record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int insertSelective(Employee record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
List<Employee> selectByExample(EmployeeExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
Employee selectByPrimaryKey(Integer id);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByExampleSelective(@Param("record") Employee record, @Param("example") EmployeeExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByExample(@Param("record") Employee record, @Param("example") EmployeeExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByPrimaryKeySelective(Employee record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByPrimaryKey(Employee record);
}package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Department;
import com.atguigu.mybatis.bean.DepartmentExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface DepartmentMapper {
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int countByExample(DepartmentExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int deleteByExample(DepartmentExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int deleteByPrimaryKey(Integer id);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int insert(Department record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int insertSelective(Department record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
List<Department> selectByExample(DepartmentExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
Department selectByPrimaryKey(Integer id);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByExampleSelective(@Param("record") Department record, @Param("example") DepartmentExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByExample(@Param("record") Department record, @Param("example") DepartmentExample example);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByPrimaryKeySelective(Department record);
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_dept
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
int updateByPrimaryKey(Department record);
}package com.atguigu.mybatis.bean;
import java.util.ArrayList;
import java.util.List;
public class EmployeeExample {
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
protected String orderByClause;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
protected boolean distinct;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
protected List<Criteria> oredCriteria;
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public EmployeeExample() {
oredCriteria = new ArrayList<Criteria>();
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public String getOrderByClause() {
return orderByClause;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public boolean isDistinct() {
return distinct;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andLastNameIsNull() {
addCriterion("last_name is null");
return (Criteria) this;
}
public Criteria andLastNameIsNotNull() {
addCriterion("last_name is not null");
return (Criteria) this;
}
public Criteria andLastNameEqualTo(String value) {
addCriterion("last_name =", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameNotEqualTo(String value) {
addCriterion("last_name <>", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameGreaterThan(String value) {
addCriterion("last_name >", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameGreaterThanOrEqualTo(String value) {
addCriterion("last_name >=", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameLessThan(String value) {
addCriterion("last_name <", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameLessThanOrEqualTo(String value) {
addCriterion("last_name <=", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameLike(String value) {
addCriterion("last_name like", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameNotLike(String value) {
addCriterion("last_name not like", value, "lastName");
return (Criteria) this;
}
public Criteria andLastNameIn(List<String> values) {
addCriterion("last_name in", values, "lastName");
return (Criteria) this;
}
public Criteria andLastNameNotIn(List<String> values) {
addCriterion("last_name not in", values, "lastName");
return (Criteria) this;
}
public Criteria andLastNameBetween(String value1, String value2) {
addCriterion("last_name between", value1, value2, "lastName");
return (Criteria) this;
}
public Criteria andLastNameNotBetween(String value1, String value2) {
addCriterion("last_name not between", value1, value2, "lastName");
return (Criteria) this;
}
public Criteria andEmailIsNull() {
addCriterion("email is null");
return (Criteria) this;
}
public Criteria andEmailIsNotNull() {
addCriterion("email is not null");
return (Criteria) this;
}
public Criteria andEmailEqualTo(String value) {
addCriterion("email =", value, "email");
return (Criteria) this;
}
public Criteria andEmailNotEqualTo(String value) {
addCriterion("email <>", value, "email");
return (Criteria) this;
}
public Criteria andEmailGreaterThan(String value) {
addCriterion("email >", value, "email");
return (Criteria) this;
}
public Criteria andEmailGreaterThanOrEqualTo(String value) {
addCriterion("email >=", value, "email");
return (Criteria) this;
}
public Criteria andEmailLessThan(String value) {
addCriterion("email <", value, "email");
return (Criteria) this;
}
public Criteria andEmailLessThanOrEqualTo(String value) {
addCriterion("email <=", value, "email");
return (Criteria) this;
}
public Criteria andEmailLike(String value) {
addCriterion("email like", value, "email");
return (Criteria) this;
}
public Criteria andEmailNotLike(String value) {
addCriterion("email not like", value, "email");
return (Criteria) this;
}
public Criteria andEmailIn(List<String> values) {
addCriterion("email in", values, "email");
return (Criteria) this;
}
public Criteria andEmailNotIn(List<String> values) {
addCriterion("email not in", values, "email");
return (Criteria) this;
}
public Criteria andEmailBetween(String value1, String value2) {
addCriterion("email between", value1, value2, "email");
return (Criteria) this;
}
public Criteria andEmailNotBetween(String value1, String value2) {
addCriterion("email not between", value1, value2, "email");
return (Criteria) this;
}
public Criteria andGenderIsNull() {
addCriterion("gender is null");
return (Criteria) this;
}
public Criteria andGenderIsNotNull() {
addCriterion("gender is not null");
return (Criteria) this;
}
public Criteria andGenderEqualTo(String value) {
addCriterion("gender =", value, "gender");
return (Criteria) this;
}
public Criteria andGenderNotEqualTo(String value) {
addCriterion("gender <>", value, "gender");
return (Criteria) this;
}
public Criteria andGenderGreaterThan(String value) {
addCriterion("gender >", value, "gender");
return (Criteria) this;
}
public Criteria andGenderGreaterThanOrEqualTo(String value) {
addCriterion("gender >=", value, "gender");
return (Criteria) this;
}
public Criteria andGenderLessThan(String value) {
addCriterion("gender <", value, "gender");
return (Criteria) this;
}
public Criteria andGenderLessThanOrEqualTo(String value) {
addCriterion("gender <=", value, "gender");
return (Criteria) this;
}
public Criteria andGenderLike(String value) {
addCriterion("gender like", value, "gender");
return (Criteria) this;
}
public Criteria andGenderNotLike(String value) {
addCriterion("gender not like", value, "gender");
return (Criteria) this;
}
public Criteria andGenderIn(List<String> values) {
addCriterion("gender in", values, "gender");
return (Criteria) this;
}
public Criteria andGenderNotIn(List<String> values) {
addCriterion("gender not in", values, "gender");
return (Criteria) this;
}
public Criteria andGenderBetween(String value1, String value2) {
addCriterion("gender between", value1, value2, "gender");
return (Criteria) this;
}
public Criteria andGenderNotBetween(String value1, String value2) {
addCriterion("gender not between", value1, value2, "gender");
return (Criteria) this;
}
public Criteria andDIdIsNull() {
addCriterion("d_id is null");
return (Criteria) this;
}
public Criteria andDIdIsNotNull() {
addCriterion("d_id is not null");
return (Criteria) this;
}
public Criteria andDIdEqualTo(Integer value) {
addCriterion("d_id =", value, "dId");
return (Criteria) this;
}
public Criteria andDIdNotEqualTo(Integer value) {
addCriterion("d_id <>", value, "dId");
return (Criteria) this;
}
public Criteria andDIdGreaterThan(Integer value) {
addCriterion("d_id >", value, "dId");
return (Criteria) this;
}
public Criteria andDIdGreaterThanOrEqualTo(Integer value) {
addCriterion("d_id >=", value, "dId");
return (Criteria) this;
}
public Criteria andDIdLessThan(Integer value) {
addCriterion("d_id <", value, "dId");
return (Criteria) this;
}
public Criteria andDIdLessThanOrEqualTo(Integer value) {
addCriterion("d_id <=", value, "dId");
return (Criteria) this;
}
public Criteria andDIdIn(List<Integer> values) {
addCriterion("d_id in", values, "dId");
return (Criteria) this;
}
public Criteria andDIdNotIn(List<Integer> values) {
addCriterion("d_id not in", values, "dId");
return (Criteria) this;
}
public Criteria andDIdBetween(Integer value1, Integer value2) {
addCriterion("d_id between", value1, value2, "dId");
return (Criteria) this;
}
public Criteria andDIdNotBetween(Integer value1, Integer value2) {
addCriterion("d_id not between", value1, value2, "dId");
return (Criteria) this;
}
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table tbl_employee
*
* @mbggenerated do_not_delete_during_merge Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table tbl_employee
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}package com.atguigu.mybatis.bean;
public class Employee {
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database column tbl_employee.id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
private Integer id;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database column tbl_employee.last_name
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
private String lastName;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database column tbl_employee.email
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
private String email;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database column tbl_employee.gender
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
private String gender;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database column tbl_employee.d_id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
private Integer dId;
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column tbl_employee.id
*
* @return the value of tbl_employee.id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public Integer getId() {
return id;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column tbl_employee.id
*
* @param id the value for tbl_employee.id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setId(Integer id) {
this.id = id;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column tbl_employee.last_name
*
* @return the value of tbl_employee.last_name
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public String getLastName() {
return lastName;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column tbl_employee.last_name
*
* @param lastName the value for tbl_employee.last_name
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setLastName(String lastName) {
this.lastName = lastName == null ? null : lastName.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column tbl_employee.email
*
* @return the value of tbl_employee.email
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public String getEmail() {
return email;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column tbl_employee.email
*
* @param email the value for tbl_employee.email
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setEmail(String email) {
this.email = email == null ? null : email.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column tbl_employee.gender
*
* @return the value of tbl_employee.gender
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public String getGender() {
return gender;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column tbl_employee.gender
*
* @param gender the value for tbl_employee.gender
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setGender(String gender) {
this.gender = gender == null ? null : gender.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column tbl_employee.d_id
*
* @return the value of tbl_employee.d_id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public Integer getdId() {
return dId;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column tbl_employee.d_id
*
* @param dId the value for tbl_employee.d_id
*
* @mbggenerated Sat Mar 25 13:59:48 GMT+08:00 2017
*/
public void setdId(Integer dId) {
this.dId = dId;
}
}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>
<!--
1、mybatis可以使用properties来引入外部properties配置文件的内容；
resource：引入类路径下的资源
url：引入网络路径或者磁盘路径下的资源
-->
<properties resource="dbconfig.properties"></properties>
<!--
2、settings包含很多重要的设置项
setting:用来设置每一个设置项
name：设置项名
value：设置项取值
-->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="jdbcTypeForNull" value="NULL"/>
<!--显式的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题 -->
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
<!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
别名不区分大小写
-->
<typeAliases>
<!-- 1、typeAlias:为某个java类型起别名
type:指定要起别名的类型全类名;默认别名就是类名小写；employee
alias:指定新的别名
-->
<!-- <typeAlias type="com.atguigu.mybatis.bean.Employee" alias="emp"/> -->
<!-- 2、package:为某个包下的所有类批量起别名
name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
-->
<package name="com.atguigu.mybatis.bean"/>
<!-- 3、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名 -->
</typeAliases>
<!--
4、environments：环境们，mybatis可以配置多种环境 ,default指定使用某种环境。可以达到快速切换环境。
environment：配置一个具体的环境信息；必须有两个标签；id代表当前环境的唯一标识
transactionManager：事务管理器；
type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
自定义事务管理器：实现TransactionFactory接口.type指定为全类名
dataSource：数据源;
type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
|POOLED(PooledDataSourceFactory)
|JNDI(JndiDataSourceFactory)
自定义数据源：实现DataSourceFactory接口，type是全类名
-->
<environments default="dev_mysql">
<environment id="dev_mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</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>
<!-- 5、databaseIdProvider：支持多数据库厂商的；
type="DB_VENDOR"：VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(驱动getDatabaseProductName())，mybatis就能根据数据库厂商标识来执行不同的sql;
MySQL，Oracle，SQL Server,xxxx
-->
<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）中 -->
<!-- 6、mappers：将sql映射注册到全局配置中 -->
<mappers>
<!--
mapper:注册一个sql映射
注册配置文件
resource：引用类路径下的sql映射文件
mybatis/mapper/EmployeeMapper.xml
url：引用网路路径或者磁盘路径下的sql映射文件
file:///var/mappers/AuthorMapper.xml
注册接口
class：引用（注册）接口，
1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
2、没有sql映射文件，所有的sql都是利用注解写在接口上;
推荐：
比较重要的，复杂的Dao接口我们来写sql映射文件
不重要，简单的Dao接口为了开发快速可以使用注解；
-->
<!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
<!-- <mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/> -->
<!-- 批量注册： -->
<package name="com.atguigu.mybatis.dao"/>
</mappers>
</configuration>log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="D:\44\ehcache" />
<defaultCache
maxElementsInMemory="10000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>
<!--
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
-->dbconfig.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
jdbc.username=root
jdbc.password=123456
orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456EmployeeMapper.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.atguigu.mybatis.dao.EmployeeMapper" >
<resultMap id="BaseResultMap" type="com.atguigu.mybatis.bean.Employee" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<id column="id" property="id" jdbcType="INTEGER" />
<result column="last_name" property="lastName" jdbcType="VARCHAR" />
<result column="email" property="email" jdbcType="VARCHAR" />
<result column="gender" property="gender" jdbcType="CHAR" />
<result column="d_id" property="dId" jdbcType="INTEGER" />
</resultMap>
<sql id="Example_Where_Clause" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</where>
</sql>
<sql id="Base_Column_List" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
id, last_name, email, gender, d_id
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.atguigu.mybatis.bean.EmployeeExample" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select
<if test="distinct" >
distinct
</if>
<include refid="Base_Column_List" />
from tbl_employee
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null" >
order by ${orderByClause}
</if>
</select>
<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select
<include refid="Base_Column_List" />
from tbl_employee
where id = #{id,jdbcType=INTEGER}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
delete from tbl_employee
where id = #{id,jdbcType=INTEGER}
</delete>
<delete id="deleteByExample" parameterType="com.atguigu.mybatis.bean.EmployeeExample" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
delete from tbl_employee
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insert" parameterType="com.atguigu.mybatis.bean.Employee" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
insert into tbl_employee (id, last_name, email,
gender, d_id)
values (#{id,jdbcType=INTEGER}, #{lastName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR},
#{gender,jdbcType=CHAR}, #{dId,jdbcType=INTEGER})
</insert>
<insert id="insertSelective" parameterType="com.atguigu.mybatis.bean.Employee" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
insert into tbl_employee
<trim prefix="(" suffix=")" suffixOverrides="," >
<if test="id != null" >
id,
</if>
<if test="lastName != null" >
last_name,
</if>
<if test="email != null" >
email,
</if>
<if test="gender != null" >
gender,
</if>
<if test="dId != null" >
d_id,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<if test="id != null" >
#{id,jdbcType=INTEGER},
</if>
<if test="lastName != null" >
#{lastName,jdbcType=VARCHAR},
</if>
<if test="email != null" >
#{email,jdbcType=VARCHAR},
</if>
<if test="gender != null" >
#{gender,jdbcType=CHAR},
</if>
<if test="dId != null" >
#{dId,jdbcType=INTEGER},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="com.atguigu.mybatis.bean.EmployeeExample" resultType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select count(*) from tbl_employee
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_employee
<set >
<if test="record.id != null" >
id = #{record.id,jdbcType=INTEGER},
</if>
<if test="record.lastName != null" >
last_name = #{record.lastName,jdbcType=VARCHAR},
</if>
<if test="record.email != null" >
email = #{record.email,jdbcType=VARCHAR},
</if>
<if test="record.gender != null" >
gender = #{record.gender,jdbcType=CHAR},
</if>
<if test="record.dId != null" >
d_id = #{record.dId,jdbcType=INTEGER},
</if>
</set>
<if test="_parameter != null" >
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByExample" parameterType="map" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_employee
set id = #{record.id,jdbcType=INTEGER},
last_name = #{record.lastName,jdbcType=VARCHAR},
email = #{record.email,jdbcType=VARCHAR},
gender = #{record.gender,jdbcType=CHAR},
d_id = #{record.dId,jdbcType=INTEGER}
<if test="_parameter != null" >
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByPrimaryKeySelective" parameterType="com.atguigu.mybatis.bean.Employee" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_employee
<set >
<if test="lastName != null" >
last_name = #{lastName,jdbcType=VARCHAR},
</if>
<if test="email != null" >
email = #{email,jdbcType=VARCHAR},
</if>
<if test="gender != null" >
gender = #{gender,jdbcType=CHAR},
</if>
<if test="dId != null" >
d_id = #{dId,jdbcType=INTEGER},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.atguigu.mybatis.bean.Employee" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_employee
set last_name = #{lastName,jdbcType=VARCHAR},
email = #{email,jdbcType=VARCHAR},
gender = #{gender,jdbcType=CHAR},
d_id = #{dId,jdbcType=INTEGER}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>DepartmentMapper.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.atguigu.mybatis.dao.DepartmentMapper" >
<resultMap id="BaseResultMap" type="com.atguigu.mybatis.bean.Department" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<id column="id" property="id" jdbcType="INTEGER" />
<result column="dept_name" property="deptName" jdbcType="VARCHAR" />
</resultMap>
<sql id="Example_Where_Clause" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</where>
</sql>
<sql id="Base_Column_List" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
id, dept_name
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.atguigu.mybatis.bean.DepartmentExample" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select
<if test="distinct" >
distinct
</if>
<include refid="Base_Column_List" />
from tbl_dept
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null" >
order by ${orderByClause}
</if>
</select>
<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select
<include refid="Base_Column_List" />
from tbl_dept
where id = #{id,jdbcType=INTEGER}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
delete from tbl_dept
where id = #{id,jdbcType=INTEGER}
</delete>
<delete id="deleteByExample" parameterType="com.atguigu.mybatis.bean.DepartmentExample" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
delete from tbl_dept
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insert" parameterType="com.atguigu.mybatis.bean.Department" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
insert into tbl_dept (id, dept_name)
values (#{id,jdbcType=INTEGER}, #{deptName,jdbcType=VARCHAR})
</insert>
<insert id="insertSelective" parameterType="com.atguigu.mybatis.bean.Department" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
insert into tbl_dept
<trim prefix="(" suffix=")" suffixOverrides="," >
<if test="id != null" >
id,
</if>
<if test="deptName != null" >
dept_name,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<if test="id != null" >
#{id,jdbcType=INTEGER},
</if>
<if test="deptName != null" >
#{deptName,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="com.atguigu.mybatis.bean.DepartmentExample" resultType="java.lang.Integer" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
select count(*) from tbl_dept
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_dept
<set >
<if test="record.id != null" >
id = #{record.id,jdbcType=INTEGER},
</if>
<if test="record.deptName != null" >
dept_name = #{record.deptName,jdbcType=VARCHAR},
</if>
</set>
<if test="_parameter != null" >
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByExample" parameterType="map" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_dept
set id = #{record.id,jdbcType=INTEGER},
dept_name = #{record.deptName,jdbcType=VARCHAR}
<if test="_parameter != null" >
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByPrimaryKeySelective" parameterType="com.atguigu.mybatis.bean.Department" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_dept
<set >
<if test="deptName != null" >
dept_name = #{deptName,jdbcType=VARCHAR},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.atguigu.mybatis.bean.Department" >
<!--
WARNING - @mbggenerated
This element is automatically generated by MyBatis Generator, do not modify.
This element was generated on Sat Mar 25 13:59:48 GMT+08:00 2017.
-->
update tbl_dept
set dept_name = #{deptName,jdbcType=VARCHAR}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>71.MyBatis_运行原理_框架分层架构
(网络接口层（数据链路层）&Executor框架&)
72.MyBatis_运行原理_调试前注意
73.MyBatis_运行原理_SQLSessionFactory的初始化
(DeploymentBuilder对象&)
74.MyBatis_运行原理_openSession获取SqlSession对象
( Configuration介绍&使用--no-defaults选项&Statement接口&Statement接口)
75.MyBatis_运行原理_getMapper获取到接口的代理对象
76.MyBatis_运行原理_查询实现
77.MyBatis_运行原理_查询流程总结
78.MyBatis_运行原理_MyBatis原理总结
package com.atguigu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
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 org.junit.Test;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.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(1);
System.out.println(mapper);
System.out.println(employee);
} finally {
openSession.close();
}
}
}
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
}
package com.atguigu.mybatis.bean;
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee [id=" + id + ", lastName=" + lastName + ", email="
+ email + ", gender=" + gender + "]";
}
}
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
<property name="username" value="root" />
<property name="password" value="123456" />
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
>
select id,last_name lastName,email,gender from tbl_employee where id = #{id}
</select>
</mapper>79.MyBatis_插件_插件原理
80.MyBatis_插件_插件编写&单个插件原理
81.MyBatis_插件_多个插件运行流程
82.MyBatis_插件_开发插件
package com.atguigu.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.atguigu.mybatis.bean.Employee;
import com.atguigu.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(1);
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(){
}
}
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
}
}
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);
}
}
package com.atguigu.mybatis.dao;
import com.atguigu.mybatis.bean.Employee;
public interface EmployeeMapper {
public Employee getEmpById(Integer id);
}
package com.atguigu.mybatis.bean;
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee [id=" + id + ", lastName=" + lastName + ", email="
+ email + ", gender=" + gender + "]";
}
}
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.atguigu.mybatis.dao.MyFirstPlugin">
<property name="username" value="root"/>
<property name="password" value="123456"/>
</plugin>
<plugin interceptor="com.atguigu.mybatis.dao.MySecondPlugin"></plugin>
</plugins>
<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/mybatis" />
<property name="username" value="root" />
<property name="password" value="123456" />
</dataSource>
</environment>
</environments>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<mapper resource="EmployeeMapper.xml" />
</mappers>
</configuration>log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
>
select id,last_name lastName,email,gender from tbl_employee where id = #{id}
</select>
</mapper>83.MyBatis_扩展_分页_PageHelpler分页插件使用
84.MyBatis_扩展_批量_BatchExecutor&Spring中配置批量sqlSession
85.MyBatis_扩展_存储过程_oracle中创建一个带游标的存储过程
86.MyBatis_扩展_存储过程_MyBatis调用存储过程
87.MyBatis_扩展_自定义类型处理器_MyBatis中枚举类型的默认处理
88.MyBatis_扩展_自定义类型处理器_使用自定义的类型处理器处理枚举类型
package com.atguigu.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.atguigu.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;
}
}
package com.atguigu.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.atguigu.mybatis.bean.EmpStatus;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.bean.OraclePage;
import com.atguigu.mybatis.dao.EmployeeMapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
/**
* 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 test() throws IOException {
// 2、获取sqlSession实例，能直接执行已经映射的sql语句
// sql的唯一标识：statement Unique identifier matching the statement to use.
// 执行sql要用的参数：parameter A parameter object to pass to the statement.
SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
try {
Employee employee = openSession.selectOne(
"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
System.out.println(employee);
} finally {
openSession.close();
}
}
@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(5, 1);
List<Employee> emps = mapper.getEmps();
//传入要连续显示多少页
PageInfo<Employee> info = new PageInfo<>(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();
}
}
@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 = 0; i < 10000; i++) {
mapper.addEmp(new Employee(UUID.randomUUID().toString().substring(0, 5), "b", "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();
}
}
/**
* 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();
}
}
@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("test_enum", "enum@atguigu.com","1");
//mapper.addEmp(employee);
//System.out.println("保存成功"+employee.getId());
//openSession.commit();
Employee empById = mapper.getEmpById(30026);
System.out.println(empById.getEmpStatus());
}finally{
openSession.close();
}
}
}
package com.atguigu.mybatis.dao;
import java.util.List;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.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);
}
package com.atguigu.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;
}
}
package com.atguigu.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;
}
}
}
package com.atguigu.mybatis.bean;
public class Employee {
private Integer id;
private String lastName;
private String email;
private String gender;
//员工状态
private EmpStatus empStatus=EmpStatus.LOGOUT;
public Employee(String lastName, String email, String gender) {
super();
this.lastName = lastName;
this.email = email;
this.gender = gender;
}
public Employee() {
super();
// TODO Auto-generated constructor stub
}
public EmpStatus getEmpStatus() {
return empStatus;
}
public void setEmpStatus(EmpStatus empStatus) {
this.empStatus = empStatus;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee [id=" + id + ", lastName=" + lastName + ", email="
+ email + ", gender=" + gender + "]";
}
}
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="dbconfig.properties"></properties>
<typeHandlers>
<!--1、配置我们自定义的TypeHandler -->
<typeHandler handler="com.atguigu.mybatis.typehandler.MyEnumEmpStatusTypeHandler" javaType="com.atguigu.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>
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
<environments default="dev_mysql">
<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>log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>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.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识
resultType：返回值类型
#{id}：从传递过来的参数中取出id值
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.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.atguigu.mybatis.bean.Employee">
select id,last_name lastName,email,gender from tbl_employee
</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.atguigu.mybatis.bean.Employee" id="PageEmp">
<id column="EMPLOYEE_ID" property="id"/>
<result column="LAST_NAME" property="email"/>
<result column="EMAIL" property="email"/>
</resultMap>
</mapper>dbconfig.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=123456
orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456
804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
