mybatis的入门之多表查询的多对多
准备工作
IDEA的创建Maven
点击下一步
输入完成后，点击下一步，在点击完成就ok了
并且在pom.xml里面导入关系依赖坐标
创建目录结构
实现Role到User 的 多对多
所以我们要创建，2个实体类User和Role 实体类的属性名称都对应数据库的列名称 并且创建get和set 和重写toString 方法。
注意（实体类都要 实现Serializable（序列化））
User实体类
package com.itmei.domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
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 String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", address='" + address + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
'}';
}
}
Role实体类
package com.itmei.domain;
import java.io.Serializable;
public class Role implements Serializable {
private Integer roleId;
private String roleName;
private String roleDesc;
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;
}
public String toString() {
return "Role{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
", roleDesc='" + roleDesc + '\'' +
'}';
}
}
在实体类Role中加入 映射关系
编写Role接口
（前提你要在resources下创建和java目录下的接口包一样）
RoleDao.xml 编写映射文件
我这里标签导错了，反正遇到这个问题记得点击刷新，在这里我们用mapper标签 里面有个属性namespace用于指定Dao的
collection标签当然可以一对多或多对多。
ofType属性：用于把返回的数据封装到全限定类名
association标签用于一对一
javaType属性：用于把返回的数据封装到全限定类名
配置文件SqlMapperConfig.xml
我们在resources下创建SqlMapperConfig.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">
<!--mybatis的主配置文件-->
<configuration>
<!--用于配置外部资源 这个位置要再前面 -->
<properties resource="jdbcConfig.properties"></properties>
<!--配置typeAliases标签：注册实体类的别名 （实体类的别名就是类的名称不区分大小写）-->
<typeAliases>
<package name="com.itmei.domain"/>
</typeAliases>
<!--配置环境-->
<environments default="mysql">
<!--mysql的环境-->
<environment id="mysql">
<!--事务管理-->
<transactionManager type="JDBC"></transactionManager>
<!--数据源-->
<dataSource type="POOLED">
<!--数据库的基本信息-->
<property name="driver" value="${jdbc.driver}"/> <!--这里的value引用外部信息${}里面的值要和外置信息的key名称一样-->
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<!--mapper的映射-->
<mappers>
<!--使用package标签：注册dao下的所有接口-->
<package name="com.itmei.dao"/>
</mappers>
</configuration>
外置数据库配置文件信息：
编写测试类：
创建RoleTest的测试类：
package com.itmei.Test;
import com.itmei.dao.RoleDao;
import com.itmei.domain.Role;
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 RoleTest {
private InputStream in;
private SqlSession session;
private RoleDao roleDao;
//在测试方法执行前运行
public void init() throws Exception {
//1.读取配置
in= Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建构建者
SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
//3.创建Sqlsession工厂对象
SqlSessionFactory factory = builder.build(in);
//4.创建Sqlsession对象
session = factory.openSession(); //也可以在openSession里面放true ，也是提交的意思
//5.创建Dao的代理对象
roleDao = session.getMapper(RoleDao.class);
}
//在测试方法执行后运行
public void end() throws Exception {
//7.提交事务
session.commit();
//8.释放资源
session.close();
in.close();
}
/**
* 查询角色同时获取用户信息
* @throws Exception
*/
public void testFindAll() throws Exception{
List<Role> roles=roleDao.findAll();
for (Role role:roles){
System.out.println("-----每一个用户信息--------");
System.out.println(role);
System.out.println(role.getUsers());
}
}
}
测试结果：
把获取用户信息的关了就，只查询出职位
log4j.properties 这个是日志的配置
有他就可以看见运行的日志信息
# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
这个问题是没有上面的log4j.properties 这个是日志的配置
XML配置的延迟加载：
实体类和数据库列名称一致
创建User类
package com.itmei.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
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 String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", address='" + address + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
'}';
}
}
创建Account实体类：
package com.itmei.domain;
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;
}
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
'}';
}
}
使用 assocation 实现延迟加载（一对一）
需求：查询账户信息同时查询用户信息。
在Account实体类添加User对象
Account账户的持久层 DAO 接口
package com.itmei.dao;
import com.itmei.domain.Account;
import java.util.List;
public interface AccountDao {
/**
* 查询所有账户，同时获取账户的所属名称和地址信息
* @return
*/
List<Account> findAll();
}
Account账户的持久层映射文件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">
<!--1.上面的是约束-->
<mapper namespace="com.itmei.dao.AccountDao">
<!-- 创建表的对应关系-->
<resultMap id="accountMap" type="account">
<id column="id" property="id"></id>
<result column="uid" property="uid"></result>
<result column="money" property="money"></result>
<!--他是用于指定从表方的引用实体类属性的-->
<association property="user" javaType="user"
select="com.itmei.dao.UserDao.findById"
column="uid">
</association>
</resultMap>
<select id="findAll" resultMap="accountMap">
select * from account;
</select>
select属性：填写我们要调用的select 映射的 id
column属性：填写我们要传递的select映射参数
</mapper>
User用户的持久层接口和映射文件：
UserDao 接口
package com.itmei.dao;
import com.itmei.domain.User;
import java.util.List;
public interface UserDao {
/**
* 根据id查询
* @param id
* @return
*/
User findById(Integer id);
}
UserDao 接口映射文件：
<?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">
<!--1.上面的是约束-->
<mapper namespace="com.itmei.dao.UserDao">
<!--根据id获取-->
<select id="findById" resultType="user" parameterType="int">
select * from user where id=#{uid}
</select>
</mapper>
开启 Mybatis 的延迟加载策略：
<!--配置参数-->
<settings>
<!--开启mybatis的延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--将积极加载改为消息加载即按需加载-->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
编写测试只查账户信息不查用户信息。
package com.itmei.Test;
import com.itmei.dao.AccountDao;
import com.itmei.domain.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.InputStream;
import java.util.List;
public class AccountTest {
private InputStream in;
private SqlSession session;
private AccountDao accountDao;
//在测试执行前运行
public void init() throws Exception{
//1.读取配置文件
in= Resources.getResourceAsStream("SqlMapConfig.xml");
//2.获取SqlSessionFactory 工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//3.获取SqlSession对象
session = factory.openSession(true);
//4.获取dao代理对象
accountDao = session.getMapper(AccountDao.class);
}
//在测试执行后运行
public void end() throws Exception{
//6.释放资源
session.close();
in.close();
}
/**
* 查询所有账户，同时获得账户的所属用户
*/
public void testFindAll(){
List<Account> accounts=accountDao.findAll();
/* for (Account account:accounts){
System.out.println(account);
//System.out.println(account.getUser());
}*/
}
}
运行结果：
我们发现，因为本次只是将Account对象查询出来放入List集合中，并没有涉及到User对象，所以就没有发出SQL语句查询账户所关联的User对象的查询。
使用 Collection 实现延迟加载（一对多）
在 User 实体类中加入 List属性 一对多
编写UserDao用户和AccountDao账户持久层接口的方法
package com.itmei.dao;
import com.itmei.domain.User;
import java.util.List;
public interface UserDao {
/**
* 查询所有用户，同时获取所有用户信息
* @return
*/
List<User> findAll();
}
AccountDao 的接口配置：
package com.itmei.dao;
import com.itmei.domain.Account;
import java.util.List;
public interface AccountDao {
/**
* 根据id查询账号信息
* @param id
* @return
*/
List<Account> findByUid(Integer id);
}
编写用户（user）持久层映射配置：
<?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">
<!--1.上面的是约束-->
<mapper namespace="com.itmei.dao.UserDao">
<!--创建表关系-->
<resultMap id="userMap" type="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="sex" property="sex"></result>
<result column="address" property="address"></result>
<result column="birthday" property="birthday"></result>
<!-- 创建一对多或对多集合属性的映射关系
ofType：用于指定集合元素的数据类型
select:用于指定查询账户的唯一标识（账户的dao全限定名称加上方法名称）
column：用于指定使用哪一个字段的值作为条件查询
-->
<collection property="accounts" ofType="account"
select="com.itmei.dao.AccountDao.findByUid"
column="id">
</collection>
</resultMap>
<!--查询所有-->
<select id="findAll" resultMap="userMap">
select * from user ;
</select>
</mapper>
编写账户（account）持久层映射配置：
测试只加载用户信息
package com.itmei.Test;
import com.itmei.dao.AccountDao;
import com.itmei.dao.UserDao;
import com.itmei.domain.Account;
import com.itmei.domain.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.InputStream;
import java.util.List;
public class UserTest {
private InputStream in;
private SqlSession session;
private UserDao userDao;
private SqlSessionFactory factory ;
//在测试执行前运行
public void init() throws Exception{
//1.读取配置文件
in= Resources.getResourceAsStream("SqlMapConfig.xml");
//2.获取SqlSessionFactory 工厂
factory = new SqlSessionFactoryBuilder().build(in);
//3.获取SqlSession对象
session = factory.openSession(true);
//4.获取dao代理对象
userDao = session.getMapper(UserDao.class);
}
//在测试执行后运行
public void end() throws Exception{
//6.释放资源
session.close();
in.close();
}
/**
* 查询所有账户
*/
public void testFindAll(){
List<User> users=userDao.findAll();
/* for (User user:users){
System.out.println(user);
//System.out.println(account.getUser());
}*/
}
}
测试结果：
我们发现，因为本次只是将User对象查询出来放入List集合中，并没有涉及到Account对象，所以就没有发出SQL语句查询用户所关联的Account对象的查询。
Mybatis 缓存
Mybatis一级缓存
一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。
一级缓存的分析
一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。
第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。
得到用户信息，将用户信息存储到一级缓存中。
如果 sqlSession 去执行 commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。
Mybatis 二级缓存
二级缓存设置 (XML)
二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。
二级缓存示意图：
首先开启 mybatis 的二级缓存。sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。
sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。
二级缓存的开启与关闭
第一步：在 SqlMapConfig.xml 文件开启二级缓存
第二步：配置相关的 Mapper 映射文件（接口的xml）
第三步：配置 statement （声明）上面的 useCache 属性：默认是true
二级缓存测试
package com.itmei.test;
import com.itmei.dao.UserDao;
import com.itmei.domain.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.InputStream;
public class SecondLevelCacheTest {
private InputStream in;
private SqlSessionFactory factory;
//用于测试方法执行之前执行
public void init() throws Exception {
//1.读取配置，生成字节输入流
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.获取SqlSessionFactory工厂
factory = new SqlSessionFactoryBuilder().build(in);
}
//用于在测试方法执行之后执行
public void destroy() throws Exception {
in.close();
}
/**
* 测试二级缓存
* @throws Exception
*/
public void testFirstLeveCache() {
SqlSession sqlSession1 = factory.openSession();
UserDao dao1 = sqlSession1.getMapper(UserDao.class);
User user1=dao1.findById(41);
System.out.println(user1);
sqlSession1.close();//一级缓存消失
SqlSession sqlSession2 = factory.openSession();
UserDao dao2 = sqlSession2.getMapper(UserDao.class);
User user2=dao2.findById(41);
System.out.println(user1);
sqlSession2.close();//一级缓存消失
System.out.println(user1==user2);
}
}
经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。
二级缓存注意事项:
总结：mybatis的入门
mybatis的入门
mybatis的环境搭建
第一步：创建maven工程并导入坐标
第二步：创建实体类和dao的接口
第三步：创建Mybatis的主配置文件
SqlMapConifg.xml
第四步：创建映射配置文件
IUserDao.xml
环境搭建的注意事项：
第一个：创建IUserDao.xml 和 IUserDao.java时名称是为了和我们之前的知识保持一致。
在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper
所以：IUserDao 和 IUserMapper是一样的
第二个：在idea中创建目录的时候，它和包是不一样的
包在创建时：com.itheima.dao它是三级结构
目录在创建时：com.itheima.dao是一级目录
第三个：mybatis的映射配置文件位置必须和dao接口的包结构相同
第四个：映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
第五个：映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名
当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类。
mybatis的入门案例
第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源
注意事项：
不要忘记在映射配置中告知mybatis要封装到哪个实体类中
配置的方式：指定实体类的全限定类名
基于注解的入门案例：
把IUserDao.xml移除，在dao接口的方法上使用@Select注解，并且指定SQL语句
同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名。
明确：
我们在实际开发中，都是越简便越好，所以都是采用不写dao实现类的方式。
不管使用XML还是注解配置。
但是Mybatis它是支持写dao实现类的。
