Mybatis使用总结
1.快速使用
1.创建数据库
2.创建Maven项目
3.创建实体类
4.创建核心配置文件 Mybatis-config.xml
5.创建接口
6.创建接口映射文件
1.创建数据库
CREATE DATABASE mybatis_day01;
USE mybatis_day01;
CREATE TABLE t_user(
uid int PRIMARY KEY auto_increment,
username varchar(40),
sex varchar(10),
birthday date,
address varchar(40)
);
INSERT INTO `t_user` VALUES (null, 'zs', '男', '2018-08-08', '北京');
INSERT INTO `t_user` VALUES (null, 'ls', '女', '2018-08-30', '武汉');
INSERT INTO `t_user` VALUES (null, 'ww', '男', '2018-08-08', '北京');
2.创建Maven 项目引入Maven 坐标
<dependencies>
<dependency>
<!--myaql驱动-->
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>
<dependency>
<!--mybatis驱动-->
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.4</version>
</dependency>
<dependency>
<!--junit驱动-->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
//要注意的地方:数据库驱动要根据版本号进行选择
3.创建实体类
public class User implements Serializable{
private int uid; //用户id
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
public User() {
}
public User(String username, String sex, Date birthday, String address) {
this.username = username;
this.sex = sex;
this.birthday = birthday;
this.address = address;
}
//get..set..toString
}
4.创建查询接口
public interface UserMapper {
List<User> getUserList();
}
5.创建接口的映射文件
<?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=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.ac.Mapper.UserMapper">
<!--select查询语句,id对应的是接口中的方法!-->
<select id="getUserList" resultType="com.ac.pojo.User">
select * from user;
</select>
</mapper>
6.创建Mybatis的核心配文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
<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="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!-->
<mapper resource="com/ac/Mapper/UserMapper.xml"/>
</mappers>
</configuration>
7.编辑测试类
@Test
public void test01() throws Exception{
//加载核心配置文件
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
//获得sqlSession工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
//获得sqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//方式二:getMapper,流行使用!
UserMapper Um = sqlSession.getMapper( UserMapper.class);
List<User> userList = Um.getUserList();
//打印结果
System.out.println(userList);
//释放资源
sqlSession.close();
}
8.Log4j配置文件 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
2.Mybatis核心配置文件
2.1. properties
作用(引入外部properties文件)可以引入外部配置文件还可以配置常量
1、mybatis可以使用properties来引入外部properties配置文件的内容;
resource:引入类路径下的资源
url:引入网络路径或者磁盘路径下的资源
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy_mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=1234
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="jdbc.properties">
</properties>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<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>
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!-->
<mapper resource="com/ac/Mapper/UserMapper.xml"/>
</mappers>
</configuration>
**2.2settings **
包含很多重要的设置项
setting:用来设置每一个设置项
name:设置项名
value:设置项取值
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。
<settings>
<!--启用了驼峰命名发-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
2.3.typeAliases
作用:修改类的别名,按照别名的方式进行注入
//为实体类创建对应的别名
例如:
<!--
1、typeAlias:为某个java类型起别名
type:指定要起别名的类型全类名;默认别名就是类名小写;employee
alias:指定新的别名
-->
<typeAliases>
<typeAlias type="com.ac.bean.User" alias="user"></typeAlias>
</typeAliases>
则
<select id="findaALL" resultType="user">
select * from t_user
</select>
<!--
2、package:为某个包下的所有类批量起别名
name:指定包名(为当前包以及下面所有的后代包的每一个类都起一个默认别名(类名小写),)
-->
<typeAliases>
<package name="com.ac.bean.User" />
</typeAliases>
<!--3. 在需要注入的类上加注解@Alias注解为某个类型指定新的别名-->
2.4 environments
作用:配置环境变量,Mybatis支持多种的环境变量,default属性指定默认的环境变量
environment:配置一个具体的环境信息;必须有两个标签;id代表当前环境的唯一标识
transactionManager:事务管理器;
type:事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
自定义事务管理器:实现TransactionFactory接口.type指定为全类名
dataSource:数据源;
type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
|POOLED(PooledDataSourceFactory)
|JNDI(JndiDataSourceFactory)
自定义数据源:实现DataSourceFactory接口,type是全类名
<environments default="dev_mysql">
<environment id="dev_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>
<environment id="dev_oracle">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${orcl.driver}" />
<property name="url" value="${orcl.url}" />
<property name="username" value="${orcl.username}" />
<property name="password" value="${orcl.password}" />
</dataSource>
</environment>
</environments>
2.5.mapper
作用:将sql映射注册到全局配置文件中,写的sql 的xml文件映射到全局配置文件中
<!--
mapper:注册一个sql映射
注册配置文件
resource:引用类路径下的sql映射文件
com/ac/Mapper/UserMapper.xml
url:引用网路路径或者磁盘路径下的sql映射文件
file:///var/com/ac/Mapper/UserMapper.xml
注册接口
class:引用(注册)接口,
1、有sql映射文件,映射文件名必须和接口同名,并且放在与接口同一目录下;
2、没有sql映射文件,所有的sql都是利用注解写在接口上;
推荐:
比较重要的,复杂的Dao接口我们来写sql映射文件
不重要,简单的Dao接口为了开发快速可以使用注解;
-->
//1.单个接口文件的扫描
<mappers>
<mappler resources="com/ac/Mapper/UserMapper.xml"></mappler>
</mappers>
//2.批量扫描:1、有sql映射文件,映射文件名必须和接口同名,并且放在与接口同一目录下;必须放在类的根目录下和接口同级,编译后的效果必须在同一级目录下
<mappers>
<package name="com.ac.Mapper"></package>
</mappers>
2.6databaseIdProvider
作用:databaseIdProvider:支持多数据库厂商的;
type=“DB_VENDOR”:VendorDatabaseIdProvider
作用就是得到数据库厂商的标识(驱动getDatabaseProductName()),mybatis就能根据数据库厂商标识来执行不同的sql;
MySQL,Oracle,SQL Server,xxxx
<databaseIdProvider type="DB_VENDOR">
<!-- 为不同的数据库厂商起别名 -->
<property name="MySQL" value="mysql"/>
<property name="Oracle" value="oracle"/>
<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>
在sql的映射文件中使用 databaseId=”Mysql“
例如:
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
databaseId="mysql">
select * from tbl_employee where id = #{id}
</select>
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee"
databaseId="oracle">
select EMPLOYEE_ID id,LAST_NAME lastName,EMAIL email
from employees where EMPLOYEE_ID=#{id}
</select>
3.获取自增id 的方式
1.通过语句查询
<!--添加测试parameterType属性:参数的类型;赋值的时候直接写对象里面的属性名-->
<insertid="save" parameterType="com.ac.bean.User">
<!--查询主键自增值
presultType:主键类型;
keyProperty:pojo里面对应的id的属性名;
order属性:指定是在目标的sql语句之前还是之后执行-->
<selectKey resultType="int" keyProperty="uid" order="AFTER">
SELECT LAST_INSERT_ID()
</selectKey>
INSERT INTO
t_user(username,sex,birthday,address)VALUES(#{username},#{sex},#{birthday},#{address})
</insert>
2通过语句中的配置向进行查询
<!--
keyProperty:pojo里面对应的id的属性名;
useGeneratedKeys="true"使用主键自增值-->
<insert id="save" parameterType="com.ac.bean.User" keyProperty="uid" useGeneratedKeys="true">
INSERT INTO t_user(username,sex,birthday,address)VALUES(#{username},#{sex},#{birthday},#{address})
</insert>
4.#{} 和 ${} 的区别
1. #{}表示一个占位符号
通过#{}可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和数据库类型转换
#{}可以有效防止 sql 注入
#{}可以接收简单类型值或 pojo 属性值
如果 parameterType 传输单个简单类型值,#{}括号中可以是 value 或其它名称
2.${}表示拼接 sql 串
通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换.
${}不能防止 sql 注入
${}可以接收简单类型值或 pojo 属性值
如果 parameterType 传输单个简单类型值.${}括号中只能是 value
原生jdbc不支持占位符的地方我们就可以使用${}进行取值
比如分表、排序。。。;按照年份分表拆分
select * from ${year}_salary where xxx;
select * from tbl_employee order by ${f_name} ${order}
#{}:更丰富的用法:
规定参数的一些规则:
javaType、 jdbcType、 mode(存储过程)、 numericScale、
resultMap、 typeHandler、 jdbcTypeName、 expression(未来准备支持的功能);
jdbcType通常需要在某种特定的条件下被设置:
在我们数据为null的时候,有些数据库可能不能识别mybatis对null的默认处理。比如Oracle(报错);
JdbcType OTHER:无效的类型;因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型,oracle不能正确处理;
由于全局配置中:jdbcTypeForNull=OTHER;oracle不支持;两种办法
1、#{email,jdbcType=OTHER};
2、jdbcTypeForNull=NULL
<setting name="jdbcTypeForNull" value="NULL"/>
5.动态sql
1.if 标签:用来判断条件
<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo">
SELECT*FROM t_user WHERE 1=1
<if test="user!=null and user.uid!=0">
AND uid>#{user.uid}
</if>
<if test="user!=null and user.username!=null and user.username!=''">
AND user name like#{user.username}
</if>
</select>
2.where 标签:消除where 1=1
<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo">
SELECT*FROM t_user
<where>
<if test="user!=null and user.uid!=0">
AND uid>#{user.uid}
</if>
<if test="user!=null and user.username!=null and user.username!=''">
AND user name like#{user.username}
</if>
</where>
</select>
3.foreach标签:循环读取条件
例如sql:
select uid,username,birthday,sex,address from t_user WHERE username LIKE'张%' AND uid IN(1,7,10,18)
则标签处理的时候
<select id="findByQueryVo" resultType="com.ac.bean.User" parameterType="com.ac.bean.QueryVo">
SELECT uid,username,birthday,sex,address FROM t_user
<where>
<if test="user!=null and user.username!=null and user.username!=''">
AND username like #{user.username}
</if>
<--! ids 传入的数据
collection:代表要遍历的集合元素,注意编写时不要写#{}
open:代表语句的开始部分(一直到动态的值之前)
close:代表语句结束部分
item:代表遍历集合的每个元素,生成的变量名(随便取)
sperator:代表分隔符 (动态值之间的分割)
-->
<if test="ids!=null">
<foreach collection="ids" item="id" open="AND uid in(" close=")" separator=",">
#{id}
</foreach>
</if>
</where>
</select>
4.SQL标签
//一般公共的标签都用sql标签
--定义sql片段
<sql id="sqlpd">
select * from
</sql>
--引用sql片段
<include refid="sqlpd"></include>
6.Mybatis 的日志使用
1.导入Maven 坐标
<dependencies>
<!--MyBatis坐标-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
</dependencies>
2.添加配置文件----log4j.properties
##日志输出的级别,以及配置记录方案
log4j.rootLogger= DEBUG,Console,info,std,file
#日志输出配置
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.org.apache=DEBUG##设置日志记录到控制台的方式
log4j.appender.std=org.apache.log4j.ConsoleAppender
log4j.appender.std.Target=System.err
log4j.appender.std.layout=org.apache.log4j.PatternLayout
log4j.appender.std.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n
##设置日志记录到文件的方式
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=mylog.txt
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
PatternLayout:日志布局类型
ConversionPattern:日志输出格式
%m 输出代码中指定的消息
%p 输出优先级,即DEBUG,INFO,WARN,ERROR,FATAL
%r 输出自应用启动到输出该log信息耗费的毫秒数
%c 输出所属的类目,通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符,Windows平台为“rn”,Unix平台为“n”
%d 输出日志时间点的日期或时间,默认格式为ISO8601,也可以在其后指定格式,比如:%d{yyyy MMM dd HH:mm:ss,SSS},输出类似:2002年10月18日 :10:28,921
%l 输出日志事件的发生位置,包括类目名、发生的线程,以及在代码中的行数。
级别:error > warn > info>debug>trace
trace:追踪,是最低的日志级别,相当于追踪程序的执行,一般不怎么使用。
debug:一般在开发中,都将其设置为最低的日志级别。
info:输出感兴趣的信息,我在开发中一般都会用info去输出。
warn:警告.有些时候,虽然程序不会报错,但是还是需要告诉程序员的。
error:错误,这个在开发中也挺常用的。
fatal:极其重大的错误,这个一旦发生,程序基本上也要停止了,目前限于开发经验,生产环境一般不用。
7.表和表之间的关系
1.一对一查询
例如账户和用户关系:一个账户对应一个用户(用户表的uid 是账户表Uid的外键)
SELECT a.*,u.username,u.address FROM t_account a,t_user u WHERE a.uid=u.uid
-
Account.java
在 Account 类中加入 User类的对象作为 Account 类的一个属性。
public class Account implements Serializable {
private Integer aid;
private Integer uid;
private Double money;
//表示一个账号属于一个用户的,是一种一对一的关系
private User user;
//get..set..toString
}
- AccountDao.java
public interface AccountDao {
/***
* 查询所有
* @return
*/
List<Account> findAllAccount();
}
-
AccountDao.xml
<!--
定义结果集映射转换器
唯一标识符:accountListMap
type:结果集需要转换的Pojo
-->
<resultMap id="accountListMap" type="Account">
<!--
SQL语句中的aid列的值赋值给需要转换的对象的aid属性
id:表示该映射关系是主键对象
column="aid":指定SQL语句中的列名字
property="aid":需要赋值给转换对象的指定属性
-->
<id column="aid" property="aid"></id>
<result column="money" property="money"></result>
<result column="uid" property="uid"></result>
<!--
association:用于关联加载的对象,用于一对一关系,
property:Account中的属性名字
javaType:为需要加载对应的类型
-->
<association property="user" javaType="User">
<result column="username" property="username"></result>
<result column="address" property="address"></result>
</association>
</resultMap>
<!--
查询所有账号
resultMap:使用accountListMap映射转换器进行转换
-->
<select id="findAllAccount" resultMap="accountListMap">
SELECT a.*,u.username,u.address FROM t_account a, t_user u WHERE a.uid = u.uid
</select>
```
2.一对多查询
例如: 用户信息和他的账户信息为一对多关系,并且查询过程中如果用户没有账户信息,此时也要将用户信息查询出来,我们想到了左外连接查询比较合适。
SELECT u.*, a.aid, a.money FROM t_user u LEFT OUTER JOIN t_account a ON u.uid = a.uid
- Account.java
public class Account {
private Integer aid;
private Integer uid;
private Double money;
}
-
User.java
为了能够让查询的 User 信息中,带有他的个人多个账户信息,我们就需要在 User 类中添加一个集合,
用于存放他的多个账户信息,这样他们之间的关联关系就保存了。
public class User implements Serializable{
private int uid;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
//表达关系:1个用户对应多个账户
private List<Account> accounts;
}
- UserDao.java
public interface UserDao {
/**
* 查询所有的用户对应的账户信息
* @return
*/
List<User> findUserAccountList();
}
- 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">
<mapper namespace="com.ac.dao.UserDao">
<!--
定义一个映射转换器,唯一标识:userAccountListMap
需要转换的类型为User
-->
<resultMap id="userAccountListMap" type="User">
<id property="uid" column="uid"></id>
<result property="username" column="username"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<result property="address" column="address"></result>
<!--
加载多方数据,
property属性:一方类里面List集合的属性名;
ofType:List中的对象类型
-->
<collection property="accounts" ofType="Account">
<result property="aid" column="aid"></result>
<result property="money" column="money"></result>
</collection>
</resultMap>
<!--一对多查询-->
<select id="findUserAccountList" resultMap="userAccountListMap">
SELECT u.*, a.aid, a.money FROM t_user u LEFT OUTER JOIN t_account a ON u.uid = a.uid
</select>
3.多对多查询
多对多关系其实我们看成是双向的一对多关系。用户与角色的关系模型就是典型的多对多关系.
需求:实现查询所有角色对象并且加载它所分配的用户信息。
1.创建表
CREATE TABLE t_role(
rid INT PRIMARY KEY AUTO_INCREMENT,
rName varchar(40),
rDesc varchar(40)
);
INSERT INTO `t_role` VALUES (null, '校长', '负责学校管理工作');
INSERT INTO `t_role` VALUES (null, '副校长', '协助校长负责学校管理');
INSERT INTO `t_role` VALUES (null, '班主任', '负责班级管理工作');
INSERT INTO `t_role` VALUES (null, '教务处主任', '负责教学管理');
INSERT INTO `t_role` VALUES (null, '班主任组长', '负责班主任小组管理');
-- 中间表(关联表)
CREATE TABLE user_role(
uid INT,
rid INT
);
ALTER TABLE user_role ADD FOREIGN KEY(uid) REFERENCES t_user(uid);
ALTER TABLE user_role ADD FOREIGN KEY(rid) REFERENCES t_role(rid);
INSERT INTO `user_role` VALUES ('1', '1');
INSERT INTO `user_role` VALUES ('3', '3');
INSERT INTO `user_role` VALUES ('2', '3');
INSERT INTO `user_role` VALUES ('2', '5');
INSERT INTO `user_role` VALUES ('3', '4');
2.分析
案例场景:查询所有角色,并且查询出每个角色授予的用户集合。
查询角色我们需要用到 Role 表,但角色分配的用户的信息我们并不能直接找到用户信息,而是要通过中间表(USER_ROLE 表)才能关联到用户信息。
下面是实现的 SQL 语句:
SELECT r.*, u.uid, u.username,u.sex,u.birthday,u.address FROM t_role r INNER JOIN user_role ur
ON r.rid = ur.rid INNER JOIN t_user u ON ur.uid = u.uid
或者
SELECT r.*, u.uid, u.username,u.sex,u.birthday,u.address FROM t_role r, user_role ur, t_user u
WHERE r.rid = ur.rid AND ur.uid = u.uid
3.实现
- User.java
public class User implements Serializable{
private int uid;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
}
- Role.java
public class Role {
private Integer rid;
private String rName;
private String rDesc;
//1个角色对应多个用户
private List<User> users;
}
- RoleDao.java
public interface RoleDao {
/**
* 查询角色信息
* @return
*/
List<Role> findRoleList();
}
- RoleDao.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.ac.dao.RoleDao">
<!--和一对多实现一致-->
<resultMap id="roleListMap" type="role">
<id column="rid" property="rid"></id>
<result column="rName" property="rName"></result>
<result column="rDesc" property="rDesc"></result>
<collection property="users" ofType="user">
<result property="username" column="username"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<result property="address" column="address"></result>
</collection>
</resultMap>
<select id="findRoleList" resultMap="roleListMap">
SELECT r.*,u.username,u.sex,u.birthday, u.address FROM t_role r,user_role ur,t_user u WHERE r.rid = ur.rid AND ur.uid = u.uid
</select>
</mapper>
8.延迟加载
1.多对一,一对一 延迟加载
1.1需求
查询账户(Account)信息并且关联查询用户(User)信息。
先查询账户(Account)信息,当我们需要用到用户(User)信息时再查询用户(User)信息。
-- 1. 查询账户
SELECT * FROM t_account
-- 2, 再查询用户(等使用到用户再查询 account.getUser().getName())
-- 再根据查询结果里面的uid查询当前账户所属的用户
SELECT * FROM t_user WHERE uid = 1
sql:select * from account
1.2实现
- User.java
public class User{
private int uid;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
}
- Account.java
public class Account {
private Integer aid;
private Integer uid;
private Double money;
//表达关系:1个用户对应1个账户
private User user;
}
- AccountDao.java
public interface AccountDao {
/**
* 查询账户信息(包含用户信息)
*
* @return
*/
List<Account> findAccountList();
}
- AccountDao.xml
<mapper namespace="com.ac.dao.AccountDao">
<select id="findAccountList" resultMap="accountListId">
SELECT * FROM t_account
</select>
<resultMap id="accountListId" type="Account">
<id property="aid" column="aid"/>
<result property="money" column="money"/>
<result property="uid" column="uid"/>
<!--association用于关联加载的对象,
property属性:多方类里面一方对象的属性名
javaType属性:一方对象的类型
select属性: 用于关联查询另外的一方(User)对应的id
column属性: 填写我们要传递给 select 映射的参数
fetchType属性:lazy延迟
-->
<association property="user" javaType="User" select="com.ac.dao.UserDao.findByUid" column="uid" fetchType="lazy" >
</association>
</resultMap>
</mapper>
- UserDao.java
public interface UserDao {
/**
* 根据id查询user
* @param uid
* @return
*/
User findByUid(Integer uid);
}
- 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">
<mapper namespace="com.ac.dao.UserDao">
<select id="findByUid" resultType="User" parameterType="Integer">
SELECT * FROM t_user WHERE uid = #{uid}
</select>
</mapper>
2.一对多,多对对的延迟加载
2.1需求
完成加载用户对象时,查询该用户所拥有的账户信息。
等账户信息使用的时候再查询.
-- 1.先把用户查询出来
SELECT * FROM t_user
-- 2. 等使用了该用户的账户的时候再把账户查询出来(user.getAccounts()...)
-- 把查询出来的uid去查询当前用户的账户信息
SELECT * FROM t_account WHERE uid = 1
2.2实现
- Account.java
public class Account {
private Integer aid;
private Integer uid;
private Double money;
}
- User.java
public class User implements Serializable{
private int uid;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
//表达关系:1个用户对应多个账户
private List<Account> accounts;
}
- UserDao.java
public interface UserDao {
/**
* 查询所有的用户对应的账户信息
* @return
*/
List<User> findUserAccountList();
}
- 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">
<mapper namespace="com.ac.dao.UserDao">
<select id="findUserAccountList" resultMap="userListId">
SELECT * FROM t_user
</select>
<resultMap id="userListId" type="user">
<result property="uid" column="uid"/>
<result property="username" column="username"/>
<result property="sex" column="sex"/>
<result property="birthday" column="birthday"/>
<result property="address" column="address"/>
<!--加载多方数据,property属性:一方类里面List集合的属性名; ofType:List中的对象类型-->
<collection property="accounts" ofType="account" select="com.ac.dao.AccountDao.findByUid" column="uid" fetchType="lazy"/>
</resultMap>
</mapper>
- AccountDao.java
public interface AccountDao {
/**
* 根据uid查询当前用户的账户
* @return
*/
List<Account> findByUid(Integer uid);
}
- 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.ac.dao.AccountDao">
<select id="findByUid" resultType="Account" parameterType="Integer" >
SELECT * FROM t_account WHERE uid = #{uid}
</select>
</mapper>
延迟加载需要在配置文件中开启延迟加载设置
<settings>
<!--开启Mybatis的日志-->
<setting name="logImpl" value="STDOUT_LOGGING"></setting>
<!--开启全局延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--
启用按需加载:false,则按需加载,延迟加载
true,每次查询,用不用都全部查询
-->
<setting name="aggressiveLazyLoading" value="false" />
<!--开启缓存-->
<setting name="cacheEnabled" value="true" />
</settings>
9.Mybatis缓存
一级缓存:它是sqlSession对象的缓存,自带的(不需要配置)不可卸载的(不想使用还不行). 一级缓存的生命周期与sqlSession一致。
二级缓存:它是SqlSessionFactory的缓存。只要是同一个SqlSessionFactory创建的SqlSession就解压共享二级缓存的内容,并且可以操作二级缓存。二级缓存如果要使用的话,需要我们自己手动开启(需要配置的)。
1.一级缓存
第一次发起查询用户 id 为 1 的用户信息,先去找缓存中是否有 id 为 1 的用户信息,如果没有,从数据库查询用户信息。得到用户信息,将用户信息存储到一级缓存中。第二次发起查询用户 id 为 1 的用户信息,先去找缓存中是否有 id 为 1 的用户信息,缓存中有,直接从缓存中获取用户信息。
如果 sqlSession 去执行 commit操作(执行插入、更新、删除),清空 SqlSession 中的一级缓存,这样做的目的为了让缓存中存储的是最新的信息,避免脏读。
//证明一级缓存的存在
public void fun01() throws Exception {
SqlSession sqlSession = SqlSessionFactoryUtil.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
User user01 = userDao.findByUid(1);
User user02 = userDao.findByUid(1);
System.out.println(user01 == user02);
sqlSession.close();
}
2.二级缓存
二级缓存是SqlSessionFactory的缓存。只要是同一个SqlSessionFactory创建的SqlSession就共享二级缓存的内容,并且可以操作二级缓存.
1.在 SqlMapConfig.xml 文件开启二级缓存
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
2.配置属性
将 .xml 映射文件中的 <select>
标签中设置 useCache=”true”代表当前这个 statement 要使用二级缓存,如果不使用二级缓存可以设置为 false。
注意: 针对每次查询都需要最新的数据 sql,要设置成 useCache=false,禁用二级缓存。
<?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.ac.dao.AccountDao">
<select id="findByUid" resultType="Account" parameterType="Integer" useCache="true">
SELECT * FROM t_account WHERE uid = #{uid}
</select>
</mapper>
=====================================
以上是自己的一点小总结,有问题可以评论出来,有不足可以指正出来。