MyBatis03:连接池及事务控制、xml动态SQL语句、多表操作
今日内容：
- mybatis中的连接池、事务控制【原理了解，应用会用】
- mybatis中连接池的使用及分析
- mybatis中事务控制的分析
- mybatis中基于xml配置的动态SQL语句使用【会用即可】
- mappers配置文件中的几个标签
- <if>
- <where>
- <foreach>
- <sql>实现代码片段
- mybatis中的多表操作【掌握应用】
- 一对多
- 一对一（？）
- 多对多
一、mybatis的连接池和事务控制
1、连接池的介绍
- 实际开发中都会使用连接池
- 原因：可以减少获取连接所消耗的时间
- 图解
- 分析：
- 连接池就是用于存储连接的容器
- 容器其实就是一个集合对象，只不过该集合是线程安全的，两个线程不能拿到同一个连接
- 该集合还需要实现队列的先进先出特性。
while (conn == null) { //连接为空时创建
synchronized (state) {
if (!state.idleConnections.isEmpty()) {
// Pool has available connection
conn = state.idleConnections.remove(0);2、mybatis连接池的分类
mybatis连接池提供了三种方式的配置
- 配置的位置：
- 主配置文件SqlMapConfig.xml中的dataSource标签，type属性表示采用何种连接池方式
- type的取值：
- POOLED：采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
- UNPOOLED：采用传统的获取连接的方式，虽然也实现了javax.sql.DataSource接口，但是没有使用池的思想--每次使用都获取一个新的连接
- 【扩展】JNDI：采用服务器提供的JNDI技术实现，来获取DataSource对象，不同服务器所能拿到的DataSource不同。
- 注意：如果不是web或者maven的war工程，是不能使用的
- 我们课程中使用的是tomcat服务器，采用的连接池就是dbcp连接池
3、mybatis中使用unpooled配置连接池的原理分析
- POOLED是从池中获取一个连接来用
- UNPOOLED是注册驱动、获取连接
4、mybatis中使用pooled配置连接的原理分析
- 空闲连接池
- 活动连接池
5、mybatis中的事务原理和自动提交设置
- 了解（面试）
- 什么是事务
- 事务的四大特性ACID
- 不考虑隔离性会产生的3个问题
- 解决方法：四种隔离级别
- mybatis的事务
- 通过sqlSession对象的commit方法和rollback方法实现事务的提交和和回滚
- 如何设置为自动提交
@Override
public void saveUser(User user) {
//1.根据factory获取SqlSession对象
SqlSession session = factory.openSession(true);
//2.调用SQLSession中的方法实现查询列表
session.insert("com.itcast.dao.IUserDao.saveUser",user);
//3.提交事务
//session.commit();
//4.关闭
session.close();
}二、mybatis的动态sql语句（mybatis映射文件的sql深入）
与查询相关的查询条件
1、if标签
<!--根据条件查询-->
<select id="findUserByCondition" resultType="com.itcast.domain.User" parameterType="user">
select * from user where 1=1
<if test="username != null">
and username = #{username}
</if>
</select>2、where标签
<!--根据条件查询-->
<select id="findUserByCondition" resultType="com.itcast.domain.User" parameterType="user">
select * from user
<where>
<if test="username != null">
and username = #{username}
</if>
<if test="sex != null">
and sex = #{sex}
</if>
</where>
</select>3、foreach和sql标签
- 举例：select * from user where username in(43,44);
/**
* 根据queryvo中提供的id集合，查询用户集合
* @param vo
* @return
*/
List<User> findByUserInIds(QueryVo vo); <!--根据queryvo中的id集合实现查询用户列表-->
<select id="findByUserInIds" resultType="com.itcast.domain.User">
select * from user where id
<where>
<if test="ids != null and ids.size()>0">
<foreach collection="ids" open="id in(" close=")" item="id" separator=",">
#{id}
</foreach>
</if>
</where>
</select> /**
* 测试foreach
*/
@Test
public void testfindInIds() throws IOException {
QueryVo vo = new QueryVo();
List<Integer> list = new ArrayList<>();
list.add(41);
list.add(42);
list.add(44);
vo.setIds(list);
List<User> users = userDao.findByUserInIds(vo);
for (User user : users) {
System.out.println(user);
}
}抽取代码片段及使用
<sql id="defaultUser">
select * from user
</sql>
<select id="findAll" resultType="com.itcast.domain.User" >
<include refid="defaultUser"></include>
</select>三、mybatis的多表操作
1、mybatis表之间关系分析
- 一对多
- 举例：一个用户可以下多个订单
- 多对一
- 举例：一个班级有多个学生
- 一对一
- 多对多
- 举例：一个学生可以有多个老师，一个老师可以有多个学生
- 特例：拿出每一个订单都只属于一个用户，所以mybatis就把多对一看成一对一
2、完成account表的建立及实现单表查询
- 示例：用户和账户
- 一个用户可以有多个账户
- 一个账户只能属于一个用户（多个账户可以只属于同一个用户）
- 步骤：
- 建立用户表和账户表
- 让用户表和账户表之间具备一对多的关系，需要在账户表中添加外键
- 建立两个实体类：用户实体类和账户实体类
- 让用户和账户的实体类能体现出一对多的关系
- 建立两个配置文件
- 用户的配置文件
- 账户的配置文件
- 实现配置：
- 当查询用户时，可以同时得到用户下所包含的账户信息
- 当查询账户时，可以同时得到账户的所属用户信息
3、完成account一对一操作---一对多（不常用）
<?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.itcast.dao.IAccountDao">
<select id="findAll" resultType="account" >
select * from account
</select>
<!--查询所有账户同时包含用户名和地址信息-->
<select id="findAllAccount" resultType="accountuser" >
SELECT a.*,u.username,u.address FROM account a, USER u WHERE a.uid = u.id
</select>
</mapper><?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="jdbcConfig.properties">
</properties>
<!--使用typeAliases配置别名，只能配置domain中类的别名-->
<typeAliases>
<!--typeAliases配置别名，type指定全限定类名，alias指定别名，指定别名后不再区分大小写-->
<!--<typeAlias type="com.itcast.domain.User" alias="user"></typeAlias>
<typeAlias type="com.itcast.domain.Account" alias="account"></typeAlias>-->
<!--package用于指定要配置别名的包，当指定后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写-->
<package name="com.itcast.domain"></package>
</typeAliases>
<!--配置环境-->
<environments default="mysql">
<!--配置mysql的环境-->
<environment id="mysql">
<!--配置事务-->
<transactionManager type="JDBC"></transactionManager>
<!--配置连接池-->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
<!--配置映射文件的位置-->
<mappers>
<!--<mapper resource="com/itcast/dao/IAccountDao.xml"></mapper>-->
<!--用于指定dao接口所在的包，当指定完成之后就不需要再写mapper、resource或class了-->
<package name="com.itcast.dao"/>
</mappers>
</configuration> /**
* 测试查询所有账户，同时包含用户名称和地址
*/
@Test
public void testFindAllAccount(){
List<AccountUser> aus = accountDao.findAllAccount();
for (AccountUser au : aus) {
System.out.println(au);
}
} @Override
public String toString() {
return super.toString() +
"AccountUser{" +
"username='" + username + '\'' +
", address='" + address + '\'' +
'}';
}4、完成account一对一操作-建立实体类关系的方式
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;
}<?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.itcast.dao.IAccountDao">
<!--定义封装account和user的resultMap-->
<resultMap id="accountUserMap" type="account">
<id property="id" column="aid"></id>
<result property="uid" column="uid"></result>
<result property="money" column="money"></result>
<!--应当建立一对一的关系映射：配置封装user的内容-->
<association property="user" column="uid" javaType="user">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
</association>
</resultMap>
<select id="findAll" resultMap="accountUserMap" >
SELECT u.*,a.id AS aid,a.money,a.uid FROM account a, USER u WHERE a.uid = u.id
</select>
<!--查询所有账户同时包含用户名和地址信息-->
<select id="findAllAccount" resultType="accountuser" >
SELECT a.*,u.username,u.address FROM account a, USER u WHERE a.uid = u.id
</select>
</mapper> /**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<Account> accounts = accountDao.findAll();
for (Account account : accounts) {
System.out.println("-----每个account的信息-----");
System.out.println(account);
System.out.println(account.getUser());
}
}5、完成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">
<mapper namespace="com.itcast.dao.IUserDao">
<!--定义user的resultMap-->
<resultMap id="userAccountMap" type="user">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<!--配置user对象中account集合的映射-->
<collection property="accounts" ofType="account">
<id column="aid" property="id"></id>
<result column="uid" property="uid"></result>
<result column="money" property="money"></result>
</collection>
</resultMap>
<select id="findAll" resultMap="userAccountMap" >
SELECT * FROM USER u LEFT OUTER JOIN account a ON u.id = a.UID
</select>
</mapper> /**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println("-----每个account的信息-----");
System.out.println(user);
System.out.println(user.getAccounts());
}
}public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
//建立一对多关系映射，主表实体应该包含从表实体的集合引用
private List<Account> accounts;
public List<Account> getAccounts() {
return accounts;
}
public void setAccounts(List<Account> accounts) {
this.accounts = accounts;
}6、分析mybatis多对多的步骤并搭建环境
多对多
- 示例：用户和角色（用户的身份）
- 用户可以有多个角色
- 一个角色也可以赋予多个用户
- 步骤：
- 建立用户表和角色表
- 让用户表和角色表之间具备一对多的关系
- 需要使用中间表，中间表中包含各自的主键，在中间表中是外键
- 建立两个实体类：用户实体类和角色实体类
- 让用户和角色的实体类能体现出多对多的关系
- 各自包含对方的集合引用
- 建立两个配置文件
- 用户的配置文件
- 角色的配置文件
- 实现配置：
- 当查询用户时，可以同时得到用户下所包含的角色信息
- 当查询角色时，可以同时得到角色的所赋予的用户信息
7、mybatis多对多准备角色表的实体类和映射配置
public class Role implements Serializable {
private Integer roleId;
private String roleName;
private String roleDesc;package com.itcast.dao;
import com.itcast.domain.Role;
import java.util.List;
public interface IRoleDao {
/**
* 查询所有角色
* @return
*/
List<Role> findAll();
}<?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.itcast.dao.IRoleDao">
<!--定义role表的resultMap-->
<resultMap id="roleMap" type="role">
<id property="roleId" column="id"></id>
<!--windows不区分大小写，linux区分大小写-->
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
</resultMap>
<select id="findAll" resultMap="roleMap">
select * from role
</select>
</mapper>8、mybatis多对多操作-查询角色获取角色下所属用户信息
两次左外连接才能实现功能
public class Role implements Serializable {
private Integer roleId;
private String roleName;
private String roleDesc;
//多对多的关系映射：一个角色可以赋予多个用户
private List<User> users;
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}<mapper namespace="com.itcast.dao.IRoleDao">
<!--定义role表的resultMap-->
<resultMap id="roleMap" type="role">
<id property="roleId" column="id"></id>
<!--windows不区分大小写，linux区分大小写-->
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
<collection property="users" ofType="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="address" property="address"></result>
<result column="sex" property="sex"></result>
<result column="birthday" property="birthday"></result>
</collection>
</resultMap>
<select id="findAll" resultMap="roleMap">
SELECT u.*,r.`ID` rid,r.`ROLE_NAME`,r.`ROLE_DESC` FROM role r
LEFT OUTER JOIN user_role ur ON r.id = ur.`RID`
LEFT OUTER JOIN USER u ON u.id = ur.`UID`
</select>
</mapper> /**
* 测试查询所有
*/
@Test
public void testFindAll(){
List<Role> roles = roleDao.findAll();
for (Role role : roles) {
System.out.println("-----每个角色的信息-----");
System.out.println(role);
System.out.println(role.getUsers());
}
}9、mybatis多对多操作-查询用户获取用户所包含的角色信息
-- 查询角色时查出用户
SELECT * FROM role;
SELECT * FROM USER;
-- 两次左外连接
SELECT u.*,r.`ID` rid,r.`ROLE_NAME`,r.`ROLE_DESC` FROM role r
LEFT OUTER JOIN user_role ur ON r.id = ur.`RID`
LEFT OUTER JOIN USER u ON u.id = ur.`UID`
-- 查询用户对应的角色，并不是所有用户都有角色
SELECT u.*,r.`ID` rid,r.`ROLE_NAME`,r.`ROLE_DESC` FROM USER u
LEFT OUTER JOIN user_role ur ON u.id = ur.`UID`
LEFT OUTER JOIN role r ON r.id = ur.`RID`<?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.itcast.dao.IUserDao">
<!--定义user的resultMap-->
<resultMap id="userAccountMap" type="user">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<!--配置角色集合的映射-->
<collection property="roles" ofType="role">
<id property="roleId" column="rid"></id>
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
</collection>
</resultMap>
<select id="findAll" resultMap="userMap" >
SELECT u.*,r.ID rid,r.ROLE_NAME,r.ROLE_DESC FROM USER u
LEFT OUTER JOIN user_role ur ON u.id = ur.UID
LEFT OUTER JOIN role r ON r.id = ur.RID
</select>
</mapper>public class User implements Serializable {
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
//多对多的关系映射：一个用户可以具备多个角色
private List<Role> roles;
public List<Role> getRoles() {
return roles;
}
public void setRoles(List<Role> roles) {
this.roles = roles;
}四、JNDI
1、JNDI概述和原理
- JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口.
- 是SUN公司推出的一套规范，属于JavaEE技术之一。目的是模仿windows系统中的注册表（搜索-regedit）。
- win的 key存放的为：路径+名称
2、JNDI搭建maven的war工程
3、测试JNDI数据源的使用以及使用细节
- 使用了tomcat的数据源，必须要经过服务器，原先的test方法无法使用
JNDI数据源
JNDI：Java Naming and Directory Interface。是SUN公司推出的一套规范，属于JavaEE技术之一。目的是模仿windows系统中的注册表。
在服务器中注册数据源：
1.1 创建Maven的war工程并导入坐标
<dependencies>
<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.6</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
</dependency>
</dependencies>
1.3 在META-INF目录中建立一个名为context.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<Context>
<!--
<Resource
name="jdbc/eesy_mybatis" 数据源的名称
type="javax.sql.DataSource" 数据源类型
auth="Container" 数据源提供者
maxActive="20" 最大活动数
maxWait="10000" 最大等待时间
maxIdle="5" 最大空闲数
username="root" 用户名
password="1234" 密码
driverClassName="com.mysql.jdbc.Driver" 驱动类
url="jdbc:mysql://localhost:3306/eesy_mybatis" 连接url字符串
/>
-->
<Resource
name="jdbc/eesy_mybatis"
type="javax.sql.DataSource"
auth="Container"
maxActive="20"
maxWait="10000"
maxIdle="5"
username="root"
password="1234"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/eesy_mybatis"
/>
</Context>
<%@ page import="java.io.InputStream" %>
<%@ page import="org.apache.ibatis.io.Resources" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactoryBuilder" %>
<%@ page import="org.apache.ibatis.session.SqlSession" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactory" %>
<%@ page import="com.itcast.dao.IUserDao" %>
<%@ page import="com.itcast.domain.User" %>
<%@ page import="java.util.List" %>
<%@ page language="java" contentType="text/html; utf-8" pageEncoding="utf-8" %>
<html>
<body>
<h2>Hello World!</h2>
<%
//1.读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);
//3.使用工厂生产SqlSession对象
SqlSession sqlSession = factory.openSession();//与jsp的隐式对象session冲突
//4.使用SqlSession创建Dao接口的代理对象
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
//5.使用代理对象执行方法
System.out.println("你好");
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
//6.释放资源
sqlSession.close();
in.close();
%>
</body>
</html>
本文来自博客园，作者：哥们要飞，转载请注明原文链接：https://www.cnblogs.com/liujinhui/p/1619da8f406ec81c4cac09703e890452.html
浙公网安备 33010602011771号