笔记主要来源
https://gitee.com/lagouedu/Basic-document/blob/master/document/MyBatis.md
l 经典三层
web表现层(视图+controller)、service层、dao层
分层的好处
代码清晰、解耦、便于维护,出现问题容易定位
分层开发下的常见框架
dao层:hibernate、mybatis
service层:spring框架(对象容器)
web表现层:springmvc框架
[了解]原生JDBC操作数据库分析
package com.mybatis.dao;
import com.mybatis.pojo.User;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class UserDaoImpl implements UserDao {
private String driver = "com.mysql.jdbc.Driver";
private String url = "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8";
private String username = "root";
private String password = "root";
public List<User> queryUserList() throws Exception {
List<User> userList = new ArrayList<User>();
Class.forName(driver);
/**
* 问题一:频繁获取/释放数据库连接,影响数据库和应用性能
* 解决:数据库连接池技术,C3P0,DRUID(阿里巴巴荣誉出品,号称前无古人后无来者世界最强没有之一)
*/
Connection connection = DriverManager.getConnection(url, username, password);
/**
* 问题二:sql语句硬编码,后期难以维护
* 解决:若sql语句和java代码分离,比如sql写在配置文件中。Mybatis就是这么干的
*/
String sql = "select * from user";
/**
* 问题三:sql语句where条件和占位符一一对应,后期难以维护
*/
// String sql1 = "select * from user where username=? and id=?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
// preparedStatement.setInt(1,2);
ResultSet resultSet = preparedStatement.executeQuery();
User user = null;
/**
* 问题四:结果集解析麻烦,查询列硬编码
* 期望:如果单条记录直接返回实体对象,如果多条记录返回实体的集合
*/
while(resultSet.next()) {
user = new User();
user.setId(resultSet.getInt("id"));
user.setUsername(resultSet.getString("username"));
user.setSex(resultSet.getString("sex"));
user.setBirthday(resultSet.getDate("birthday"));
user.setAddress(resultSet.getString("address"));
userList.add(user);
}
resultSet.close();
preparedStatement.close();
connection.close();
return userList;
}
}
Mybatis框架是一个半自动的ORM持久层框架,也可以在Java中实现类似 insert(User)的操作最终操作数据库,但是需要我们自己写Sql语句。Mybatis是目前比较流行的Dao层框架。
自定义Mybatis框架小结
l 框架的开发使用流程
编写源代码—>打jar包—>框架使用者引入jar包—>按照框架的规范进行XML配置—>Java程序中调用框架API实现功能
l 引入框架坐标即可,它所依赖的dom4j和jaxen都不需要我们引入,这是Maven的依赖传递
l 框架是基础知识的整合(本课程中的jdbc、dom4j、xpath、反射、数据库元数据等)
l 框架往往都会用到设计模式(本课程扩展了工厂设计模式和构建者设计模式)
l 框架展示了代码的拆分思想,各司其职,便于维护
[掌握]Mybatis框架快速入门
l Mybatis入门程序
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
n pojo类User.java
package com.mybatis.pojo;
import java.util.Date;
public class User {
private Integer id;
private String username;
private String sex;
private Date birthday;
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 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 getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
", address='" + address + '\'' +
'}';
}
}
n 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="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="UserMapper.xml"></mapper>
</mappers>
</configuration>
n UserMapper.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test">
<select id="queryUserList" resultType="com.mybatis.pojo.User">
select * from user
</select>
</mapper>
n 测试程序
@Test
public void testMybatis() throws IOException {
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
List<User> list = sqlSession.selectList("test.queryUserList");
if(list != null && list.size() > 0) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
System.out.println(user);
}
}
sqlSession.close();
}
[理解]关于三个对象
l SqlSessionFactoryBuilder: 创建工厂,生命周期短暂即可,类似于一个工具类
l SqlSessionFactory: 应该只有一个工厂对象即可。
l SqlSession: 和数据库通信的会话对象,底层对应connection连接。例如:假如多个线程公用一个sqlsession对象(connection),线程A操作了数据库尚未提交事务,线程B操作了数据库把这个connecttion的事务给提交了,会造成数据安全问题。所以一个线程应该有自己的一个sqlsession对象。
换言之,SqlSession是线程不安全的
[掌握]Mybatis入门级CRUD操作
功能需求:
基于已有数据表user,使用MyBatis实现以下功能:
n 根据用户id查询一个用户
n 根据用户名称模糊查询用户列表
n 添加一个用户
n 根据用户id修改用户名
n 根据用户id删除用户
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<!--mybatis的jar坐标-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--log4j日志组件,要同时把兄弟log4j.properties引入-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
组件:
POJO
SqlMapConfig.xml
新增业务,修改:UserMapper.xml
关联SqlMapConfig和UserMapper
新增业务,修改:Java程序调用(测试程序)
根据用户id查询用户
l UserMapper.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper根标签,映射的意思
namespace:命名空间,分类管理的sql的作用
-->
<mapper namespace="test">
<!--
查询使用select标签
parameterType:传入的参数类型
resultType:封装的结果类型
-->
<select id="queryUserById" parameterType="Integer" resultType="com.mybatis.pojo.User">
<!--
#{}固定取参语法
#{}取参名称:当parameterType传入简单数据类型的时候,取参名称任意,但是建议见名思意,比如是id就#{id}
-->
select * from user where id=#{id}
</select>
</mapper>
l 测试程序
/**
* 测试用例(Use_case):根据id查询用户
*/
@Test
public void testQueryUserById() throws IOException {
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
/*
* 调用会话对象的api完成crud
* param1:锁定sql的唯一标识符
* param2:传入的参数
* */
User user = sqlSession.selectOne("test.queryUserById",1);
System.out.println(user);
sqlSession.close();
inputStream.close();
}
根据用户名模糊查询用户列表
l #{}方式取参
n UserMapper.xml
<!--根据用户名模糊查询用户列表-->
<!--注意:返回多条记录和返回单条记录,resultType配置是一样的-->
<select id="queryUserByUsername" parameterType="String" resultType="com.mybatis.pojo.User">
<!--
#{}底层原理:预编译语句(防止sql注入,性能提高)
#{}对字符串参数自动添加单引号对
-->
select * from user where username like #{username}
</select>
n 测试程序
/**
* 测试用例(Use_case):根据用户名模糊查询用户列表
*/
@Test
public void testQueryUserByUsername() throws IOException {
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
List<User> userList = sqlSession.selectList("test.queryUserByUsername","%王%");
if(userList != null && userList.size() > 0) {
for (int i = 0; i < userList.size(); i++) {
User user = userList.get(i);
System.out.println(user);
}
}
sqlSession.close();
inputStream.close();
}
l ${}方式取参
n UserMapper.xml
<!--
${}:另外一种取参方式
${}取参名称:当parameterType传入简单数据类型的时候,取参名称必须为value字符串
${}原理:简单的字符串,传什么参数拼接什么
不会对字符串参数添加单引号对
-->
<!--
#和$取参使用原则
能用#不用$(从底层原理角度出发说的,#是预编译语句),特殊情况使用$:当你传入的参数是数据库对象(比如表名动态传入),或者是
order by 的那个字段,都不希望自动添加单引号对,所以使用$
-->
<select id="queryUserByUsername$" parameterType="String" resultType="com.mybatis.pojo.User">
select * from user where username like ${value}
</select>
n 测试程序
/** - 测试用例(Use_case):根据用户名模糊查询用户列表$取参形式 */ @Test public void testQueryUserByUsername$() throws IOException { InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml"); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream); SqlSession sqlSession = sqlSessionFactory.openSession(); // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2 List<User> userList = sqlSession.selectList("test.queryUserByUsername$","'%王%'"); if(userList != null && userList.size() > 0) { for (int i = 0; i < userList.size(); i++) { User user = userList.get(i); System.out.println(user); } } sqlSession.close(); inputStream.close(); }
小结
查询部分小结:
l selectOne,当结果集有多条记录的时候,抛出异常;
l #{}和${}使用原则
能使用#不用,特殊情况比如传入的参数是数据库对象(表名)或者order by的字段名时,不希望自动添加单引号对;
l 返回结果集列表的时候,resultType和返回单个对象配置都一样;
实现添加用户(及Mysql自增主键返回)
<!--
#{}和${}取参时,当parameterType为pojo的时候,取参名称为pojo的属性名
-->
<insert id="saveUser" parameterType="com.mybatis.pojo.User">
<!--
selectKey用于查询主键数据
order:selectKey中的sql在insert之前还是之后执行 AFTER/BEFORE
resultType:查询出的主键的类型
keyProperty:查询出的主键数据回显到pojo的哪个属性
-->
<selectKey order="AFTER" resultType="Integer" keyProperty="id">
select last_insert_id()
</selectKey>
insert into user(username,sex,birthday,address)
values(#{username},#{sex},#{birthday},#{address})
</insert>
自增主键返回:其实就是mybaits在执行完insert之后立马查询last_insert_id()
根据用户id修改用户名
<update id="updateUsernameById" parameterType="com.mybatis.pojo.User"> update user set username=#{username} where id=#{id}</update>
根据用户id删除用户
<delete id="deleteUserById" parameterType="Integer"> delete from user where id=#{id}</delete>
Mybatis解决原生JDBC操作数据库存在的问题
1、频繁创建、释放数据库连接造成系统资源浪费,影响系统性能。使用数据库连接池技术可以解决此问题。
解决:在SqlMapConfig.xml中配置数据连接池,使用连接池管理数据库连接。
2、Sql语句写在代码中造成代码不易维护,实际应用中Sql变化的可能较大,Sql变动需要改变java代码。
解决:将Sql语句配置在XXXXmapper.xml文件中与Java代码分离。
3、向Sql语句传参数麻烦,因为Sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应(硬编码)。
解决:Mybatis自动将Java对象映射至Sql语句,通过statement中的parameterType定义输入参数的类型。
4、对结果集解析麻烦(查询列硬编码),Sql变化会导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成Pojo对象解析比较方便。
解决:Mybatis自动将Sql执行结果映射至Java对象,通过statement中的resultType定义输出结果的类型。
[掌握]Mybatis的两种Dao开发方式
使用MyBatis开发DAO的方式实现以下的功能:
n 根据用户id查询一个用户信息
原始Dao开发方式
定义接口(UserDao)
写实现类(UserDaoImpl):在实现类中写crud那套程序
l 定义接口UserDao
package com.mybatis.dao;
import com.mybatis.pojo.User;
/**
* 原始Dao开发方式接口定义
*/
public interface UserDao {
User queryUserById(Integer id) throws Exception;
}
l 写实现类
package com.mybatis.dao;
import com.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
public class UserDaoImpl implements UserDao {
/**
* 声明一个SqlSessionFactory变量,用于接收service层调用dao层时传入的工厂对象
* 因为工厂对象全局唯一,对于全局唯一的对象,在分层的架构中,dao层使用时候应该由
* 外部传入
*/
private SqlSessionFactory sqlSessionFactory;
public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
this.sqlSessionFactory = sqlSessionFactory;
}
@Override
public User queryUserById(Integer id) throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = sqlSession.selectOne("test.queryUserById", id);
sqlSession.close();
return user;
}
}
注意:分层其实是对原有代码的重新组织
l 思考
一个项目当中会有很多表,都对应dao接口和实现类,实现类就是做增删改查这些东西
能否不写实现类只定义接口,让框架帮我们完成实现类的逻辑,那么就是Mapper动态代理的开发方式
Mapper动态代理开发方式
l 定义一个Mapper接口,这个接口其实和我们UserDao接口是一样的
Mapper接口中的接口方法被调用时候,最终要找到这个接口方法所使用的sql语句?那如何找到呢?
遵从下面4个规范即可
l 从Mybatis框架中拿到一个代理对象(代理的是这个Mapper接口),通过代理对象调用接口当中的方法完成业务
n 传统dao开发方式中的实现类其实起了一个连接、承上启下的作用,连接了接口和xml映射文件,效果就是调用接口方法时能够找到xml映射文件
n Mapper动态代理开发遵从的规范
u sql映射文件的namespace必须和mapper接口的全限定类名保持一致
u mapper接口的接口方法名必须和xml中的sql语句id保持一致
u mapper接口的接口方法形参类型必须和sql语句的输入参数类型保持一致
u mapper接口的接口方法返回类型必须和sql语句的resultType保持一致
小结
原始Dao和Mapper动态代理开发在企业中都很常见,推荐使用Mapper动态代理开发模式
[掌握]全局配置文件SqlMapConfig.xml的使用说明
注意:子标签是有顺序要求的,因为使用了dtd校验
properties(属性)
引入外部属性文件
<properties resource="db.properties"><property name="jdbc.username" value="root1"/></properties>
typeAliases(类型别名)
Mybatis默认支持的别名
别名 | 映射的类型 |
---|---|
_byte | byte |
_long | long |
_short | short |
_int | int |
_integer | int |
_double | double |
_float | float |
_boolean | boolean |
string | String |
byte | Byte |
long | Long |
short | Short |
int | Integer |
integer | Integer |
double | Double |
float | Float |
boolean | Boolean |
date | Date |
decimal | BigDecimal |
bigdecimal | BigDecimal |
map | Map |
注意:更多默认别名参见mybatis源码中的TypeAliasRegistry类
自定义别名
<typeAliases><package name="com.mybatis.pojo"/></typeAliases>
mappers(映射器)
引入sql语句的xml配置文件,把sql语句加载到内存当中
l <mapper resource=""/> 万能型选手,基础crud、原始dao开发、mapper动态代理开发都可以使用这种方式
l 针对mapper动态代理开发dao层,我们进行一个增加
mapper class属性:执行mapper接口类的全限定类名
前提要求:
1、编译之后 mapper.xml和mapper.class在同一个目录文件夹中
2、两个文件名称相同
<mapper class="com.mybatis.mapper.UserMapper"/><package name="com.mybatis.mapper"/>
[掌握]Mybatis的输入类型和结果类型
parameterType(输入类型)
l 传递简单类型
参考上面
l 传递Pojo对象
参考上面
l 传递Pojo包装对象
n 需求:使用POJO包装对象,根据用户名模糊查询用户列表
地址:http://epub.sipo.gov.cn/gjcx.jsp
resultType(输出类型)
l 输出简单类型
查询user表总记录数
l 输出Pojo对象
参考上面
l 输出Pojo列表
参考上面
resultMap(手动映射)
l 订单表POJO类
package com.mybatis.pojo;
import java.util.Date;
public class Orders {
// 订单id
private int id;
// 用户id
private Integer userId;
// 订单号
private String number;
// 订单创建时间
private Date createtime;
// 备注
private String note;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public Date getCreatetime() {
return createtime;
}
public void setCreatetime(Date createtime) {
this.createtime = createtime;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note;
}
@Override
public String toString() {
return "Orders{" +
"id=" + id +
", userId=" + userId +
", number='" + number + '\'' +
", createtime=" + createtime +
", note='" + note + '\'' +
'}';
}
}
n OrdersMapper.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.mybatis.mapper.OrdersMapper">
<!--
resultType:自动映射,要求查询列名和pojo属性名保持一致
1 最终封装的对象
2 查询列名和pojo属性名一致
当不一致的时候,要使用手动映射
resultMap:配置手动映射
-->
<select id="queryOrdersAllList" resultMap="ordersResultMap">
select * from orders
</select>
<resultMap id="ordersResultMap" type="orders">
<!--手动配置映射关系-->
<!--
主键字段不一致的时候使用<id>标签配置
普通字段不一致的时候使用<result>标签配置
property严格区分大小写,要和pojo属性名称一致
-->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</resultMap>
</mapper>
工程准备
新建一个Maven类型的module:实现Mybatis第二天的保存用户功能,便于基于该功能的代码程序说明Mybatis数据库连接池和Mybatis事务控制。
[理解]Mybatis连接池和事务控制
Mybatis连接池
l POOLED使用连接池
n 什么时候从连接池获取连接
getMapper的时候还是真正调用api操作数据库的时候?
从连接池获取连接的时机:真正操作数据库调用api的时候,不是getMapper的时候
l 其他
n UNPOOLED:不使用数据库连接池(一般不使用)
n JNDI:(前提你的Mybatis环境必须是Web应用)(了解)
u 什么是JNDI
JNDI:java naming directory interface(java命名目录接口),它是一种该服务发布技术,可以通过JNDI技术把数据源发布成一个服务,那么客户端可以调用这个服务
u 为什么必须是web应用
因为支持JNDI技术的往往是tomcat/weblogic/websphere这些中间件才支持JNDI技术
u 如果在Mybatis当中用,怎么用
参考附录
Mybatis事务控制
type="JDBC":使用Jdbc的事务管理机制,connection的事务
Mybatis默认把Jdbc的事务自动提交给关闭了
注意:考虑提交的数据量较小的时候使用自动提交,如果数据量大影响了操作数据库的性能,那么考虑分批次手动控制事务的提交
type="MANAGED":什么都不做,交给其他框架管理事务
[掌握]Mybatis映射文件的Sql深入(即动态Sql)
更优雅更方便的帮助我们拼接sql语句。
根据用户性别和用户名称查询用户列表
if标签/where标签
sql片段
引用sql片段使用include标签,refid指向sql片段的id,如果共享其他mapper文件当中的sql片段,只需要refid前面加上另外一个mapper映射文件的namespace即可
foreach标签
delete from user where id in(1,2,3)
String sql = "delete from user where id in("
for(String s: list) {
sql += s + ","
}
substring
sql += ")"
需求:根据多个id来查询用户列表
select * from user where id in(1,2,3)
l 形式一:直接传入list集合给mybatis
l 形式二:直接传入数组给Mybatis
Mybatis底层别名定义类
<!--
foreach直接传入Array数组
-->
<select id="queryUserByIdsArray" parameterType="int[]" resultType="user">
select id,username,sex,birthday,address from user
<!--
foreach:遍历拼接sql语句
collection:遍历的集合,注意当直接传数组,除了知道是数组外没有别的名字,所以collection固定配置为array
open:遍历拼接前干点啥(拼接点什么字符串)
close:遍历结束后干点啥(拼接点什么字符串)
separator:遍历拼接时候使用的分隔符
item:遍历到的具体元素值,等同于下面for循环中的s
for(String s : list) {
s
}
-->
<foreach collection="array" open=" where id in(" close=")" separator="," item="item">
#{item}
</foreach>
</select>
l 形式三:传入一个pojo,pojo中有list或者数组
<!-- foreach直接传入pojo,pojo中封装list或者数组 --><select id="queryUserByIdsQueryVo" parameterType="queryvo" resultType="user"> select id,username,sex,birthday,address from user<!-- foreach:遍历拼接sql语句 collection:遍历的集合,当传入pojo的时候,collection配置为pojo当中集合的属性名 如果不指定具体属性名,那么mybatis是不知道要取pojo哪个属性的 open:遍历拼接前干点啥(拼接点什么字符串) close:遍历结束后干点啥(拼接点什么字符串) separator:遍历拼接时候使用的分隔符 item:遍历到的具体元素值,等同于下面for循环中的s for(String s : list) { s } --> <foreach collection="idsList" open=" where id in(" close=")" separator="," item="item"> #{item} </foreach> </select>
[掌握]Mybatis的多表关联查询
多表:至少2张表
多表关系分析技巧:从一条记录出发,比如分析A表和B表的关系,就看A表的一条记录可以对应B表中几条记录,如果对应一条,从A到B表就是一对一的关系,如果对应多条就是一对多的关系。
多对多其实是双向的一对多
l 一对一
从订单表出发到用户表,一条订单记录只会对应用户表的一条记录,一对一
l 一对多
从用户表出发到订单表,一个用户记录可以对应订单表的多条记录,一对多
(通过主外键,一的一方是主表,多的一方是从表,外键在从表多的那一方)
l 多对多
用户和角色,一个用户可以有多个角色,一个角色也可以对应多个用户
通过中间表表达两个表之间的关系
a表 b表
id field.. id field..
中间表(往往两个字段即可)
aid bid
多表关联的SQL语句表达分析
l Sql语句表达
n 笛卡尔积
u SELECT * FROM USER,orders
SELECT * FROM USER u,orders o WHERE u.id=o.user_id(笛卡尔积进一步筛选)
n 关联查询
u 内关联 innder join on(和笛卡尔积进一步筛选效果一样)
SELECT * FROM USER u INNER JOIN orders o ON u.id=o.user_id
u 外连接(outer join on)(使用较多)
左外连接(left join) left join左边的表是基础表
SELECT * FROM USER u LEFT JOIN orders o ON u.id=o.user_id
右外连接(right join) right join右边的表是基础表
SELECT * FROM USER u RIGHT JOIN orders o ON u.id=o.user_id
l 内关联和外关联分析
一对一查询
Mybatis帮我们做的事情:
1、 SQL语句是用户自己写,Mybatis框架只是帮我们执行而已
2、 封装结果集
需求:查询订单表全部数据,关联查询出订单对应的用户数据(username address)
l Mapper映射文件
<select id="queryOrdersUser" resultMap="ordersUserResultMap">
SELECT
o.`id`,
o.`user_id`,
o.`number`,
o.`createtime`,
o.`note`,
u.`username`,
u.`address`
FROM
orders o
LEFT JOIN USER u
ON o.`user_id` = u.`id`
</select>
<resultMap id="ordersUserResultMap" type="orders">
<!--两部分数据:订单+用户-->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!--association:关联的意思,用于一对一关联封装数据
property:一对一关联后封装成的数据所对应的属性名
javaType:属性的类型
-->
<association property="user" javaType="user">
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<result column="address" property="address"/>
</association>
</resultMap>
l 测试程序
@Test
public void testQueryOrdersUser() {
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
List<Orders> ordersList = ordersMapper.queryOrdersUser();
if(ordersList != null && ordersList.size() > 0) {
for (int i = 0; i < ordersList.size(); i++) {
Orders orders = ordersList.get(i);
System.out.println(orders);
}
}
sqlSession.close();
}
一对多查询
需求:查询全部用户数据,关联查询出订单数据
l Mapper映射文件
<!--一对多用例-->
<select id="queryUserOrders" resultMap="userOrdersResultmap">
SELECT
u.`id`,
u.`username`,
u.`sex`,
u.`birthday`,
u.`address`,
o.`id` oid,
o.`user_id`,
o.`number`,
o.`createtime`,
o.`note`
FROM
USER u
LEFT JOIN orders o
ON u.`id` = o.`user_id`
</select>
<resultMap id="userOrdersResultmap" type="user">
<!--两部分数据:用户+订单-->
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>
<!--一对多使用collection标签
property:封装成对应的属性的属性名
ofType:因为此时属性是一个list集合,collection已经表明了集合的意思,最重要的指定list里面的泛型类型,
所以使用ofType
-->
<collection property="ordersList" ofType="orders">
<id column="oid" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</collection>
</resultMap>
多对多查询
多对多关系分析
多对多是双向的一对多
实现Role到User的一对多
l Mapper映射文件
<select id="queryRoleUsers" resultMap="roleUsersResultMap">
SELECT
r.rid,
r.rname,
r.rdesc,
u.`username`,
u.`address`
FROM
role r
LEFT JOIN user_role ur
ON r.`RID` = ur.`RID`
LEFT JOIN USER u
ON ur.`UID` = u.`id`
</select>
<!-- 多对多拆分成双向的一对多-->
<resultMap id="roleUsersResultMap" type="role">
<id column="rid" property="rid"/>
<result column="rname" property="rname"/>
<result column="rdesc" property="rdesc"/>
<collection property="userList" ofType="user">
<result column="username" property="username"/>
<result column="address" property="address"/>
</collection>
</resultMap>
实现User到Role的一对多
[了解]扩展知识
Tomcat配置JNDI数据源(了解)
l 第一步:将数据库驱动程序(jar包)放到tomcat安装目录下的common\lib文件夹下
l 第二步:在Tomcat的conf/context.xml文件中进行jndi数据源服务配置
name:在JNDI中叫做目录名,等同于服务名,此处的jndi/mybatis是自定义的,往往以/连接前后字符串即可。
auth和type是固定的,其他都是数据库连接池的具体配置信息
l 第三步:在自己web项目的web.xml中引用Jndi数据源服务
l 第四步:在自己web项目的Mybatis配置文件中使用
配置data_source属性,指向你的数据源引用,java:comp/env/jndi/mybatis中红色部分是固定的,绿色部分是你自己定义的目录名(服务名)
工程准备
使用Mapper动态代理的方式实现:
l 根据用户id查询用户
l 查询全部订单数据并关联查询出用户数据(一对一)
l 查询全部用户数据并关联查询出订单数据(一对多)
便于基于代码程序讲解Mybatis延迟加载和缓存。
[掌握]Mybatis延迟加载策略
关联对象:数据库层次用户和订单是关联表,在对象层次订单对象和用户对象就叫做关联对象
什么是延迟加载?
在使用关联对象的过程中
比如使用了Orders对象,但是我只是获取Orders的订单数据尚未获取user的数据,但是依然查询了user表(这不是延迟)
我orders.getNumber()你不要查user表的数据,当我orders.getUser()你再去查user表
关联查询的关联对象,在较多的场合中并不需要的时候,只在少部分场合需要关联的那个对象数据,可以考虑使用延迟加载
Mybatis中怎么实现延迟加载?
步骤1:原来关联sql语句要拆分
1) 第一条sql查询基础表
2) 第二条sql根据基础表的条件查询关联表
步骤2:让两条sql自动产生联系,通过<association column="" select=""/> 或者<collection column="" select =""/>
l 全局延迟加载开关配置(一对一和一对多都需要开启)
<setting name="lazyLoadingEnabled" value="true" /><setting name="aggressiveLazyLoading" value="false" /><setting name="lazyLoadTriggerMethods" value="true" />
l 一对一关联查询的延迟加载
<select id="queryOrdersWithUser" resultMap="ordersUserResultMap">
SELECT
o.`id`,
o.`user_id`,
o.`number`,
o.`createtime`,
o.`note`
FROM
orders o
</select>
<!--
延迟加载分析
1、原来关联查询的sql语句必然要拆分,如果不拆分,那肯定要执行关联查询,两个表用不用都要查
2、sql=sql1+sql2拆分之后,要让这两个sql自动产生联系
sql1:select id,user_id,number,createtime,note from orders
sql2:select * from user u where id=user_id
-->
<resultMap id="ordersUserResultMap" type="orders">
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<association property="user" javaType="user" column="user_id" select="com.mybatis.mapper.UserMapper.queryUserByUserId">
</association>
</resultMap>
<select id="queryUserByUserId" parameterType="int" resultType="user">
select id,username,sex,birthday,address from user where id=#{user_id}
</select>
l 一对多关联查询的延迟加载
<select id="queryUserWithOrders" resultMap="userOrdersResultMap">
SELECT
u.`id`,
u.`username`,
u.`sex`,
u.`birthday`,
u.`address`
FROM
USER u
</select>
<resultMap id="userOrdersResultMap" type="user">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>
<collection property="ordersList" ofType="orders" column="id" select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserId">
</collection>
</resultMap>
<!--拆分的第二条sql语句-->
<select id="queryOrdersByUserId" parameterType="int" resultType="orders">
select o.id,o.user_id,o.number,o.createtime,o.note from orders o where o.user_id=#{id}
</select>
[了解]Mybatis缓存
Mybatis的一级缓存
Mybatis的一级缓存是SqlSession级别的缓存,是默认开启的
注意:以下情形缓存会失效(被清理掉):
n sqlSession关闭
n sqlSession提交事务:意味着可能是一个增删改的动作,数据表数据产生变化,那么这个时候Mybatis就会把这个sqlSession已有的一级缓存给清理掉
Mybatis的二级缓存
l Mybatis二级缓存机制
l 怎么用Mybatis的二级缓存
n 开启二级缓存开关
第一个开关:需要在SqlMapConfig.xml中开启二级缓存总开关
第二个开关:需要在使用二级缓存的mapper.xml中开启(因为二级缓存是mapper级别的)
n Pojo实现序列化
ratio:命中率的意思,两次都去查询了二级缓存,但是第一次的时候缓存中没有数据,所以没有命中,第二次查询的时候缓存中已经有数据了,所以命中率是0.5
l Mybatis二级缓存的清理时机:当这个mapper.xml中执行了非select语句的时候,整个Mapper的缓存全部清除掉。
注意:避免使用二级缓存,因为二级缓存带来的好处远远比不上他所隐藏的危害
n 如果你针对user表的sql操作并不是全部都在UserMapper.xml中,使用缓存的结果可能会不正确。
n 多表操作一定不能使用缓存
为什么不能?
首先不管多表操作写到那个Mapper.xml下,都会存在某个表不在这个Mapper下的情况。
例如两个表:role和user_role,如果我想查询出某个用户的全部角色role,就一定会涉及到多表的操作
<select id="selectUserRoles" resultType="UserRoleVO">
select * from user_role a,role b where a.roleid = b.roleid and a.userid = #{userid}
</select>
像上面这个查询,你会写到那个xml中呢??
不管是写到RoleMapper.xml还是UserRoleMapper.xml,或者是一个独立的XxxMapper.xml中。如果使用了二级缓存,都会导致上面这个查询结果可能不正确。
如果你正好修改了这个用户的角色,上面这个查询使用缓存的时候结果就是错的。
[掌握]Mybatis的注解开发
效果:没有写sql语句的xml了
l 基础的crud(基础crud怎么使用注解)
l 关联查询延迟加载(怎么使用注解完成)
l 动态sql的注解方式
原则:把原来xml里面的内容都对应的放到注解上即可
注解开发不需要引入额外的jar包,和原来一致即可
注解添加在接口类的方法上
使用注解实现基本的CRUD
@Insert("insert into user(username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})")
/*回显mysql自增主键id
等同于原来我们xml中使用<selectKey/>,一一对应过来即可
* */
@SelectKey(statement = "select last_insert_id()",before = false,keyProperty = "id",resultType = Integer.class)
void saveUser(User user);
@Update("update user set username=#{username} where id=#{id}")
void updateUsernameById(User user);
@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);
@Select("select id,username,sex,birthday,address from user where id=#{id}")
User queryUserById(Integer id);
@Select("select id,username,sex,birthday,address from user")
List<User> queryUserList();
@Select("<script>select id,username,sex,birthday,address from user" +
"<where>" +
"<if test=\"sex != null and sex != ''\">" +
" and sex=#{sex}" +
"</if>" +
"<if test=\"username != null and username != ''\">" +
" and username like #{username}" +
"</if>" +
"</where></script>")
List<User> queryUserByWhere(User user);
@Select("<script>select id,username,sex,birthday,address from user" +
"<foreach collection=\"list\" open=\" where id in(\" close=\")\" separator=\",\" item=\"item\">" +
"#{item}" +
"</foreach></script>")
List<User> queryUserByIdsList(List<Integer> ids);
使用注解实现复杂关系映射开发
使用注解实现一对一查询
/*
* 对应关系
* @Results对应xml中的resultMap
* @Result对应xml中的id/result
* id:true/false,是否是主键,默认false
* column:查询列名
* property:pojo属性名
* association:在注解中使用@Result+one=@One的方式去表达
* fetchType:延迟加载类型,默认是延迟加载,eager:积极加载
* */
@Results({
@Result(id = true,column = "id",property = "id"),
@Result(column = "user_id",property = "userId"),
@Result(column = "number",property = "number"),
@Result(column = "createtime",property = "createtime"),
@Result(column = "note",property = "note"),
@Result(property = "user",column = "user_id",javaType = User.class,one=@One(select = "com.mybatis.mapper.UserMapper.queryUserByUserid",fetchType = FetchType.LAZY))
})
List<Orders> queryOrdersUser();
@Select("select id,username,sex,birthday,address from user where id=#{user_id}")
User queryUserByUserid(Integer id);
使用注解实现一对多查询
l mapper接口
/*
* 对应关系
* @Results对应xml中的resultMap
* @Result对应xml中的id/result
* id:true/false,是否是主键,默认false
* column:查询列名
* property:pojo属性名
* collection:在注解中使用@Result+many=@Many的方式去表达
* xml中的ofType在注解中使用 javaType表达=List.class
* fetchType:延迟加载类型,默认是延迟加载,eager:积极加载
* */
@Select("select id,username,sex,birthday,address from user")
@Results({
@Result(id = true,column = "id",property = "id"),
@Result(column = "username",property = "username"),
@Result(column="sex",property="sex"),
@Result(column="birthday",property="birthday"),
@Result(column="address",property="address"),
@Result( property="ordersList",javaType = List.class,column="id",
many = @Many(select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserid",fetchType = FetchType.LAZY))
})
List<User> queryUserOrders();
@Select("select id,number from orders where user_id=#{userId}")
List<Orders> queryOrdersByUserid(Integer userId);
网友评论