通过前面的学习,我们已经掌握了 MyBatis 中一对一(多对一)、一对多、多对多关系的配置及实现,可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是将关联的对象的信息也一并加载出来,此时就是我们所说的延迟加载。
举例:用户和账户
一个账户只能属于一个用户(多个账户也可以属于同一个用户):一对一(多对一)
一个用户可以有多个账户:一对多
在查询用户时,可能我就只是想查询用户信息,并不关心其账户,因此用户下的账户信息应该是什么时候使用什么时候才加载出来(延迟加载)。
在查询账户时,光是查出账户信息而不知道此账户属于哪个用户会很不直观,因此账户的所属用户信息应该是随着账户查询时一起立即查询出来(立即加载)。
延迟加载:就是在需要用到数据时才进行加载,不需要用到数据时就不加载数据。延迟加载也称懒加载。
在对应的四种表关系中:
在实现延迟加载之前,我们必须做一些配置。
进入 MyBatis 的官方文档,找到 settings 的说明信息:
设置名 | 描述 | 默认值 |
---|---|---|
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 | false |
aggressiveLazyLoading | 开启时,任一方法的调用都会加载该对象的所有延迟加载属性。 否则,每个延迟加载属性会按需加载(参考 lazyLoadTriggerMethods)。 | false (在 MyBatis 3.4.1 及之前的版本中默认为 true) |
我们需要在 MyBatis 的核心配置文件中添加延迟加载的配置:
<settings>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
settings>
如果MyBatis版本是3.4.1以后就可以不添加aggressiveLazyLoading,因为默认是false。
案例:查询所有账户及其所属用户信息
用户表、账户表、用户实体类、账户实体类,可在前篇博客查看。
IAccountDao:
import com.fox.pojo.Account;
import java.util.List;
public interface IAccountDao {
//查询所有账户及其所属用户信息
List<Account> findAll();
}
IAccountDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IAccountDao">
<resultMap id="accountUser" type="com.fox.pojo.Account">
<id property="id" column="id">id>
<result property="uid" column="uid">result>
<result property="money" column="money">result>
<association property="user" column="uid" javaType="com.fox.pojo.User" select="com.fox.dao.IUserDao.findUserById">association>
resultMap>
<select id="findAll" resultMap="accountUser">
select * from account;
select>
mapper>
IUserDao:
import com.fox.pojo.User;
import java.util.List;
public interface IUserDao {
//根据id查询用户以及所包含的账户信息
User findUserById(Integer id);
}
IUserDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IUserDao">
<select id="findUserById" parameterType="Integer" resultType="com.fox.pojo.User">
select * from user where id=#{id};
select>
mapper>
测试类:
import com.fox.dao.IAccountDao;
import com.fox.pojo.Account;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class AccountTest {
private InputStream in = null;
private SqlSession sqlSession = null;
private IAccountDao accountDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
accountDao = sqlSession.getMapper(IAccountDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll() {
List<Account> accounts = accountDao.findAll();
}
}
我们发现,因为本次只是将 Account对象查询出来放入 List 集合中,并没有涉及到 User对象,所以就没有发出 SQL 语句查询账户所关联的 User 对象的查询。
案例:查询所有用户及其所包含的账户信息
用户表、账户表、用户实体类、账户实体类,可在前篇博客查看。
IUserDao:
import com.fox.pojo.User;
import java.util.List;
public interface IUserDao {
//查询所有用户以及所包含的账户信息
List<User> findAll();
}
IUserDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IUserDao">
<resultMap id="userAccountMap" type="com.fox.pojo.User">
<id property="id" column="id">id>
<result property="username" column="username">result>
<result property="birthday" column="birthday">result>
<result property="sex" column="sex">result>
<result property="address" column="address">result>
<collection property="accounts" ofType="com.fox.pojo.Account" column="id" select="com.fox.dao.IAccountDao.findAccountByUid">collection>
resultMap>
<select id="findAll" resultMap="userAccountMap">
select * from user;
select>
mapper>
IAccountDao:
import com.fox.pojo.Account;
public interface IAccountDao {
//根据用户id查询账户及用户信息
List<Account> findAccountByUid(Integer uid);
}
IAccountDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IAccountDao">
<select id="findAccountByUid" parameterType="Integer" resultType="com.fox.pojo.Account">
select * from account where uid=#{uid};
select>
mapper>
测试类:
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
}
}
像大多数的持久化框架一样,MyBatis 也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提高性能。
MyBatis 中缓存分为一级缓存,二级缓存。
User实体类:
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
IUserDao:
import com.fox.pojo.User;
public interface IUserDao {
//根据id查询用户以及所包含的账户信息
User findUserById(Integer id);
}
IUserDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IUserDao">
<select id="findUserById" parameterType="Integer" resultType="com.fox.pojo.User">
select * from user where id=#{id};
select>
mapper>
测试类:
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
User user1 = userDao.findUserById(41);
System.out.println(user1);
User user2 = userDao.findUserById(41);
System.out.println(user2);
System.out.println(user1==user2);
}
}
我们可以发现,虽然在上面的代码中我们查询了两次,但最后只执行了一次数据库操作,这就是 MyBatis 提供给我们的一级缓存在起作用了。因为一级缓存的存在,导致第二次查询 id 为 41 的记录时,并没有发出 sql 语句从数据库中查询数据,而是从一级缓存中查询。
sqlSession.commit()
、sqlSession.close()
等方法时,就会清空一级缓存。import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
private SqlSessionFactory factory =null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
User user1 = userDao.findUserById(41);
System.out.println(user1);
sqlSession.close();
//再次获取SqlSession对象
sqlSession = factory.openSession();
userDao = sqlSession.getMapper(IUserDao.class);
User user2 = userDao.findUserById(41);
System.out.println(user2);
System.out.println(user1==user2);
}
}
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
User user1 = userDao.findUserById(41);
System.out.println(user1);
sqlSession.clearCache();
User user2 = userDao.findUserById(41);
System.out.println(user2);
System.out.println(user1==user2);
}
}
IUserDao:
import com.fox.pojo.User;
public interface IUserDao {
//根据id查询用户以及所包含的账户信息
User findUserById(Integer id);
//更新用户
void updateUser(User user);
}
IUserDao.xml:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IUserDao">
<select id="findUserById" parameterType="Integer" resultType="com.fox.pojo.User">
select * from user where id=#{id};
select>
<update id="updateUser" parameterType="com.fox.pojo.User">
update user set username=#{username},address=#{address} where id=#{id};
update>
mapper>
测试类:
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
@Test
public void testFindAll(){
//根据id查询用户
User user1 = userDao.findUserById(41);
System.out.println(user1);
//更新用户信息
user1.setUsername("小何");
user1.setAddress("广东");
userDao.updateUser(user1);
//再次查询id为41的用户
User user2 = userDao.findUserById(41);
System.out.println(user2);
System.out.println(user1==user2);
}
}
案例:
让MyBatis框架支持二级缓存(在MyBatis核心配置文件中配置):
<settings>
<setting name="cacheEnabled" value="true"/>
settings>
因为 cacheEnabled 的默认值就为 true,所以这一步可以省略不配置。为 true 代表开启二级缓存;为false 代表不开启二级缓存。
让当前的映射文件支持二级缓存
(在IUserDao.xml中配置)并且让当前的操作支持二级缓存(在select标签中配置)useCache="true"
:
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fox.dao.IUserDao">
<cache>cache>
<select id="findUserById" parameterType="Integer" resultType="com.fox.pojo.User" useCache="true">
select * from user where id=#{id};
select>
mapper>
注意:针对每次查询都需要最新的数据的 sql,要设置成 useCache="false"
,不要用二级缓存。
测试类:
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSessionFactory factory =null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
factory = new SqlSessionFactoryBuilder().build(in);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
in.close();
}
@Test
public void testFindAll(){
SqlSession sqlSession1 = factory.openSession();
IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
User user1 = dao1.findUserById(41);
System.out.println(user1);
sqlSession1.close();//一级缓存消失,不让一级缓存干扰二级缓存的结果
SqlSession sqlSession2 = factory.openSession();
IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
User user2 = dao2.findUserById(41);
System.out.println(user2);
sqlSession2.close();//一级缓存消失,不让一级缓存干扰二级缓存的结果
System.out.println(user1 == user2);
}
}
经过上面的测试,我们发现执行了两次查询,并且在执行第一次查询后,我们关闭了一级缓存,再去执行第二次查询时,我们发现并没有对数据库再发出第二次的 sql 语句,所以此时的数据就只能是来自于我们所说的二级缓存。但是为什么还是false呢,这是因为在二级缓存中存放的内容是数据而不是对象。它会重新创建一个User对象,将缓存的数据再放入这个新User对象,因此user1!=user2
。
注意:当我们在使用二级缓存时,所缓存的类一定要实现 java.io.Serializable 接口,这种就可以使用序列化方式来保存对象。
MyBatis注解开发是用注解代替了映射的xml配置文件,但是MyBatis核心配置文件还是需要的。
注意:使用了MyBatis注解开发就不能同时写xml映射文件,不然会报错。
案例:
User类:
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
MyBatis核心配置文件:
由于注解开发替代了Mapper映射文件,所以本例无Mapper映射文件,因此映射器的写法也有变动:
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="jdbc.properties">
properties>
<typeAliases>
<package name="com.fox.pojo">package>
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>
<mappers>
<package name="com.fox.dao"/>
mappers>
configuration>
IUserDao:
注意:传入单个参数可以省略@Param ,传入多个参数必须使用@Param并用逗号隔开
import com.fox.pojo.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;
import java.util.List;
public interface IUserDao {
//查询所有用户
@Select("select * from user")
List<User> findAll();
//根据id查询用户
@Select("select * from user where id=#{id}")
User findUserById(Integer id);
//根据用户名模糊查询用户
@Select("select * from user where username like #{username}")
List<User> findUserByName(String name);
//根据id和用户名查询用户
@Select("select * from user where id=#{id} and username=#{name}")
User findUserByTwo(@Param("id") Integer id,@Param("name") String name);
//查询总用户数量
@Select("select count(*) from user")
int findTotal();
//添加用户
@Insert("insert into user(username,birthday,address,sex) values(#{username},#{birthday},#{address},#{sex})")
void addUser(User user);
//更新用户
@Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
void updateUser(User user);
//删除用户
@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);
}
测试类:
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class UserTest {
private InputStream in = null;
private SqlSession sqlSession =null;
private IUserDao userDao = null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.使用 SqlSessionFactory 生产 SqlSession 对象
sqlSession = factory.openSession();
//4.使用 SqlSession 创建 dao 接口的代理对象
userDao = sqlSession.getMapper(IUserDao.class);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
//提交事务
sqlSession.commit();
//释放资源
sqlSession.close();
in.close();
}
//查询所有
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
}
//根据id查询
@Test
public void testFindUserById(){
User user = userDao.findUserById(41);
System.out.println(user);
}
//根据用户名模糊查询
@Test
public void testFindUserByName(){
List<User> users = userDao.findUserByName("%王%");
for (User user : users) {
System.out.println(user);
}
}
//根据id和用户名查询用户
@Test
public void testFindUserByTwo(){
User user = userDao.findUserByTwo(41, "小何");
System.out.println(user);
}
//查询总用户数
@Test
public void testFindTotal(){
int total = userDao.findTotal();
System.out.println("共有"+total+"个用户");
}
//添加用户
@Test
public void testAddUser(){
User user = new User();
user.setUsername("小张");
user.setAddress("河南");
user.setBirthday(new Date());
user.setSex("女");
userDao.addUser(user);
}
//更新用户
@Test
public void testUpdateUser(){
User user = new User();
user.setId(46);
user.setUsername("小杰");
user.setAddress("天津");
user.setBirthday(new Date());
user.setSex("男");
userDao.updateUser(user);
}
//删除用户
@Test
public void testDeleteUser(){
userDao.deleteUserById(49);
}
}
假如数据表中的列名是这样:
User类是这样:
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Date getUserBirthday() {
return userBirthday;
}
public void setUserBirthday(Date userBirthday) {
this.userBirthday = userBirthday;
}
public String getUserSex() {
return userSex;
}
public void setUserSex(String userSex) {
this.userSex = userSex;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
@Override
public String toString() {
return "User{" +
"userId=" + userId +
", userName='" + userName + '\'' +
", userBirthday=" + userBirthday +
", userSex='" + userSex + '\'' +
", userAddress='" + userAddress + '\'' +
'}';
}
}
属性名和列名不对应,之前我们可以在映射文件中通过配置
来实现,在使用注解开发时我们需要借助 @Results 注解、@Result 注解。
@Results({@Result(),@Result()})
或@Results(@Result())
都是正确的。
标签和
标签
@Result(one=@One())
)@Result(many=@many())
)案例:
import com.fox.pojo.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
public interface IUserDao {
//查询所有用户
@Select("select * from user")
@Results(id = "userMap",value = {
@Result(id = true,property = "userId",column = "id"),
@Result(property = "userName",column = "username"),
@Result(property = "userBirthday",column = "birthday"),
@Result(property = "userAddress",column = "address"),
@Result(property = "userSex",column = "sex")
})
List<User> findAll();
//根据id查询用户
@Select("select * from user where id=#{id}")
@ResultMap("userMap")
User findUserById(Integer id);
//根据用户名模糊查询用户
@Select("select * from user where username like #{username}")
@ResultMap("userMap")
List<User> findUserByName(String name);
}
@One 注解
(多对一、一对一)
代替了
标签,是多表查询的关键,在注解中用来指定子查询返回单一对象。
@Result(property="",column="",one=@One(select="",fetchType=))
@Many 注解
(一对多)
代替了
标签,是多表查询的关键,在注解中用来指定子查询返回对象集合。
@Result(property="",column="",many=@Many(select="",fetchType=))
注意:xml方式需要指定映射的 Java 实体类的属性 ofType或 javaType,但是注解中可以不定义。
案例:一个账户对应一个用户
Account类:
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private Integer uid;
private Double money;
//一对一(多对一)的映射:从表实体应该包含一个主表实体的对象引用
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
'}';
}
}
User类:
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
IAccountDao:
import com.fox.pojo.Account;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
public interface IAccountDao {
//查询所有账户,并且获取每个账户所属的用户信息
@Select("select * from account")
@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",one = @One(select = "com.fox.dao.IUserDao.findUserById",fetchType = FetchType.EAGER))
})
List<Account> findAll();
}
IUserDao:
import com.fox.pojo.User;
import org.apache.ibatis.annotations.*;
public interface IUserDao {
//根据id查询用户
@Select("select * from user where id=#{id}")
User findUserById(Integer id);
}
案例:一个用户对应多个账户
User类:
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
//一对多关系映射:一个用户对应多个账户
private List<Account> accounts;
public List<Account> getAccounts() {
return accounts;
}
public void setAccounts(List<Account> accounts) {
this.accounts = accounts;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
Account类:
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private Integer uid;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
'}';
}
}
IUserDao:
import com.fox.pojo.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
public interface IUserDao {
//查询所有用户
@Select("select * from user")
@Results(id = "userMap",value = {
@Result(id = true,property = "id",column = "id"),
@Result(property = "username",column = "username"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "address",column = "address"),
@Result(property = "sex",column = "sex"),
@Result(property = "accounts",column = "id",many = @Many(select = "com.fox.dao.IAccountDao.findAccountByUid",fetchType = FetchType.LAZY))
})
List<User> findAll();
}
IAccountDao:
import com.fox.pojo.Account;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface IAccountDao {
//根据用户id查询账户信息
@Select("select * from account where uid=#{uid}")
List<Account> findAccountByUid(Integer uid);
}
步骤:
<settings>
<setting name="cacheEnabled" value="true"/>
settings>
@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface IUserDao {
//查询所有用户
@Select("select * from user")
@Results(id = "userMap",value = {
@Result(id = true,property = "id",column = "id"),
@Result(property = "username",column = "username"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "address",column = "address"),
@Result(property = "sex",column = "sex"),
@Result(property = "accounts",column = "id",many = @Many(select = "com.fox.dao.IAccountDao.findAccountByUid",fetchType = FetchType.LAZY))
})
List<User> findAll();
//根据id查询用户
@Select("select * from user where id=#{id}")
@ResultMap("userMap")
User findUserById(Integer id);
}
import com.fox.dao.IUserDao;
import com.fox.pojo.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class UserTest {
private InputStream in = null;
private SqlSessionFactory factory =null;
@Before //标记在非静态方法上。在@Test方法前面执行,而且是在每一个@Test方法前面都执行。
public void init() throws IOException {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.使用构建者创建工厂对象 SqlSessionFactory
factory = new SqlSessionFactoryBuilder().build(in);
}
@After //标记在非静态方法上。在@Test方法后面执行,而且是在每一个@Test方法后面都执行。
public void destroy() throws IOException {
in.close();
}
//查询所有
@Test
public void testFindAll(){
SqlSession sqlSession1=factory.openSession();
IUserDao userDao1 = sqlSession1.getMapper(IUserDao.class);
User user1 = userDao1.findUserById(41);
System.out.println(user1);
sqlSession1.close();
SqlSession sqlSession2=factory.openSession();
IUserDao userDao2 = sqlSession2.getMapper(IUserDao.class);
User user2 = userDao2.findUserById(41);
System.out.println(user2);
sqlSession2.close();
System.out.println(user1==user2);
}
}