MyBatis的使用和SSM框架基础
来源：互联网 发布：浪迹知乎 编辑：程序博客网 时间：2024/05/24 06:10
1. MyBatis与Hibernate
1.1 Hibernate 简介
Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。1.2 MyBatis简介
MyBatis的着力点，则在于POJO 与SQL之间的映射关系。然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。 相对Hibernate“O/R”而言，MyBatis是一种“Sql Mapping”的ORM实现。1.3 MyBatis与Hibernate之间的区别
1.3.1 两者相同点
Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。Hibernate和MyBatis都支持JDBC和JTA事务处理。
1.3.2 Mybatis优势
MyBatis可以进行更为细致的SQL优化，可以减少查询字段。MyBatis容易掌握，而Hibernate门槛较高。
1.3.3 Hibernate优势
Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。
1.3.4 他人总结
Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。
MyBatis入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。
MyBatis的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。
2. MyBatis实现CRUD
MyBatis实现CRUD有配置文件和注解两种方式。
2.1 Mapping配置文件实现CRUD
1、定义sql映射xml文件
userMapper.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，namespace的值习惯上设置成包名+sql映射文件名，这样就能够保证namespace的值是唯一的例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀) --><mapper namespace="me.gacl.mapping.userMapper"> <!-- 在select标签中编写查询的SQL语句， 设置select标签的id属性为getUser，id属性值必须是唯一的，不能够重复 使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型 resultType="me.gacl.domain.User"就表示将查询结果封装成一个User类的对象返回 User类就是users表所对应的实体类 --> <!-- 根据id查询得到一个user对象 --> <select id="getUser" parameterType="int" resultType="me.gacl.domain.User"> select * from users where id=#{id} </select> <!-- 创建用户(Create) --> <insert id="addUser" parameterType="me.gacl.domain.User"> insert into users(name,age) values(#{name},#{age}) </insert> <!-- 删除用户(Remove) --> <delete id="deleteUser" parameterType="int"> delete from users where id=#{id} </delete> <!-- 修改用户(Update) --> <update id="updateUser" parameterType="me.gacl.domain.User"> update users set name=#{name},age=#{age} where id=#{id} </update> <!-- 查询全部用户--> <select id="getAllUsers" resultType="me.gacl.domain.User"> select * from users </select> </mapper>2. 定义pojo类作为实体
User类的内容如下：
package me.gacl.domain;/** * @author gacl * users表所对应的实体类 */public class User { //实体类的属性和表的字段名称一一对应 private int id; private String name; private int age; 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 int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", age=" + age + "]"; }}3. 定义conf.xml配置映射文件
conf.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="XDP" /> </dataSource> </environment> </environments> </configuration>
4. 测试类调用方法
package me.gacl.test;import java.util.List;import me.gacl.domain.User;import me.gacl.util.MyBatisUtil;import org.apache.ibatis.session.SqlSession;import org.junit.Test;public class TestCRUDByXmlMapper { @Test public void testAdd(){ //SqlSession sqlSession = MyBatisUtil.getSqlSession(false); SqlSession sqlSession = MyBatisUtil.getSqlSession(true); /** * 映射sql的标识字符串， * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值， * addUser是insert标签的id属性值，通过insert标签的id属性值就可以找到要执行的SQL */ String statement = "me.gacl.mapping.userMapper.addUser";//映射sql的标识字符串 User user = new User(); user.setName("用户孤傲苍狼"); user.setAge(20); //执行插入操作 int retResult = sqlSession.insert(statement,user); //手动提交事务 //sqlSession.commit(); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(retResult); } @Test public void testUpdate(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(true); /** * 映射sql的标识字符串， * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值， * updateUser是update标签的id属性值，通过update标签的id属性值就可以找到要执行的SQL */ String statement = "me.gacl.mapping.userMapper.updateUser";//映射sql的标识字符串 User user = new User(); user.setId(3); user.setName("孤傲苍狼"); user.setAge(25); //执行修改操作 int retResult = sqlSession.update(statement,user); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(retResult); } @Test public void testDelete(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(true); /** * 映射sql的标识字符串， * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值， * deleteUser是delete标签的id属性值，通过delete标签的id属性值就可以找到要执行的SQL */ String statement = "me.gacl.mapping.userMapper.deleteUser";//映射sql的标识字符串 //执行删除操作 int retResult = sqlSession.delete(statement,5); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(retResult); } @Test public void testGetAll(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(); /** * 映射sql的标识字符串， * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值， * getAllUsers是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL */ String statement = "me.gacl.mapping.userMapper.getAllUsers";//映射sql的标识字符串 //执行查询操作，将查询结果自动封装成List<User>返回 List<User> lstUsers = sqlSession.selectList(statement); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(lstUsers); }}用来获取Session的工具类如下：
package me.gacl.util;import java.io.InputStream;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;public class MyBatisUtil { /** * 获取SqlSessionFactory * @return SqlSessionFactory */ public static SqlSessionFactory getSqlSessionFactory() { String resource = "conf.xml"; InputStream is = MyBatisUtil.class.getClassLoader().getResourceAsStream(resource); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is); return factory; } /** * 获取SqlSession * @return SqlSession */ public static SqlSession getSqlSession() { return getSqlSessionFactory().openSession(); } /** * 获取SqlSession * @param isAutoCommit * true 表示创建的SqlSession对象在执行完SQL之后会自动提交事务 * false 表示创建的SqlSession对象在执行完SQL之后不会自动提交事务，这时就需要我们手动调用sqlSession.commit()提交事务 * @return SqlSession */ public static SqlSession getSqlSession(boolean isAutoCommit) { return getSqlSessionFactory().openSession(isAutoCommit); }}就此实现了基于配置文件方式的CRUD操作。
2.2 注解方式实现CRUD
1. 定义sql映射的接口
UserMapperI接口的代码如下：
package me.gacl.mapping;import java.util.List;import me.gacl.domain.User;import org.apache.ibatis.annotations.Delete;import org.apache.ibatis.annotations.Insert;import org.apache.ibatis.annotations.Select;import org.apache.ibatis.annotations.Update;/** * @author gacl * 定义sql映射的接口，使用注解指明方法要执行的SQL */public interface UserMapperI { //使用@Insert注解指明add方法要执行的SQL @Insert("insert into users(name, age) values(#{name}, #{age})") public int add(User user); //使用@Delete注解指明deleteById方法要执行的SQL @Delete("delete from users where id=#{id}") public int deleteById(int id); //使用@Update注解指明update方法要执行的SQL @Update("update users set name=#{name},age=#{age} where id=#{id}") public int update(User user); //使用@Select注解指明getById方法要执行的SQL @Select("select * from users where id=#{id}") public User getById(int id); //使用@Select注解指明getAll方法要执行的SQL @Select("select * from users") public List<User> getAll();}需要说明的是，我们不需要针对UserMapperI接口去编写具体的实现类代码，这个具体的实现类由MyBatis帮我们动态构建出来，我们只需要直接拿来使用即可。
2. 在conf.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="XDP" /> </dataSource> </environment> </environments> <mappers> <!-- 注册userMapper.xml文件， userMapper.xml位于me.gacl.mapping这个包下，所以resource写成me/gacl/mapping/userMapper.xml--> <mapper resource="me/gacl/mapping/userMapper.xml"/> <!-- 注册UserMapper映射接口--> <mapper class="me.gacl.mapping.UserMapperI"/> </mappers> </configuration>
3. 测试类调用方法
package me.gacl.test;import java.util.List;import me.gacl.domain.User;import me.gacl.mapping.UserMapperI;import me.gacl.util.MyBatisUtil;import org.apache.ibatis.session.SqlSession;import org.junit.Test;public class TestCRUDByAnnotationMapper { @Test public void testAdd(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(true); //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来 UserMapperI mapper = sqlSession.getMapper(UserMapperI.class); User user = new User(); user.setName("用户xdp"); user.setAge(20); int add = mapper.add(user); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(add); } @Test public void testUpdate(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(true); //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来 UserMapperI mapper = sqlSession.getMapper(UserMapperI.class); User user = new User(); user.setId(3); user.setName("孤傲苍狼_xdp"); user.setAge(26); //执行修改操作 int retResult = mapper.update(user); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(retResult); } @Test public void testDelete(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(true); //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来 UserMapperI mapper = sqlSession.getMapper(UserMapperI.class); //执行删除操作 int retResult = mapper.deleteById(7); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(retResult); } @Test public void testGetUser(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(); //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来 UserMapperI mapper = sqlSession.getMapper(UserMapperI.class); //执行查询操作，将查询结果自动封装成User返回 User user = mapper.getById(8); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(user); } @Test public void testGetAll(){ SqlSession sqlSession = MyBatisUtil.getSqlSession(); //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来 UserMapperI mapper = sqlSession.getMapper(UserMapperI.class); //执行查询操作，将查询结果自动封装成List<User>返回 List<User> lstUsers = mapper.getAll(); //使用SqlSession执行完SQL之后需要关闭SqlSession sqlSession.close(); System.out.println(lstUsers); }}3. MyBatis使用问题
3.1 属性名不一致
当实体类中的属性名和表中的字段名不一致时，使用MyBatis进行查询操作时无法查询出相应的结果的问题以及针对问题采用的两种办法：
解决办法一: 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致，这样就可以表的字段名和实体类的属性名一一对应上了，这种方式是通过在sql语句中定义别名来解决字段名和属性名的映射关系的。
解决办法二: 通过<resultMap>来映射字段名和实体类属性名的一一对应关系。这种方式是使用MyBatis提供的解决方式来解决字段名和属性名的映射关系的。
<!-- 根据id查询得到一个order对象，使用这个查询是可以正常查询到我们想要的结果的， 这是因为我们通过<resultMap>映射实体类属性名和表的字段名一一对应关系 --> <select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap"> select * from orders where order_id=#{id} </select> <!--通过<resultMap>映射实体类属性名和表的字段名对应关系 --> <resultMap type="me.gacl.domain.Order" id="orderResultMap"> <!-- 用id属性来映射主键字段 --> <id property="id" column="order_id"/> <!-- 用result属性来映射非主键字段 --> <result property="orderNo" column="order_no"/> <result property="price" column="order_price"/> </resultMap>3.2 关联查询
3.2.1 一对一关联
一对一关联查询可以采用嵌套结果和嵌套查询两种方式，嵌套结果基于SQL语句的方式，嵌套查询是MyBatis提供的方式。
<!-- 方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集 封装联表查询的数据(去除重复的数据) select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1 --> <select id="getClass" parameterType="int" resultMap="ClassResultMap"> select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id} </select> <!-- 使用resultMap映射实体类和字段之间的一一对应关系 --> <resultMap type="me.gacl.domain.Classes" id="ClassResultMap"> <id property="id" column="c_id"/> <result property="name" column="c_name"/> <association property="teacher" javaType="me.gacl.domain.Teacher"> <id property="id" column="t_id"/> <result property="name" column="t_name"/> </association> </resultMap> <!-- 方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型 SELECT * FROM class WHERE c_id=1; SELECT * FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id的值 --> <select id="getClass2" parameterType="int" resultMap="ClassResultMap2"> select * from class where c_id=#{id} </select> <!-- 使用resultMap映射实体类和字段之间的一一对应关系 --> <resultMap type="me.gacl.domain.Classes" id="ClassResultMap2"> <id property="id" column="c_id"/> <result property="name" column="c_name"/> <association property="teacher" column="teacher_id" select="getTeacher"/> </resultMap> <select id="getTeacher" parameterType="int" resultType="me.gacl.domain.Teacher"> SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id} </select><resultmap>用于对映射进行一一对应，当使用嵌套结果时需要使用<association>标签指明内层结果的对应关系，嵌套查询使用<association>标签定义，其中“select”项为嵌套的查询操作。
3.2.2 一对多关联
MyBatis中使用association标签来解决一对一的关联查询，association标签可用的属性如下：
- property:对象属性的名称
- javaType:对象属性的类型
- column:所对应的外键字段名称
- select:使用另一个查询封装的结果
<!-- 方式一: 嵌套结果: 使用嵌套结果映射来处理重复的联合结果的子集 SELECT * FROM class c, teacher t,student s WHERE c.teacher_id=t.t_id AND c.C_id=s.class_id AND c.c_id=1 --> <select id="getClass3" parameterType="int" resultMap="ClassResultMap3"> select * from class c, teacher t,student s where c.teacher_id=t.t_id and c.C_id=s.class_id and c.c_id=#{id} </select> <resultMap type="me.gacl.domain.Classes" id="ClassResultMap3"> <id property="id" column="c_id"/> <result property="name" column="c_name"/> <association property="teacher" column="teacher_id" javaType="me.gacl.domain.Teacher"> <id property="id" column="t_id"/> <result property="name" column="t_name"/> </association> <!-- ofType指定students集合中的对象类型 --> <collection property="students" ofType="me.gacl.domain.Student"> <id property="id" column="s_id"/> <result property="name" column="s_name"/> </collection> </resultMap> <!-- 方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型 SELECT * FROM class WHERE c_id=1; SELECT * FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id的值 SELECT * FROM student WHERE class_id=1 //1是第一个查询得到的c_id字段的值 --> <select id="getClass4" parameterType="int" resultMap="ClassResultMap4"> select * from class where c_id=#{id} </select> <resultMap type="me.gacl.domain.Classes" id="ClassResultMap4"> <id property="id" column="c_id"/> <result property="name" column="c_name"/> <association property="teacher" column="teacher_id" javaType="me.gacl.domain.Teacher" select="getTeacher2"></association> <collection property="students" ofType="me.gacl.domain.Student" column="c_id" select="getStudent"></collection> </resultMap>MyBatis中使用collection标签来解决一对多的关联查询，ofType属性指定集合中元素的对象类型。
4. MyBatis缓存介绍
正如大多数持久层框架一样，MyBatis 同样提供了一级缓存和二级缓存的支持
一级缓存: 基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。
二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。
对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。
4.1 一级缓存
第一次发出一个查询sql，sql查询结果写入sqlsession的一级缓存中，缓存使用的数据结构是一个map<key,value>。
key：hashcode+sql+sql输入参数+输出参数（sql的唯一标识）
value：用户信息
同一个sqlsession再次发出相同的sql，就从缓存中取,而不走数据库。如果两次中间出现commit操作（修改、添加、删除），本sqlsession中的一级缓存区域全部清空，下次再去缓存中查询不到所以要从数据库查询，从数据库查询到再写入缓存。即对于查询操作，每次查询都先从缓存中查询，如果缓存中查询到数据则将缓存数据直接返回，如果缓存中查询不到就从数据库查询。
mybatis默认支持一级缓存不需要配置。
package me.gacl.test;import me.gacl.domain.User;import me.gacl.util.MyBatisUtil;import org.apache.ibatis.session.SqlSession;import org.junit.Test;/** * @author gacl * 测试一级缓存 */public class TestOneLevelCache { /* * 一级缓存: 也就Session级的缓存(默认开启) */ @Test public void testCache1() { SqlSession session = MyBatisUtil.getSqlSession(); String statement = "me.gacl.mapping.userMapper.getUser"; User user = session.selectOne(statement, 1); System.out.println(user); /* * 一级缓存默认就会被使用 */ user = session.selectOne(statement, 1); System.out.println(user); session.close(); /* 1. 必须是同一个Session,如果session对象已经close()过了就不可能用了 */ session = MyBatisUtil.getSqlSession(); user = session.selectOne(statement, 1); System.out.println(user); /* 2. 查询条件是一样的 */ user = session.selectOne(statement, 2); System.out.println(user); /* 3. 没有执行过session.clearCache()清理缓存 */ //session.clearCache(); user = session.selectOne(statement, 2); System.out.println(user); /* 4. 没有执行过增删改的操作(这些操作都会清理缓存) */ session.update("me.gacl.mapping.userMapper.updateUser", new User(2, "user", 23)); user = session.selectOne(statement, 2); System.out.println(user); }}注意:mybatis和spring整合后进行mapper代理开发，不支持一级缓存，mybatis和spring整合，spring按照mapper的模板去生成mapper代理对象，模板中在最后统一关闭sqlsession。
4.2 二级缓存原理
二级缓存的范围是mapper级别（mapper同一个命名空间），mapper以命名空间为单位创建缓存数据结构，结构是map<key、value>。
过程:每次查询先看是否开启二级缓存，如果开启从二级缓存的数据结构中取缓存数据，如果从二级缓存没有取到，再从一级缓存中找，如果一级缓存也没有，从数据库查询。
不像一级缓存那样mybatis自动开启一级缓存，mybatis是默认关闭二级缓存的，所以我们需要需要进行两个操作才能开启二级缓存:
1. 在核心配置文件SqlMapperConfig.xml中加入：
<mapper namespace="me.gacl.mapping.userMapper"><!-- 开启二级缓存 --><cache/>属性值cacheEnabled表示对在此配置文件下的所有cache 进行全局性开/关设置，它的可选值为true｜false,默认值为true.
2.在你的Mapper映射文件中添加一行:<cache /> ，表示此mapper开启二级缓存。
package me.gacl.test;import me.gacl.domain.User;import me.gacl.util.MyBatisUtil;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.junit.Test;/** * @author gacl * 测试二级缓存 */public class TestTwoLevelCache { /* * 测试二级缓存 * 使用两个不同的SqlSession对象去执行相同查询条件的查询，第二次查询时不会再发送SQL语句，而是直接从缓存中取出数据 */ @Test public void testCache2() { String statement = "me.gacl.mapping.userMapper.getUser"; SqlSessionFactory factory = MyBatisUtil.getSqlSessionFactory(); //开启两个不同的SqlSession SqlSession session1 = factory.openSession(); SqlSession session2 = factory.openSession(); //使用二级缓存时，User类必须实现一个Serializable接口===> User implements Serializable User user = session1.selectOne(statement, 1); session1.commit();//不懂为啥，这个地方一定要提交事务之后二级缓存才会起作用 System.out.println("user="+user); //由于使用的是两个不同的SqlSession对象，所以即使查询条件相同，一级缓存也不会开启使用 user = session2.selectOne(statement, 1); //session2.commit(); System.out.println("user2="+user); }}5. Spring+MyBatis+ehcache整合
分布式管理缓存数据有助于提升查询性能，可以把缓存数据的管理托管给分布式缓存框架。MyBatis自己的二级缓存，它在自己内部提供了一个cache接口，我们只要实现了cache接口就可以把缓存数据灵活的管理起来。步骤可以分为如下的四步。
1. spring加载ehcache配置文件
<!-- 使用ehcache缓存 --> <bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation" value="classpath:ehcache.xml" /> </bean>
2. 配置ehcache.xml配置文件
<?xml version="1.0" encoding="UTF-8"?> <ehcache> <!-- maxElementsInMemory：缓存中最大允许创建的对象数 maxInMemory：设定内存中创建对象的最大值。 eternal：设置元素（译注：内存中对象）是否永久驻留。如果是，将忽略超时限制且元素永不消亡。 timeToIdleSeconds：设置某个元素消亡前的停顿时间。 timeToLiveSeconds：为元素设置消亡前的生存时间. overflowToDisk：设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘上。 memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。 diskPersistent：重启时内存不持久化到硬盘。 --> <diskStore path="java.io.tmpdir"/> <defaultCache maxElementsInMemory="10000" memoryStoreEvictionPolicy="LRU" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="300" overflowToDisk="false" diskPersistent="false" /> <cache name="districtDataCache" maxElementsInMemory="4000" eternal="true" overflowToDisk="false" diskPersistent="false" memoryStoreEvictionPolicy="LRU"/> </ehcache>
diskStore：指定数据在磁盘中的存储位置。
defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
maxElementsInMemory - 在内存中缓存的element的最大数目
maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
在对应的mapper.xml里面加上：
<cache readOnly="true"> <property name="timeToIdleSeconds" value="3600"/><!--1 hour--> <property name="timeToLiveSeconds" value="3600"/><!--1 hour--> <property name="maxEntriesLocalHeap" value="1000"/> <property name="maxEntriesLocalDisk" value="10000000"/> <property name="memoryStoreEvictionPolicy" value="LRU"/> </cache>（1）property参数配置不加也可以，都会有一个默认值，大家也可以查查一共有哪些配置，然后根据自己的需要来配置，然后这个配置是会带上cache执行的日志，如果不要带日志可以把LogginEhcache改成EhcacheCache。
（2）如果readOnly为false，此时要结果集对象必须是可序列化的。需要将实体对象implements Serializable
4：useCache开关
在mapper.xml这样设置了默认是全部操作都会执行缓存策略，如果有某些sql不需要执行，可以把useCache设置为false。
<select id="selectUser" resultMap="BaseResultMap" parameterType="XX.XX.XX.XX.User" useCache="false" >
局限性：
mybatis二级缓存对细粒度的数据级别的缓存实现不好，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存。
6. MyBatis Generator的使用
MyBatis Generator是MyBatis提供的逆向工具，可自动通过数据表生成pojo类、Mapping和Dao接口。
在Eclipse中可以使用MyBatis Generator插件完成，或者使用命令行生成（差距不大），核心在于配置文件和依赖jar包。
generatorConfig.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> <!--数据库驱动--> <classPathEntry location="mysql-connector-java-5.0.8-bin.jar"/><!--和当前配置文件处在同一文件夹--> <context id="DB2Tables" targetRuntime="MyBatis3"> <commentGenerator> <property name="suppressDate" value="true"/><!-- 是否生成注释代时间戳 --> <property name="suppressAllComments" value="true"/><!-- 是否取消注释 --> </commentGenerator> <!--数据库链接地址账号密码--> <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost/ironblog" userId="root" password="password"> </jdbcConnection> <!--生成Model类存放位置--> <javaModelGenerator targetPackage="com.zenhobby.pojo" targetProject="Ironblog\src\main\java"> <property name="enableSubPackages" value="true"/> <property name="trimStrings" value="true"/> </javaModelGenerator> <!--生成映射文件存放位置--> <sqlMapGenerator targetPackage="com.zenhobby.mapping" targetProject="Ironblog\src\main\java"> <property name="enableSubPackages" value="true"/> </sqlMapGenerator> <!--生成Dao类存放位置--> <javaClientGenerator type="XMLMAPPER" targetPackage="com.zenhobby.dao" targetProject="Ironblog\src\main\java"> <property name="enableSubPackages" value="true"/> </javaClientGenerator> <!--生成对应表及类名--> <table tableName="article" domainObjectName="Article" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table><!-- domainObjectName配置生成的pojo的类型 --> </context></generatorConfiguration>按照此配置需要把数据库连接jar包、mybatis generator包和mybatis驱动包放置在相同路径下，使用如下命令生成：
java -jar mybatis-generator-core-1.3.2.jar -configfile generatorConfig.xml -overwrite
阅读全文
0 0
- MyBatis的使用和SSM框架基础
- SSM基础框架的搭建和测试
- 基于ssm框架的mybatis pagehelper分页插件的使用
- 【SSM-SpringMVC框架】SpringMVC和MyBatis的整合
- ssm框架学习---mybatis和spring的整合
- SSM框架之SpringMVC(1)--Mybatis和SpringMVC的整合
- SSM框架的使用
- SSM(Spring + SpringMVC + MyBatis)框架使用
- 搭建SSM框架，使用MyBatis Generator
- 使用Spring、SpringMvc、MyBatis搭建SSM框架
- 使用Spring、SpringMvc、MyBatis搭建SSM框架
- 使用Spring、SpringMvc、MyBatis搭建SSM框架
- 【Mybatis】使用SSM框架完成jsTree
- SSM框架整合（ Spring 、 SpringMVC 和 Mybatis )
- ssm框架学习---springmvc和mybatis整合
- SSM框架整合（ Spring 、 SpringMVC 和 Mybatis )
- SSM框架整合（ Spring 、 SpringMVC 和 Mybatis )
- SSM框架整合和mybatis generator应用
- Jenkens配置Git遇到的问题
- 创建线程的三种方式
- 基于HBase的云盘项目复制功能总结
- 1020. Tree Traversals (25)
- 资料记录
- MyBatis的使用和SSM框架基础
- [Azure]ARM模式托管磁盘的快照与还原[2]——删除与恢复
- iOS开发 AudioServices(音效播放)的使用
- 最全面的Java多线程用法解析
- 如何禁止 网页的复制功能
- 基于nginx和redis架构的高并发框架的设计与研究
- Linux 常用命令
- Android初级开发（六）——1、SharedPreferences数据存储
- oracle 学习笔记
