缓存可以提高系统性能，可以加快访问速度，减轻服务器压力，带来更好的用户体验。缓存用空间换时间，好的缓存是缓存命中率高的且数据量小的。缓存是一种非常重要的技术。
为了配置缓存的学习我们将工具类再次封装。
原sqlsessionfactoryutil工具类如下：
我要评论
package com.zhangguo.mybatis03.utils;
import org.apache.ibatis.session.sqlsession;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.session.sqlsessionfactorybuilder;
import java.io.ioexception;
import java.io.inputstream;
/**
* mybatis 会话工具类
* */
public class sqlsessionfactoryutil {
/**
* 获得会话工厂
*
* */
public static sqlsessionfactory getfactory(){
inputstream inputstream = null;
sqlsessionfactory sqlsessionfactory=null;
try{
//加载conf.xml配置文件，转换成输入流
inputstream = sqlsessionfactoryutil.class.getclassloader().getresourceasstream("mybatiscfg.xml");
//根据配置文件的输入流构造一个sql会话工厂
sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
}
finally {
if(inputstream!=null){
try {
inputstream.close();
} catch (ioexception e) {
e.printstacktrace();
}
}
}
return sqlsessionfactory;
}
/**
* 获得sql会话，是否自动提交
* */
public static sqlsession opensession(boolean isautocommit){
return getfactory().opensession(isautocommit);
}
/**
* 关闭会话
* */
public static void closesession(sqlsession session){
if(session!=null){
session.close();
}
}
}
上面的代码中当我们每次获取sqlsession时都要实例化sqlsessionfactory，效率不高。可以使用单例改进：
package com.zhangguo.mybatis03.utils;
import org.apache.ibatis.io.resources;
import org.apache.ibatis.session.sqlsession;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.session.sqlsessionfactorybuilder;
import java.io.ioexception;
import java.io.inputstream;
/**
* mybatis会话工具类
* */
public class sqlsessionfactoryutils {
/**会话工厂*/
private static sqlsessionfactory factory;
static {
try {
/*获得配置文件的文件流*/
inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
//初始化工厂
factory=new sqlsessionfactorybuilder().build(inputstream);
} catch (ioexception e) {
e.printstacktrace();
}
}
/**
* 获得会话对象
* 指定是否自动提交
* */
public static sqlsession opensqlsession(boolean isautocommit){
return getfactory().opensession(isautocommit);
}
public static sqlsessionfactory getfactory() {
return factory;
}
public static void setfactory(sqlsessionfactory factory) {
sqlsessionfactoryutils.factory = factory;
}
/**
* 关闭会话
* */
public static void closesession(sqlsession session){
if(session!=null){
session.close();
}
}
}
在一个系统中查询的频次远远高于增删改，据三方统计不同系统比例在9:1-7:3之间。正如大多数持久层框架一样，mybatis 同样提供了一级缓存和二级缓存的支持
（1）、一级缓存基于perpetualcache 的 hashmap本地缓存，其存储作用域为 session，当 session flush 或 close 之后，该session中的所有 cache 就将清空。
（2）、二级缓存与一级缓存其机制相同，默认也是采用 perpetualcache，hashmap存储，不同在于其存储作用域为 mapper(namespace)，并且可自定义存储源，如 ehcache。
（3）、对于缓存数据更新机制，当某一个作用域(一级缓存session/二级缓存namespaces)的进行了 c/u/d 操作后，默认该作用域下所有 select 中的缓存将被clear。
测试用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
student student2 = mapper1.selectstudentbyid(1);
system.out.println(student2);
//关闭
sqlsessionfactoryutils.closesession(session1);
}
结果：
虽然查询了二次，但只向数据库发送了一次sql请求，因为第二次是在缓存中获得的数据。
测试用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//打开一个会话2，不自动提交
sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper2 = session2.getmapper(studentmapper.class);
student student2 = mapper2.selectstudentbyid(1);
system.out.println(student2);
//关闭
sqlsessionfactoryutils.closesession(session1);
}
结果：
从上图可以看出此时并没有使用缓存，向数据库查询了二次，因为第二次查询使用的是新的会话，而一级缓存必须在同一个会话中。
（1）、当对表执行增删改时缓存将清空
测试用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//执行更新
student lili=new student();
lili.setid(5);
lili.setsex("girl");
mapper1.updatestudent(lili);
student student2 = mapper1.selectstudentbyid(1);
system.out.println(student2);
sqlsessionfactoryutils.closesession(session1);
}
结果：
从日志中可以看出第二次查询也发送了sql到数据库中，并没有使用缓存，是因为执行了更新操作缓存已被清空。
此时数据库中的数据其实并未真的更新，如下所示：
因为没有手动提交，可以设置自动提交
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//执行更新
student lili=new student();
lili.setid(5);
lili.setsex("girl");
mapper1.updatestudent(lili);
student student2 = mapper1.selectstudentbyid(1);
system.out.println(student2);
//提交
session1.commit();
sqlsessionfactoryutils.closesession(session1);
}
提交后的结果
（2）、手动清空
测试用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//执行手动更新
session1.clearcache();
student student2 = mapper1.selectstudentbyid(1);
system.out.println(student2);
//提交
session1.commit();
sqlsessionfactoryutils.closesession(session1);
}
结果：
从日志中可以看到第二次查询并未使用缓存因为执行了手动清空缓存，没有缓存可用则再次查询数据库。
小结：当session flush或close之后，该session中的所有 cache 就将清空；执行cud也将会自动清空；手动清空；
默认二级缓存是不开启的，需要手动进行配置：
默认是true，如果它配成false，其余各个mapper xml文件配成支持cache也没用。
<settings>
<!--设置是否允许缓存-->
<setting name="cacheenabled" value="true"/>
<!--设置日志输出的目标-->
<setting name="logimpl" value="stdout_logging"/>
</settings>
默认mapper xml映射文件是不采用cache。在配置文件加一行就可以支持cache：
<?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.zhangguo.mybatis03.dao.studentmapper">
<cache/>
<select id="selectstudentbyid" resulttype="student">
select id,name,sex from student where id=#{id}
</select>
</mapper>
可以在开启二级缓存时候，手动配置一些属性
<cache eviction="lru" flushinterval="100000" size="1024" readonly="true"/>
各个属性意义如下：
<select id="selectstudentbyid" resulttype="student" usecache="false">
select id,name,sex from student where id=#{id}
</select>
可以在mapper的具体方法下设置对二级缓存的访问意愿：
usecache配置
如果一条语句每次都需要最新的数据，就意味着每次都需要从数据库中查询数据，可以把这个属性设置为false，如：
<select id="selectall" usecache="false">
刷新缓存（就是清空缓存）
二级缓存默认会在insert、update、delete操作后刷新缓存，可以手动配置不更新缓存，如下：
<update id="updatebyid" flushcache="false" />
如果未实现可序列化接口，会引发异常。
修改pojo对象，增加实现可序列化接口：
package com.zhangguo.mybatis03.entities;
import java.io.serializable;
/**
* 学生实体
*/
public class student implements serializable {
private int id;
private string name;
private string sex;
public int getid() {
return id;
}
public void setid(int id) {
this.id = id;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
public string getsex() {
return sex;
}
public void setsex(string sex) {
this.sex = sex;
}
@override
public string tostring() {
return "student{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
<cache readonly="false"/>
当我们的配置文件配置了cacheenabled=true时，就会开启二级缓存，二级缓存是mapper级别的，也就说不同的sqlsession使用同一个mapper查询是，查询到的数据可能是另一个sqlsession做相同操作留下的缓存。
查询数据的顺序为：二级缓存 -> 一级缓存 -> 数据库
默认情况下一级缓存只在同一个会话中有效：
用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器1
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//打开一个会话2，不自动提交
sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器2
studentmapper mapper2 = session2.getmapper(studentmapper.class);
//查询单个对象通过编号
student student2 = mapper2.selectstudentbyid(1);
system.out.println(student2);
sqlsessionfactoryutils.closesession(session1);
sqlsessionfactoryutils.closesession(session2);
}
结果：
如果需要将范围扩大到同一个namespace中有效可以使用二级缓存：
用例：
/**缓存测试*/
@test
public void cachetest(){
//打开一个会话1，不自动提交
sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器1
studentmapper mapper1 = session1.getmapper(studentmapper.class);
//查询单个对象通过编号
student student1 = mapper1.selectstudentbyid(1);
system.out.println(student1);
//必须手动提交，否则无效
session1.commit();
//打开一个会话2，不自动提交
sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
//获得一个映射器2
studentmapper mapper2 = session2.getmapper(studentmapper.class);
//查询单个对象通过编号
student student2 = mapper2.selectstudentbyid(1);
system.out.println(student2);
sqlsessionfactoryutils.closesession(session1);
sqlsessionfactoryutils.closesession(session2);
}
结果：
如果不手动提交查询结果也不会缓存成功。
使用两个不同的sqlsession对象去执行相同查询条件的查询，第二次查询时不会再发送sql语句，而是直接从缓存中取出数据
1. 映射语句文件中的所有select语句将会被缓存。
2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。
3. 缓存会使用least recently used（lru，最近最少使用的）算法来收回。
4. 缓存会根据指定的时间间隔来刷新。
5. 缓存会存储1024个对象
cache标签常用属性：
<cache eviction="fifo" <!--回收策略为先进先出--> flushinterval="60000" <!--自动刷新时间60s--> size="512" <!--最多缓存512个引用对象--> readonly="true"/> <!--只读-->
这里创建了一个maven项目，未使用骨架。
在maven项目的pom.xml 添加mybatis-generator-maven-plugin 插件
<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelversion>4.0.0</modelversion>
<groupid>com.zhangguo.mybatis06</groupid>
<artifactid>mybatis06</artifactid>
<version>1.0-snapshot</version>
<dependencies>
<!--mybatis -->
<dependency>
<groupid>org.mybatis</groupid>
<artifactid>mybatis</artifactid>
<version>3.4.6</version>
</dependency>
<!--mysql数据库驱动 -->
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>5.1.38</version>
</dependency>
<!-- junit单元测试工具 -->
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- mybatis-generator-core 反向生成java代码-->
<dependency>
<groupid>org.mybatis.generator</groupid>
<artifactid>mybatis-generator-core</artifactid>
<version>1.3.5</version>
</dependency>
</dependencies>
<!--mybatis 代码生成插件-->
<build>
<finalname>mybatis06</finalname>
<plugins>
<plugin>
<groupid>org.mybatis.generator</groupid>
<artifactid>mybatis-generator-maven-plugin</artifactid>
<version>1.3.2</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
</plugins>
</build>
</project>
在maven项目下的src/main/resources 目录下建立名为 generatorconfig.xml的配置文件，作为mybatis-generator-maven-plugin 插件的执行目标：
<?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>
<!--导入属性配置 -->
<properties resource="db.properties"></properties>
<!--指定特定数据库的jdbc驱动jar包的位置 -->
<classpathentry location="${mysql.driverlocation}"/>
<context id="default" targetruntime="mybatis3">
<!-- optional，旨在创建class时，对注释进行控制 -->
<commentgenerator>
<property name="suppressdate" value="true" />
</commentgenerator>
<!--jdbc的数据库连接 -->
<jdbcconnection driverclass="${mysql.driver}" connectionurl="${mysql.url}" userid="${mysql.username}" password="${mysql.password}">
</jdbcconnection>
<!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javatyperesolver >
<property name="forcebigdecimals" value="false" />
</javatyperesolver>
<!-- model模型生成器,用来生成含有主键key的类，记录类 以及查询example类
targetpackage 指定生成的model生成所在的包名
targetproject 指定在该项目下所在的路径
-->
<javamodelgenerator targetpackage="com.zhangguo.mybatis06.entities" targetproject="src/main/java">
<!-- 是否对model添加 构造函数 -->
<property name="constructorbased" value="true"/>
<!-- 是否允许子包，即targetpackage.schemaname.tablename -->
<property name="enablesubpackages" value="false"/>
<!-- 建立的model对象是否 不可改变 即生成的model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="true"/>
<!-- 给model添加一个父类 -->
<property name="rootclass" value="com.zhangguo.mybatis06.entities.baseentity"/>
<!-- 是否对类char类型的列的数据进行trim操作 -->
<property name="trimstrings" value="true"/>
</javamodelgenerator>
<!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的sqlmap文件 -->
<sqlmapgenerator targetpackage="com.zhangguo.mybatis06.mapper" targetproject="src/main/resources">
<property name="enablesubpackages" value="false"/>
</sqlmapgenerator>
<!-- 客户端代码，生成易于使用的针对model对象和xml配置文件 的代码
type="annotatedmapper",生成java model 和基于注解的mapper对象
type="mixedmapper",生成基于注解的java model 和相应的mapper对象
type="xmlmapper",生成sqlmap xml文件和独立的mapper接口
-->
<javaclientgenerator targetpackage="com.zhangguo.mybatis06.dao" targetproject="src/main/java" type="mixedmapper">
<property name="enablesubpackages" value=""/>
<!--
定义maper.java 源代码中的byexample() 方法的可视性，可选的值有：
public;
private;
protected;
default
注意：如果 targetruntime="mybatis3",此参数被忽略
-->
<property name="examplemethodvisibility" value=""/>
<!--
方法名计数器
important note: this property is ignored if the target runtime is mybatis3.
-->
<property name="methodnamecalculator" value=""/>
<!--
为生成的接口添加父接口
-->
<property name="rootinterface" value=""/>
</javaclientgenerator>
<table tablename="student" schema="nfmall"></table>
<table tablename="category" schema="nfmall"></table>
<table tablename="goods" schema="nfmall"></table>
</context>
</generatorconfiguration>
这里的属性资源文件与mybatis共用db.propities文件
##mysql连接字符串 #驱动 mysql.driver=com.mysql.jdbc.driver #地址 mysql.url=jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&characterencoding=utf-8 #用户名 mysql.username=root #密码 mysql.password=uchr@123 #驱动位置 mysql.driverlocation=e:\\nf\\java\\jdbc\\mysql-connector-java-5.1.47\\mysql-connector-java-5.1.47.jar
参数配置文件一：
<?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>
<!-- 本地数据库驱动程序jar包的全路径 -->
<classpathentry location=""/>
<context id="context" targetruntime="mybatis3">
<commentgenerator>
<property name="suppressallcomments" value="false"/>
<property name="suppressdate" value="true"/>
</commentgenerator>
<!-- 数据库的相关配置 -->
<jdbcconnection driverclass="" connectionurl="" userid="" password=""/>
<javatyperesolver>
<property name="forcebigdecimals" value="false"/>
</javatyperesolver>
<!-- 实体类生成的位置 -->
<javamodelgenerator targetpackage="目标包" targetproject="目标项目classpath">
<property name="enablesubpackages" value="false"/>
<property name="trimstrings" value="true"/>
</javamodelgenerator>
<!-- *mapper.xml 文件的位置 -->
<sqlmapgenerator targetpackage="目标包" targetproject="目标项目classpath">
<property name="enablesubpackages" value="false"/>
</sqlmapgenerator>
<!-- mapper 接口文件的位置 -->
<javaclientgenerator targetpackage="目标包" targetproject="目标项目classpath" type="xmlmapper">
<property name="enablesubpackages" value="false"/>
</javaclientgenerator>
<!-- 相关表的配置 -->
<table tablename="表名" enablecountbyexample="false" enabledeletebyexample="false" enableselectbyexample="false"
enableupdatebyexample="false"/>
</context>
</generatorconfiguration>
参考配置文件二：
<?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>
<!--导入属性配置 -->
<properties resource="generator.properties"></properties>
<!--指定特定数据库的jdbc驱动jar包的位置 -->
<classpathentry location="${jdbc.driverlocation}"/>
<context id="default" targetruntime="mybatis3">
<!-- optional，旨在创建class时，对注释进行控制 -->
<commentgenerator>
<property name="suppressdate" value="true" />
</commentgenerator>
<!--jdbc的数据库连接 -->
<jdbcconnection driverclass="${jdbc.driverclass}" connectionurl="${jdbc.connectionurl}" userid="${jdbc.userid}" password="${jdbc.password}">
</jdbcconnection>
<!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javatyperesolver >
<property name="forcebigdecimals" value="false" />
</javatyperesolver>
<!-- model模型生成器,用来生成含有主键key的类，记录类 以及查询example类
targetpackage 指定生成的model生成所在的包名
targetproject 指定在该项目下所在的路径
-->
<javamodelgenerator targetpackage="org.louis.hometutor.po" targetproject="src/main/java">
<!-- 是否对model添加 构造函数 -->
<property name="constructorbased" value="true"/>
<!-- 是否允许子包，即targetpackage.schemaname.tablename -->
<property name="enablesubpackages" value="false"/>
<!-- 建立的model对象是否 不可改变 即生成的model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="true"/>
<!-- 给model添加一个父类 -->
<property name="rootclass" value="com.foo.louis.hello"/>
<!-- 是否对类char类型的列的数据进行trim操作 -->
<property name="trimstrings" value="true"/>
</javamodelgenerator>
<!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的sqlmap文件 -->
<sqlmapgenerator targetpackage="org.louis.hometutor.domain" targetproject="src/main/java">
<property name="enablesubpackages" value="false"/>
</sqlmapgenerator>
<!-- 客户端代码，生成易于使用的针对model对象和xml配置文件 的代码
type="annotatedmapper",生成java model 和基于注解的mapper对象
type="mixedmapper",生成基于注解的java model 和相应的mapper对象
type="xmlmapper",生成sqlmap xml文件和独立的mapper接口
-->
<javaclientgenerator targetpackage="com.foo.tourist.dao" targetproject="src/main/java" type="mixedmapper">
<property name="enablesubpackages" value=""/>
<!--
定义maper.java 源代码中的byexample() 方法的可视性，可选的值有：
public;
private;
protected;
default
注意：如果 targetruntime="mybatis3",此参数被忽略
-->
<property name="examplemethodvisibility" value=""/>
<!--
方法名计数器
important note: this property is ignored if the target runtime is mybatis3.
-->
<property name="methodnamecalculator" value=""/>
<!--
为生成的接口添加父接口
-->
<property name="rootinterface" value=""/>
</javaclientgenerator>
<table tablename="lession" schema="louis">
<!-- optional , only for mybatis3 runtime
自动生成的键值（identity,或者序列值）
如果指定此元素，mbg将会生成<selectkey>元素，然后将此元素插入到sql map的<insert> 元素之中
sqlstatement 的语句将会返回新的值
如果是一个自增主键的话，你可以使用预定义的语句,或者添加自定义的sql语句. 预定义的值如下:
cloudscape this will translate to: values identity_val_local()
db2: values identity_val_local()
db2_mf: select identity_val_local() from sysibm.sysdummy1
derby: values identity_val_local()
hsqldb: call identity()
informix: select dbinfo('sqlca.sqlerrd1') from systables where tabid=1
mysql: select last_insert_id()
sqlserver: select scope_identity()
sybase: select @@identity
jdbc: this will configure mbg to generate code for mybatis3 suport of jdbc standard generated keys.
this is a database independent method of obtaining the value from identity columns.
identity: 自增主键 if true, then the column is flagged as an identity column and the generated <selectkey>
element will be placed after the insert (for an identity column). if false, then the generated <selectkey> will be placed before
the insert (typically for a sequence).
-->
<generatedkey column="" sqlstatement="" identity="" type=""/>
<!-- optional.
列的命名规则：
mbg使用 <columnrenamingrule> 元素在计算列名的对应 名称之前，先对列名进行重命名，
作用：一般需要对busi_client_no 前的busi_进行过滤
支持正在表达式
searchstring 表示要被换掉的字符串
replacestring 则是要换成的字符串，默认情况下为空字符串，可选
-->
<columnrenamingrule searchstring="" replacestring=""/>
<!-- optional.告诉 mbg 忽略某一列
column，需要忽略的列
delimitedcolumnname:true ,匹配column的值和数据库列的名称 大小写完全匹配，false 忽略大小写匹配
是否限定表的列名，即固定表列在model中的名称
-->
<ignorecolumn column="plan_id" delimitedcolumnname="true" />
<!--optional.覆盖mbg对model 的生成规则
column: 数据库的列名
javatype: 对应的java数据类型的完全限定名
在必要的时候可以覆盖由javatyperesolver计算得到的java数据类型. for some databases, this is necessary to handle "odd"
database types (e.g. mysql's unsigned bigint type should be mapped to java.lang.object).
jdbctype:该列的jdbc数据类型(integer, decimal, numeric, varchar, etc.)，该列可以覆盖由javatyperesolver计算得到的jdbc类型，
对某些数据库而言，对于处理特定的jdbc 驱动癖好 很有必要(e.g. db2's longvarchar type should be mapped to varchar for ibatis).
typehandler:
-->
<columnoverride column="" javatype="" jdbctype="" typehandler="" delimitedcolumnname="" />
</table>
</context>
</generatorconfiguration>
属性资源文件：
jdbc.driverlocation=e:\\nf\\java\\jdbc\\mysql-connector-java-5.1.47\\mysql-connector-java-5.1.47.jar jdbc.driverclass=com.mysql.jdbc.driver jdbc.connectionurl=jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&characterencoding=utf-8 jdbc.userid=root jdbc.password=uchr@123
这里使用了外置的配置文件generator.properties，可以将一下属性配置到properties文件之中，增加配置的灵活性：
项目目录如下：
在maven projects中找到plugins->mybatis-generator->mybatis-generator:generate
点击运行，然后不出意外的话，会在控制台输出：
[info] scanning for projects... [info] [info] ------------------------------------------------------------------------ [info] building mybatis06 1.0-snapshot [info] ------------------------------------------------------------------------ [info] [info] --- mybatis-generator-maven-plugin:1.3.2:generate (default-cli) @ mybatis06 --- [info] connecting to the database [info] introspecting table nfmall.student log4j:warn no appenders could be found for logger (org.mybatis.generator.internal.db.databaseintrospector). log4j:warn please initialize the log4j system properly. log4j:warn see http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info. [info] introspecting table nfmall.category [info] introspecting table nfmall.goods [info] generating example class for table student [info] generating record class for table student [info] generating mapper interface for table student [info] generating sql map for table student [info] generating example class for table category [info] generating record class for table category [info] generating mapper interface for table category [info] generating sql map for table category [info] generating example class for table goods [info] generating record class for table goods [info] generating mapper interface for table goods [info] generating sql map for table goods [info] saving file studentmapper.xml [info] saving file categorymapper.xml [info] saving file goodsmapper.xml [info] saving file studentexample.java [info] saving file student.java [info] saving file studentmapper.java [info] saving file categoryexample.java [info] saving file category.java [info] saving file categorymapper.java [info] saving file goodsexample.java [info] saving file goods.java [info] saving file goodsmapper.java [warning] root class com.zhangguo.mybatis06.entities.baseentity cannot be loaded, checking for member overrides is disabled for this class [info] ------------------------------------------------------------------------ [info] build success [info] ------------------------------------------------------------------------ [info] total time: 1.845 s [info] finished at: 2018-10-10t09:51:45+08:00 [info] final memory: 11m/162m [info] ------------------------------------------------------------------------
看到build success，则大功告成，如果有错误的话，由于添加了-e 选项，会把具体的详细错误信息打印出来的，根据错误信息修改即可。
生成结果：
1、mybatis会话工具类
package com.zhangguo.mybatis06.utils;
import org.apache.ibatis.io.resources;
import org.apache.ibatis.session.sqlsession;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.session.sqlsessionfactorybuilder;
import java.io.ioexception;
import java.io.inputstream;
/**
* mybatis会话工具类
* */
public class sqlsessionfactoryutils {
/**会话工厂*/
private static sqlsessionfactory factory;
static {
try {
/*获得配置文件的文件流*/
inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
//初始化工厂
factory=new sqlsessionfactorybuilder().build(inputstream);
} catch (ioexception e) {
e.printstacktrace();
}
}
/**
* 获得会话对象
* 指定是否自动提交
* */
public static sqlsession opensqlsession(boolean isautocommit){
return getfactory().opensession(isautocommit);
}
public static sqlsessionfactory getfactory() {
return factory;
}
public static void setfactory(sqlsessionfactory factory) {
sqlsessionfactoryutils.factory = factory;
}
/**
* 关闭会话
* */
public static void closesession(sqlsession session){
if(session!=null){
session.close();
}
}
}
2、mybatis核心配置文件
<?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>
<!--导入db.properties文件中的所有key-value数据-->
<!--外部引入的内容将覆盖内部定义的-->
<properties resource="db.properties">
<!--定义一个名称为driver，值为com.mysql.jdbc.driver的属性-->
<property name="mysql.driver" value="com.mysql.jdbc.driver"></property>
</properties>
<settings>
<!--设置是否允许缓存-->
<setting name="cacheenabled" value="true"/>
<!--设置日志输出的目标-->
<setting name="logimpl" value="stdout_logging"/>
</settings>
<!--别名-->
<typealiases>
<!--定义单个别名，指定名称为student，对应的类型为com.zhangguo.mybatis02.entities.student-->
<!--<typealias type="com.zhangguo.mybatis02.entities.student" alias="student"></typealias>-->
<!--指定包名下所有的类被自动扫描并定义默认别名，
mybatis会自动扫描包中的pojo类，自动定义别名，别名就是类名(首字母大写或小写都可以)-->
<package name="com.zhangguo.mybatis03.entities"></package>
</typealiases>
<!--注册自定义的类型处理器-->
<typehandlers>
<!--<typehandler handler="" javatype="" jdbctype=""></typehandler>-->
</typehandlers>
<!--环境配置，default为默认选择的环境-->
<environments default="development">
<!--开发-->
<environment id="development">
<!--事务管理-->
<transactionmanager type="jdbc"/>
<!--连接池-->
<datasource type="pooled">
<!--引用属性${mysql.driver}-->
<property name="driver" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/>
</datasource>
</environment>
<!--运行-->
<environment id="work">
<transactionmanager type="jdbc"/>
<datasource type="pooled">
<property name="driver" value="${driver}"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&characterencoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="uchr@123"/>
</datasource>
</environment>
</environments>
<mappers>
<!--根据路径注册一个基于xml的映射器-->
<mapper resource="com/zhangguo/mybatis06/mapper/studentmapper.xml"/>
</mappers>
</configuration>
3、测试用例
package test;
import com.zhangguo.mybatis06.dao.studentmapper;
import com.zhangguo.mybatis06.entities.student;
import com.zhangguo.mybatis06.entities.studentexample;
import com.zhangguo.mybatis06.utils.sqlsessionfactoryutils;
import org.apache.ibatis.session.sqlsession;
import org.junit.test;
import java.util.list;
public class studenttest {
/***
* list<student> selectbyexample(studentexample example);
*/
@test
public void testselectbyexample(){
list<student> entities = null;
//打开一个会话
sqlsession session = sqlsessionfactoryutils.opensqlsession(true);
//获得一个映射器
studentmapper mapper = session.getmapper(studentmapper.class);
studentexample studentexample=new studentexample();
//查询名字中含a
studentexample.createcriteria().andnamelike("%a%");
//查询多个对象，指定参数
entities = mapper.selectbyexample(studentexample);
//关闭
sqlsessionfactoryutils.closesession(session);
}
}
测试结果：
源码地址：
mybatis-generator-gui是基于开发一款界面工具, 本工具可以使你非常容易及快速生成mybatis的java pojo文件及数据库mapping文件。
本工具由于使用了java 8的众多特性，所以要求jdk 1.8.0.60以上版本，另外jdk 1.9暂时还不支持。
你可以从本链接下载本工具:
git clone https://github.com/astarring/mybatis-generator-gui
cd mybatis-generator-gui
mvn jfx:jar
cd target/jfx/app/
java -jar mybatis-generator-gui.jar
eclipse or intellij idea中启动, 找到com.zzg.mybatis.generator.mainui类并运行就可以了
方法三：打包为本地原生应用，双击快捷方式即可启动，方便快捷
如果不想打包后的安装包logo为java的灰色的茶杯，需要在pom文件里将对应操作系统平台的图标注释放开
#<icon>${project.basedir}/package/windows/mybatis-generator-gui.ico</icon>为windows
#<icon>${project.basedir}/package/macosx/mybatis-generator-gui.icns</icon>为mac
mvn jfx:native
另外需要注意，windows系统打包成exe的话需要安装wixtoolset3+的环境；由于打包后会把jre打入安装包，两个平台均100m左右，体积较大请自行打包；打包后的安装包在target/jfx/native目录下
更多详细文档请参考本库的wiki
3.8.1、创建一个maven项目
3.8.2、下载源代码并使用idea打开
下载地址：
解压后引入到idea中
找到mainui类
3.8.3、运行程序
3.8.4、连接到数据
3.8.5、生成代码
3.8.6、使用生成的代码
pom:
<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelversion>4.0.0</modelversion>
<groupid>com.zhangguo.mybatis05</groupid>
<artifactid>mybatis05</artifactid>
<version>1.0-snapshot</version>
<dependencies>
<!--mybatis -->
<dependency>
<groupid>org.mybatis</groupid>
<artifactid>mybatis</artifactid>
<version>3.4.6</version>
</dependency>
<!--mysql数据库驱动 -->
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>5.1.38</version>
</dependency>
<!-- junit单元测试工具 -->
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
工具类：
package com.zhangguo.mybatis05.utils;
import org.apache.ibatis.io.resources;
import org.apache.ibatis.session.sqlsession;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.session.sqlsessionfactorybuilder;
import java.io.ioexception;
import java.io.inputstream;
/**
* mybatis会话工具类
* */
public class sqlsessionfactoryutils {
/**会话工厂*/
private static sqlsessionfactory factory;
static {
try {
/*获得配置文件的文件流*/
inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
//初始化工厂
factory=new sqlsessionfactorybuilder().build(inputstream);
} catch (ioexception e) {
e.printstacktrace();
}
}
/**
* 获得会话对象
* 指定是否自动提交
* */
public static sqlsession opensqlsession(boolean isautocommit){
return getfactory().opensession(isautocommit);
}
public static sqlsessionfactory getfactory() {
return factory;
}
public static void setfactory(sqlsessionfactory factory) {
sqlsessionfactoryutils.factory = factory;
}
/**
* 关闭会话
* */
public static void closesession(sqlsession session){
if(session!=null){
session.close();
}
}
}
核心配置文件：
<?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>
<!--导入db.properties文件中的所有key-value数据-->
<!--外部引入的内容将覆盖内部定义的-->
<properties resource="db.properties">
<!--定义一个名称为driver，值为com.mysql.jdbc.driver的属性-->
<property name="mysql.driver" value="com.mysql.jdbc.driver"></property>
</properties>
<settings>
<!--设置是否允许缓存-->
<setting name="cacheenabled" value="true"/
-
如对本文有疑问，
点击进行留言回复！！
ScrollView和RecyclerView的滑动事件处理
配置JAVA环境+安装Android Studio全过程+踩坑记录
Android P Camera2当SD卡被拔出来自动切换到内部存储
android 多个edittext 判空监听 让Button动态是否可点击
Android开源项目滚轮选择器WheelPicker的基本用法总结
网友评论