mybatis
1.mybatis环境搭建
-
在dao和domain包下分别创建UserDao接口和User类(以User为例)
-
在UserDao中定义一个
List<User> findAll();
方法若采用注解的方式,则需要在方法上加
@Select(select * from user)
注解(括号内写具体的sql语句) -
在resources目录下创建
SqlMapConfig.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="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<!--配置连接数据库的四大参数-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///zzx"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--配置UserDao配置文件的映射(包结构必须与dao接口的包结构一致)
如果使用注解,则此处的resource属性需替换为class属性指定UserDao的全限定类名
<mapper class="com.zzx.dao.UserDao"/>-->
<mapper resource="com/zzx/dao/UserDao.xml"/>
</mappers>
</configuration>
- 在resources目录下创建UserDao的配置文件UserDao.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">
<!--此处的namespace必须是UserDao接口的全限定类名-->
<mapper namespace="com.zzx.dao.UserDao">
<!--此处的id值为dao中定义的方法的名称,resultType为查询返回结果集的JavaBean类型-->
<select id="findAll" resultType="com.zzx.domain.User">
SELECT * FROM user
</select>
</mapper>
- 测试代码
//读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory build = builder.build(in);
//使用SqlSessionFactory生成sqlSession对象
SqlSession sqlSession = build.openSession();
//使用SqlSessionFactory创建Dao接口的代理对象
UserDao userDao = sqlSession.getMapper(UserDao.class);
//使用代理对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
//释放资源,非常重要!!!
sqlSession.close();
in.close();
1.1.也可以采用dao实现类的方式来搭建环境
1.1.1.USerDaoImpl
public class UserDaoImpl implements UserDao {
private SqlSessionFactory factory;
//定义构造方法规定创建对象时需要传递factory对象,将factory传递给成员变量factory
public UserDaoImpl(SqlSessionFactory factory){
this.factory = factory;
}
public List<User> findAll(){
//使用工厂创建session对象
SqlSession session = factory.openSession();
//使用session执行查询所有方法
//此处selectList()方法所需要的参数是原来UserDao.xml配置文件中的namespace值加上方法名
List<User> users = session.selectList("com.zzx.dao.UserDao.findAll");
session.close();
//返回结果
return users;
}
}
1.1.2.功能实现
//读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);
//使用SqlSessionFactory生成sqlSession对象
//SqlSession sqlSession = build.openSession();
//使用SqlSessionFactory创建Dao接口的代理对象,此处无需创建Dao的代理对象了,因为采用Dao实现类的方式来实现功能
//UserDao userDao = sqlSession.getMapper(UserDao.class);
//创建实现类对象时需传入工厂对象
UserDao userDao = new UserDaoImpl(factory);
//使用实现类对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
//释放资源
//sqlSession.close();
in.close();
2.mybatis的增删改查
2.1.增
-
在dao接口中新增方法
void saveUser(User user);
-
在UserDao.xml中新增Insert配置
<insert id="saveUser" parameterType="com.zzx.domain.User">
<!--新增用户时,由于id是数据库自动增长实现的,因此并没有向user对象中封装id信息,可以通过以下sql语句来查询新增用户的id值,其中:
keyProperty是实体类(User)中的id名称
keyColumn是对应数据库中的列名
resultType是返回的结果集的类型
order是指定在查询用户之前或者之后执行该查询id的语句-->
<selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID();
</selectKey>
<!--此处sql语句中#{}中的内容必须与domian中User类中get方法名一致,无需与字段名一致-->
INSERT INTO user(username,birthday,sex,address) values (#{username},#{birthday},#{sex},#{address})
</insert>
- 调用
saveUser()
方法
User user = new User();
user.setUsername("小张");
user.setBirthday(new Date());
user.setSex("帅哥");
user.setAddress("上园头村草");
//保存操作之前id值为null
System.out.println(user.getId());
//将user对象作为参数传递给saveUser()
userDao.saveUser(user);
//保存操作之后查询得到结果id值为52
System.out.println(user.getId());
2.2.删
-
在dao接口中新增方法
void deleteUser(Integer id);
-
在UserDao.xml中新增delete配置
<!--此处的parameterType还可以使用Int,java.lang.Integer-->
<delete id="deleteUser" parameterType="Integer">
<!--当方法只有一个参数时,此处#{}的内容其实是没有任何要求的,它仅仅表示一个占位符-->
DELETE FROM user WHERE id=#{id}
</delete>
- 调用
deleteUser()
方法
userDao.deleteUser(51);
2.3.改
-
在dao接口中新增方法
void updateUser(User user);
-
在UserDao.xml中新增update配置
<update id="updateUser" parameterType="com.zzx.domain.User">
UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} WHERE id=#{id}
</update>
- 调用
updateUser()
方法
User user = new User();
//由于sql语句中写的是根据id更新User信息,因此此处需要给User对象设置Id属性
user.setId(51);
user.setUsername("小张");
user.setBirthday(new Date());
user.setSex("帅哥");
user.setAddress("上园头村草");
userDao.updateUser(user);
2.4.查
2.4.1.根据id查询
-
在dao接口中新增方法
User findById(Integer id);
-
在UserDao.xml中新增select配置
<!--此处需要设置参数的值parameterType和返回值的全限定类名resultType-->
<select id="findById" parameterType="Integer" resultType="com.zzx.domain.User">
SELECT * FROM user WHERE id=#{id}
</select>
- 调用
findById()
方法
User user = userDao.findById(45);
System.out.println(user);
2.4.2.根据名字模糊查询
-
在dao接口中新增方法
List<User> findByName(String name);
-
在UserDao.xml中新增select配置
<select id="findByName" parameterType="java.lang.String" resultType="com.zzx.domain.User">
<!--此处的sql语句有两种写法,另一种写法则是在sql语句中直接添加%符号,而不需要在调用方法时候在关键字前后添加%,注意:此处的{}前是$而不是#!!!但是一般还是采用不加%的-->
<!--SELECT * FROM user WHERE username LIKE '%${value}%'-->
SELECT * FROM user WHERE username LIKE #{name}
</select>
- 调用
findByName()
方法
List<User> users = userDao.findByName("%王%");
for (User user : users) {
System.out.println(user);
}
3.实体类的字段名称和数据库中的列名不一致时的解决方案
-
增删改操作:只需要将sql语句中#{}内的值改成与实体类中的字段一致
-
查询操作:由于实体类中字段名与数据库中列名不一致,因此数据无法全部封装,只有userName可以被封装进结果集,原因是在windows系统下,mysql数据库不区分大小写
实体类User.class
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
3.1.两种解决查询操作的方案
- 在编写sql语句时加上别名,使其与实体类中的字段名称一致
此方法的执行效率较高,但是修改所有的查询语句,比较麻烦
<select id="findAll" resultType="com.zzx.domain.User">
SELECT id as userId, username as userName, address as userAddress, sex as userSex, birthday as userBirthday FROM user
</select>
- 在UserDao.xml中**(mapper标签内)**新增一个查询结果的列名和实体类的属性名的对应关系
由于要多解析一段xml标签,所以此方法的效率会较第一种方法低,但是只需将select标签中的resultType属性修改为resultMap属性,比较方便
<resultMap id="userMap" type="com.zzx.domain.User">
<!--主键字段的对应-->
<id property="userId" column="id"></id>
<!--非主键字段的对应-->
<result property="userName" column="username"></result>
<result property="userBirthday" column="birthday"></result>
<result property="userSex" column="sex"></result>
<result property="userAddress" column="address"></result>
</resultMap>
<!--将此处select标签内的resultType属性替换为resultMap属性,值为userMap,即与上面定义的resultMap的id一致-->
<!--resultType="com.zzx.domain.User"-->
<select id="findAll" resultMap="userMap">
SELECT * FROM user
</select>
4.properties标签的使用
可以在dataSource标签外定义properties标签来设置连接数据库的四大参数,在property中引用即可
<?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>
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///zzx"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</properties>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<!--此处property的value用${}替换-->
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/zzx/dao/UserDao.xml"/>
</mappers>
</configuration>
引用外部配置文件,将jdbcConfig.properties文件放在resources根目录下
<?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="jdbcConfig.properties">
<!--<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///zzx"/>
<property name="username" value="root"/>
<property name="password" value="123"/>-->
</properties>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<!--此处property中${}内的值必须与配置文件中的键一致-->
<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>
</environments>
<mappers>
<mapper resource="com/zzx/dao/UserDao.xml"/>
</mappers>
</configuration>
5.typeAliases标签和package标签的使用
<typeAliases>
<!--typeAlias用于配置别名。type属性指定的是实体类全限定类名。alias属性指定别名,当指定了别名就不再区分大小写
<typeAlias type="com.zzx.domain.User" alias="user"></typeAlias>-->
<!-- 用于指定要配置别名的包,当指定之后,该包下的实体类都会注册别名,并且类名就是别名,不再区分大小写-->
<package name="com.zzx.domain"></package>
</typeAliases>
在SqlMapConfig.xml中添加该包扫描配置后,增删改查标签内的parameterType只需要写类名**(User)**即可
也可以在mappers标签内配置扫描dao接口的包,这样则无需再一个一个的配置dao接口了
<mappers>
<package name="com.zzx.dao"/>
</mappers>
6.mybatis中的事务
6.1.什么是事务
事务中的多个操作,要么完全成功,要么完全失败!不可能存在成功一半的情况!
6.2.事务的四大特性ACID
-
原子性(Atomicity):事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功,要么全部执行失败。
-
一致性(Consistency):事务执行后,数据库状态与其它业务规则保持一致。如转账业务,无论事务执行成功与否,参与转账的两个账号余额之和应该是不变的。
-
隔离性(Isolation):隔离性是指在并发操作中,不同事务之间应该隔离开来,使每个并发中的事务不会相互干扰。
-
持久性(Durability):一旦事务提交成功,事务中所有的数据操作都必须被持久化到数据库中,即使提交事务后,数据库马上崩溃,在数据库重启时,也必须能保证通过某种机制恢复数据。
6.3.不考虑隔离性会产生的3个问题
-
脏读(dirty read):读到另一个事务的未提交更新数据,即读取到了脏数据;
-
不可重复读(unrepeatable read):对同一记录的两次读取不一致,因为另一事务对该记录做了修改;
-
幻读(虚读)(phantom read):对同一张表的两次查询不一致,因为另一事务插入了一条记录;
6.4.解决办法:四种隔离级别
- SERIALIZABLE(串行化)
- 不会出现任何并发问题,因为它是对同一数据的访问是串行的,非并发访问的;
- 性能最差;
- REPEATABLE READ(可重复读)(MySQL)
- 防止脏读和不可重复读,不能处理幻读问题;
- 性能比SERIALIZABLE好;
- READ COMMITTED(读已提交数据)(Oracle)
- 防止脏读,没有处理不可重复读,也没有处理幻读;
- 性能比REPEATABLE READ好;
- READ UNCOMMITTED(读未提交数据)
- 可能出现任何事务并发问题;
- 性能最好;
7.动态SQL语句
7.1.if
标签
-
在Dao中新增方法:
List<User> findUserByCondition(User user);
-
在UserDao.xml中新增select标签
<!--由于在SqlMapConfig.xml中配置了包扫描,因此此处的parameterType的值只需填写类名即可--> <select id="findUserByCondition" resultMap="userMap" parameterType="user"> SELECT * FROM user WHERE 1=1 <if test="username != null"> AND username=#{username} </if> </select>
-
测试查询代码
User user = new User(); user.setUsername("小张"); List<User> users = userDao.findUserByCondition(user); for (User u : users) { System.out.println(u); }
7.2.where
标签
当有多个条件时,一直使用if标签显然是很麻烦的,因此可以选择使用where标签
-
将select标签改造一下
<select id="findUserByCondition" resultMap="userMap" parameterType="user"> SELECT * FROM user <where> <if test="username != null"> AND username=#{username} </if> <if test="sex != null"> AND sex=#{sex} </if> </where> </select>
-
测试查询代码
User user = new User(); user.setUsername("小张"); user.setSex("帅哥"); List<User> users = userDao.findUserByCondition(user); for (User u : users) { System.out.println(u); }
7.3.foreach
标签
-
新增一个queryVo类
public class QueryVo { private User user; private List<Integer> ids; public User getUser() { return user; } public void setUser(User user) { this.user = user; } public List<Integer> getIds() { return ids; } public void setIds(List<Integer> ids) { this.ids = ids; } }
-
在UserDao.xml中编写sql语句
<select id="findUserInIds" resultMap="userMap" parameterType="queryVo"> SELECT * FROM user <where> <!--注意:当if中为多条件时,并且关系应用and而不是&& --> <if test="ids != null and ids.size()>0"> <foreach collection="ids" open="and id in (" close=")" item="id" separator=","> <!--此处#{}内的值应与foreach标签中的item值一致--> #{id} </foreach> </if> </where> </select>
-
测试查询
QueryVo vo = new QueryVo(); List<Integer> list = new ArrayList<Integer>(); list.add(46); list.add(48); list.add(52); list.add(53); vo.setIds(list); List<User> users = userDao.findUserInIds(vo); for (User user : users) { System.out.println(user); }
8.mybatis的多表查询
8.1.一对一查询
-
在Account类中添加User的映射
private User user; public User getUser() { return user; } public void setUser(User user) { this.user = user; }
-
在AccountDao接口中定义
List<Account> findAll();
方法 -
在AccountDao.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.zzx.dao.AccountDao"> <!--定义封装account和user的resultMap--> <resultMap id="accountUserMap" type="account"> <!--此处column使用aid的原因是sql语句中给该主键列设置了别名aid,此处的column值应与sql语句中一致--> <id property="id" column="aid"/> <result property="uid" column="uid"/> <result property="money" column="money"/> <!--一对一的关系映射,配置封装user的内容--> <!--此处应该给定封装的User的类型,在javaType中定义--> <association property="user" column="uid" javaType="user"> <id property="id" column="id"/> <result property="username" column="username"/> <result property="birthday" column="birthday"/> <result property="sex" column="sex"/> <result property="address" column="address"/> </association> </resultMap> <select id="findAll" resultMap="accountUserMap"> SELECT u.*,a.id as aid,a.uid,a.money FROM account a,user u WHERE u.id = a.uid; </select> </mapper>
-
查询测试
List<Account> accounts = accountDao.findAll(); for (Account account : accounts) { System.out.println(account); System.out.println(account.getUser()); }
8.2.一对多查询
-
在User类中添加Account的映射
private List<Account> accounts; public List<Account> getAccounts() { return accounts; } public void setAccounts(List<Account> accounts) { this.accounts = accounts; }
-
改造UserDao中的
List<User> findAll();
方法 -
在UserDao.xml中修改配置
<resultMap id="userAccountMap" type="user"> <id property="id" column="id"/> <result property="username" column="username"/> <result property="birthday" column="birthday"/> <result property="sex" column="sex"/> <result property="address" column="address"/> <!--ofType的含义是User类中accounts集合中的对象为account--> <collection property="accounts" ofType="account"> <!--由于sql语句中使用了别名,所以此处account表中的id列名应为aid--> <id property="id" column="aid"/> <result property="uid" column="uid"/> <result property="money" column="money"/> </collection> </resultMap> <!--此处使用左外连接--> <select id="findAll" resultMap="userAccountMap"> SELECT * FROM user u LEFT OUTER JOIN account a ON u.id = a.uid </select>
-
查询测试
List<User> users = userDao.findAll(); for (User user : users) { System.out.println(user); System.out.println(user.getAccounts()); }
8.3.多对多查询
-
创建角色表和中间表
- CREATE TABLE `role` ( `ID` int(11) NOT NULL COMMENT '编号', `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称', `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述', PRIMARY KEY (`ID`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'), (2,'总裁','管理整个公司'), (3,'校长','管理整个学校');
#中间表
CREATE TABLE `user_role` (
`UID` int(11) NOT NULL COMMENT '用户编号',
`RID` int(11) NOT NULL COMMENT '角色编号',
PRIMARY KEY (`UID`,`RID`),
KEY `FK_Reference_10` (`RID`),
CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);
//创建对应的实体类
package com.zzx.domain;
import java.util.List;
public class Role {
private Integer roleId;
private String roleName;
private String roleDesc;
//多对多的关系映射:一个角色可以赋予多个用户
private List<User> users;
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public String getRoleDesc() {
return roleDesc;
}
public void setRoleDesc(String roleDesc) {
this.roleDesc = roleDesc;
}
@Override
public String toString() {
return "Role{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
", roleDesc='" + roleDesc + '\'' +
'}';
}
}
-
在RoleDao.xml中配置
<resultMap id="roleMap" type="role"> <!--此处id标签内的column的值与sql语句中对应--> <id property="roleId" column="rid"/> <result property="roleName" column="role_name"/> <result property="roleDesc" column="role_desc"/> <collection property="users" ofType="user"> <id property="id" column="id"/> <result property="username" column="username"/> <result property="birthday" column="birthday"/> <result property="sex" column="sex"/> <result property="address" column="address"/> </collection> </resultMap> <select id="findAll" resultMap="roleMap"> SELECT u.*,r.id AS rid,r.role_name,r.role_desc FROM role r LEFT OUTER JOIN user_role ur ON r.id = ur.rid LEFT OUTER JOIN user u ON u.id = ur.uid </select>
-
查询测试
List<Role> roles = roleDao.findAll(); for (Role role : roles) { System.out.println(role); System.out.println(role.getUsers()); }
用户到角色的多对多就只是sql语句以及resultMap有少许变换,这里不再详细说明
9.mybatis的延迟加载
9.1.一对一的延迟加载
-
更改AccountDao.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.zzx.dao.AccountDao"> <!--定义封装account和user的resultMap--> <resultMap id="accountUserMap" type="account"> <!--此处column使用aid的原因是sql语句中给该主键列设置了别名aid,此处的column值应与sql语句中一致--> <id property="id" column="aid"/> <result property="uid" column="uid"/> <result property="money" column="money"/> <!--一对一的关系映射,配置封装user的内容--> <!--此处应该给定封装的User的类型,在javaType中定义--> <association property="user" column="uid" javaType="user" select="com.zzx.dao.UserDao.findById"> </association> </resultMap> <select id="findAll" resultMap="accountUserMap"> SELECT * FROM account </select> </mapper>
-
在SqlMapConfig.xml文件中配置打开延迟加载
<settings> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"/> </settings>
-
测试查询
List<Account> accounts = accountDao.findAll(); for (Account account : accounts) { System.out.println(account); System.out.println(account.getUsers()); }
9.2.一对多的延迟加载
…
10.mybatis中的缓存
10.1.什么是缓存
存在于内存中的临时数据
10.2.为什么使用缓存
减少和数据库的交互次数,提高执行效率
10.3.什么样的数据可以使用缓存
10.3.1.适用于缓存:
- 经常查询且不经常改变的
- 数据的正确与否对最终的结果影响不大的
10.3.2.不适用于缓存
- 经常改变的数据
- 数据的正确与否对最终结果的影响很大的
- 例如:商品的库存,银行的汇率,股市的牌价
10.4.mybatis中的一级缓存和二级缓存
10.4.1.一级缓存(一级缓存默认是开启的):
它指的是Mybatis中SqlSession对象的缓存。
当我们执行查询之后,查询的结果会同时存入到SqlSession为我们提供一块区域中。
该区域的结构是一个Map。当我们再次查询同样的数据,mybatis会先去sqlsession中查询是否有,有的话直接拿出来用。
当SqlSession对象消失时,mybatis的一级缓存也就消失了。
- 也可以通过
slqSession.clearCache()
来清空一级缓存 - 当调用sqlSession的修改,添加,删除,commit(),close()等方法时,就会清空以及缓存
10.4.2.二级缓存:
它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
二级缓存的使用步骤:
- 第一步:让Mybatis框架支持二级缓存(在SqlMapConfig.xml中配置)
<settings>
<setting name="cacheEnable" value="true"/>
</settings>
- 第二步:让当前的映射文件支持二级缓存(在IUserDao.xml中配置:新增cache标签即可)
<cache/>
- 第三步:让当前的操作支持二级缓存(在select标签中配置,新增useCache标签,值为true)
<select id="findById" parameterType="INT" resultType="user" useCache="true">
select * from user where id =#{uid}
</select>
11.mybatis的注解开发
11.1.注解开发单表操作
-
SqlMapConfig.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="jdbcConfig.properties"/> <!--配置别名--> <typeAliases> <package name="com.zzx.domain"/> </typeAliases> <!--配置环境--> <environments default="mysql"> <environment id="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> </environments> <!--指定带有注解的dao接口所在位置--> <mappers> <package name="com.zzx.dao"/> </mappers> </configuration>
-
UserDao接口以及方法上的注解
@Select("select * from user") List<User> findAll();
-
查询测试
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml"); SqlSessionFactory build = new SqlSessionFactoryBuilder().build(in); SqlSession sqlSession = build.openSession(true); UserDao userDao = sqlSession.getMapper(UserDao.class); List<User> users = userDao.findAll(); for (User user : users) { System.out.println(user); } sqlSession.close(); in.close();
11.2.mybatis注解建立实体类属性和数据库表中列的对应关系
当实体类的字段名称与表中列名不一致时,mybatis中提供了一个@Results注解
@Select("select * from user")
//Results有一个id属性,设置其值可以让其他查询方法来引用该Results
@Results(id = "userMap", value = {
//此处没有像xml配置文件中ResultMap一样分别使用id和result标签将主键和其他列区分开,而是使用了一个id属性,当其值为true时,说明该列是主键。
@Result(id = true, property = "userId", column = "id"),
@Result(property = "userName", column = "username"),
@Result(property = "userAddress", column = "address"),
@Result(property = "userSex", column = "sex"),
@Result(property = "userBirthday", column = "birthday")
})
List<User> findAll();
@Select("select * from user where id=#{id}")
//引用上面定义的Results
@ResultMap(value = {"userMap"})
User findById(Integer userId);
@Select("select * from user where username like #{username}")
@ResultMap(value = {"userMap"})
List<User> findUserByName(String username);
11.3.注解开发复杂多表查询
- 一对多
@Select("select * from account")
//Results有一个id属性,设置其值可以让其他查询方法来引用该Results
@Results(id = "accountMap", value = {
@Result(id = true, property = "id", column = "id"),
@Result(property = "uid", column = "uid"),
@Result(property = "money", column = "money"),
@Result(property = "user", column = "uid",
//此处select属性的内容为调用上面的UserDao的findById()方法,fetchType为配置立即加载
one = @One(select = "com.zzx.dao.UserDao.findById", fetchType = FetchType.EAGER)))
})
List<User> findAll();
-
多对多
只需将@Result注解内的one = @One属性改为many = @Many,并将其值改为对应的方法即可