Mybatis 学习笔记
1、什么是Mybatis
1.1、什么是MyBatis
MyBatis 是一款优秀的持久层框架
它支持自定义 SQL、存储过程以及高级映射
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
现迁移到GitHub
1.2、如何获得Mybatis
Maven仓库:https://mvnrepository.com/
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>
GitHub:https://github.com/mybatis/mybatis-3
官方文档:https://mybatis.org/mybatis-3/zh/index.html
1.3、持久化
1.3.1、数据持久化
- 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
- 内存:断电即失
- 数据库(jdbc),io文件持久化
- 生活结合:冰箱冷藏
1.3.2、为什么需要持久化?
- 有一些对象,不能让他丢掉
- 内存太贵
1.4、持久层
- Dao层,Service层,Controller层…
- 完成持久化工作的代码块
- 层是界限十分明显的
1.5、为什么需要MyBatis
-
帮助程序员将数据存入到数据库中
-
方便
-
传统的jdbc代码太复杂了,简化代码,形成框架。----自动化
-
不使用MyBatis也可以,更容易上手
优点: -
简单易学:本身就很小且简单。没有任何第三方依赖,最简单安装只要两个jar文件+配置几个sql映射文件。易于学习,易于使用。通过文档和源代码,可以比较完全的掌握它的设计思路和实现。
-
灵活:mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里,便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
-
解除sql与程序代码的耦合:通过提供DAO层,将业务逻辑和数据访问逻辑分离,使系统的设计更清晰,更易维护,更易单元测试。sql和代码的分离,提高了可维护性。
-
提供映射标签,支持对象与数据库的orm字段关系映射。
-
提供对象关系映射标签,支持对象关系组建维护。
-
提供xml标签,支持编写动态sql。
2、第一个Mybatis程序
思路:搭建环境—>导入Mybatis—>编写代码---->测试
2.1 搭建环境
2.1.1、创建数据库
create database 'mybatis';
use 'mybatis';
create table 'user' {
'id' int(20) not null primary key,
'name' varchar(30) default null,
'pwd' varchar(30) default null
}engine=innodb default charset=utf-8
insert into 'user' ('id', 'name', 'pwd') values
(1001, '狂神', '123'),
(1002, 'Java', '111'),
(1003, 'PPP', '122')
2.1.2 新建一个普通的maven项目
导入maven依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 父工程 -->
<groupId>com.kuang</groupId>
<artifactId>mybatis-study</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 导入依赖 -->
<dependencies>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
<!-- mybatis -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>
2.2 创建一个模块
2.2.1 普通的maven模块
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uV3ZQTtD-1664800617496)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800012105.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5eMxWHJt-1664800617497)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800027865.png)]
2.2.2 编写mybatis的核心配置文件
【connection to@localhost failed 解决办法】
<?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?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 每一个Mapper.xml都需要在MyBatis核心配置文件中注册-->
<mappers>
<mapper resource="com/qjd/dao/UserMapper.xml"/>
</mappers>
</configuration>
2.2.3 编写mybatis的工具类
package com.kuang.utils;
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 java.io.IOException;
import java.io.InputStream;
//SqlSessionFactory
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
try {
//使用mybatis获取sqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
// 既然有了 SqlSessionFactory,顾名思义,我们可以从中获得 SqlSession 的实例。
// SqlSession 提供了在数据库执行 SQL 命令所需的所有方法
public static SqlSession getSqlSession() {
return sqlSessionFactory.openSession();
}
}
2.3 编写代码
2.3.1 实体类
package com.kuang.poji;
public class User {
private int id;
private String name;
private String pwd;
public User() {}
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
2.3.2 Dao接口
package com.kuang.dao;
import com.kuang.poji.User;
import java.util.List;
public interface UserDao {
List<User> getUserList();
}
2.3.3 接口实现类
接口实现类由原来的UserDaolmpl转变为Mapper配置文件
<?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.qjd.dao.UserDao">
<!-- select查询语句,ID对应方法名 -->
<!-- ★★★ resultType 、 resultMap -->
<select id="getUserList" resultType="com.kuang.pojo.User">
<!-- 执行 sql -->
select * from mybatis.user
</select>
</mapper>
2.4 测试
package com.kuang.dao;
import com.kuang.poji.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void test() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
//方式一getMapper
UserDao mapper = sqlSession.getMapper(UserDao.class);
List<User> userList = mapper.getUserList();
//方式二
//List<User> userList1 = sqlSession.selectList("com.qjd.dao.UserDao.getUserList");
for (User user : userList) {
System.out.println(user);
}
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
}
注意问题
- 配置文件没有注册
- 绑定接口错误
- 方法名不对
- 返回类型不对
- maven导出资源问题
由于将 xxx.xml文件放在了java目录,而不是 resource目录下,出现资源配置问题:
解决方案,在 pom.xml 中加入:手动配置资源过滤
<!-- 在build中配置resources , 来防止我们资源导出失败的问题-->
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
**错误:**java.io.IOException: Could not find resource mybatis-config.xml
修改方法
将根模块下的pom.xml文件中的
<packaging>pom</packaging>
修改为
<packaging>jar</packaging>
或者 注释了
<!--<packaging>pom</packaging>-->
3、增删改查实现 CRUD
3.1 namespace
namespace中的包名要和接口中的包名一致—uesrDao–>userMapper
<mapper namespace="com.kuang.dao.UserMapper">
3.2 select
选择查询语句:
- id:就是对应的namespace中的方法名;
- resultType:就是Sql语句执行的返回值;
- parameterType:就是参数类型;
3.3 Insert
3.4 update
3.5 delete
package com.kuang.dao;
import com.kuang.pojo.User;
import java.util.List;
public interface UserMapper {
// 查询全部用户
List<User> getUserList();
// 根据 id查询用户
User getUserById(int id);
// 添加用户
int addUser(User user);
// 修改用户
int updateUser(User user);
// 删除用户
int deleteUser(int id);
}
<?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.kuang.dao.UserMapper">
<!-- select查询语句,id 对应方法名 -->
<!-- ★★★ resultType 、 resultMap -->
<select id="getUserList" resultType="com.kuang.pojo.User">
select * from mybatis.user
</select>
<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
select * from mybatis.user where id = #{id}
</select>
<insert id="addUser" parameterType="com.kuang.pojo.User">
insert into mybatis.user (id, name, pwd) values (#{id}, #{name}, #{pwd});
</insert>
<update id="updateUser" parameterType="com.kuang.pojo.User">
update mybatis.user set name = #{name} , pwd = #{pwd} where id = #{id}
</update>
<delete id="deleteUser" parameterType="com.kuang.pojo.User">
delete from mybatis.user where id = #{id};
</delete>
</mapper>
测试代码
package com.kuang.dao;
import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserMapperTest {
@Test
public void testSelectAll() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
//方式一getMapper
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
//方式二
//List<User> userList1 = sqlSession.selectList("com.qjd.dao.UserMapper.getUserList");
for (User user : userList) {
System.out.println(user);
}
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
@Test
public void getUserByIdTest() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User userById = mapper.getUserById(101);
System.out.println(userById);
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
// 【增删改】 需要提交事务
@Test
public void addUserTest() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int num = mapper.addUser(new User(1001, "wahahah", "wahha"));
if(num > 0) {
System.out.println("添加成功");
}
// 提交事务
sqlSession.commit();
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
@Test
public void updateUserTest() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int num = mapper.updateUser(new User(1001, "wahahah", "hehehe"));
if(num > 0) {
System.out.println("修改成功");
}
// 提交事务
sqlSession.commit();
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
@Test
public void deleteUserTest() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int num = mapper.deleteUser(1001);
if(num > 0) {
System.out.println("删除成功");
}
// 提交事务
sqlSession.commit();
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
}
// 提交事务
sqlSession.commit();
3.6 常见错误
【注意】增删改必须提交事务
- 标签不要匹配错 select、update……
- resource绑定mapper,需要使用路径
- 程序配置文件必须符合规范
- 空指针异常,没有注册到资源
- target输出xml文件中存在中文乱码问题
- maven资源没有导出问题
3.7 万能的map方法
假设我们的实体类,或者数据库中的表,字段或者参数过多,我们应当考虑使用Map!
//万能的map
int addUser2(Map<String,Object> map);
<insert id="addUser2" parameterType="map">
<!-- 传递map的key -->
insert into mybatis.user (id, name, pwd) values (#{userid},#{userName},#{passWord});
</insert>
@Test public void addUser2Test (){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("userid",5);
map.put("userName","hello");
map.put("passWord","976543");
mapper.addUser2(map);
sqlSession.commit();
sqlSession.close();
}
- Map传递参数,直接在sql中取出key即可! 【parameterType = ‘map’】
- 对象传递参数,直接在sql中去对象的属性即可! 【parameterType = ‘Object’】
- 只有一个基本类型参数的情况下,可以直接在sql中取到!
- 多个参数用Map,或者注解
3.8 模糊查询
java代码执行的时候,传递通配符%%
List<User> userList = mapper.getUserLike("李%");
在sql拼接中使用通配符(存在sql注入问题)
4、配置解析
4.1 核心配置文件
mybatis-config.xml
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下:
- configuration(配置)
- properties(属性)
- settings(设置)
- typeAliases(类型别名)
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- environments(环境配置)
- environment(环境变量)
- transactionManager(事务管理器)
- dataSource(数据源)
- environment(环境变量)
- databaseIdProvider(数据库厂商标识)
- mappers(映射器)
新建一个 mybatis-02 模块:
- 在 src/main/resources 路径下建立 mybatis-config.xml 文件
- 在 src/main/java/com/qjd/utils 路径下编写工具类 MybatisUtils.java 读取配置文件获取sqlsessionfactory
- 在 src/main/java/com/qjd/pojo 路径下编写实体类 User.java
- 在 src/main/java/com/qjd/dao 路径下编写接口 UserMapper.java 和UserMapper.xml
- 编写测试类
4.2 环境配置(environments)
- MyBatis 可以配置成适应多种环境
- 不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
<environments default = "development">
<!--环境 -->
<environment id = "development">
<!--环境信息 -->
</environment>
<environment id = "test">
<!--环境信息 -->
</environment>
</environments>
- 数据源的配置(比如:type=“POOLED”)
- 学会配置多套运行环境-----更改id
- Mybatis默认的事务管理器就是JDBC,连接池:POOLED
4.3 属性(Properties)
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<!-- 转义: & 等价于 & -->
<!--<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8"/>-->
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置【db.properties】
编写一个配置文件db.properties:
driver=com.mysql.cj.jdbc.Driver
#url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT
username=root
#password=123456
在核心配置文件中引入:
<!--核心配置文件-->
<configuration>
<!-- 引入外部配置文件 -->
<properties resource="db.properties">
<property name="password" value="123456"/>
</properties>
<!-- 环境配置 -->
<environments default="development">
<!--环境 -->
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<!-- 每一个Mapper.xml都需要在MyBatis核心配置文件中注册-->
<mappers>
<mapper resource="com/yxy/dao/UserMapper.xml"/>
</mappers>
</configuration>
【注意事项】
- 可以直接引入外部文件;
- 可以在其中增加一些属性配置;
- 如果两个文件有同一个字段,优先使用外部配置文件的;
4.4 typeAliases(类型别名)
- 类型别名可为 Java 类型设置一个缩写名字。
- 它仅用于 XML 配置,意在降低冗余的全限定类名书写
方法一:
<!-- 别名设置 -->
<typeAliases>
<typeAlias type="com.yxy.pojo.User" alias="User"></typeAlias>
</typeAliases>
方法二
可以指定一个包名,MyBatis会在包名下搜索需要的Java Bean,
比如:扫描实体类的包,它的默认别名就为这个类的类名,首字母小写
<typeAliases>
<typeAlias type="com.yxy.pojo.User" alias="User"></typeAlias>
<package name="com.yxy.pojo"/>
</typeAliases>
<select id="getUserList" resultType="user">
select * from mybatis.user
</select>
在实体类比较少的时候,使用第一种方式;
如果实体类十分多,建议使用第二种(在实体类中使用注解可以起别名)
@Alias("author")
public class Author {
...
}
下面是一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的,注意,为了应对原始类型的命名重复,采取了特殊的命名风格。
别名 | 映射的类型 |
---|---|
_byte | byte |
_char (since 3.5.10) | char |
_long | long |
_short | short |
_int | int |
_integer | int |
_double | double |
_float | float |
_boolean | boolean |
string | String |
byte | Byte |
char (since 3.5.10) | Character |
character (since 3.5.10) | Character |
long | Long |
short | Short |
int | Integer |
integer | Integer |
double | Double |
float | Float |
boolean | Boolean |
date | Date |
decimal | BigDecimal |
bigdecimal | BigDecimal |
biginteger | BigInteger |
object | Object |
date[] | Date[] |
decimal[] | BigDecimal[] |
bigdecimal[] | BigDecimal[] |
biginteger[] | BigInteger[] |
object[] | Object[] |
map | Map |
hashmap | HashMap |
list | List |
arraylist | ArrayList |
collection | Collection |
iterator | Iterator |
4.5 设置(settings)
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。
设置名 | 描述 | 有效值 | 默认值 |
---|---|---|---|
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false | true |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 | true | false | false |
aggressiveLazyLoading | 开启时,任一方法的调用都会加载该对象的所有延迟加载属性。 否则,每个延迟加载属性会按需加载(参考 lazyLoadTriggerMethods)。 | true | false | false (在 3.4.1 及之前的版本中默认为 true) |
multipleResultSetsEnabled | 是否允许单个语句返回多结果集(需要数据库驱动支持)。 | true | false | true |
useColumnLabel | 使用列标签代替列名。实际表现依赖于数据库驱动,具体可参考数据库驱动的相关文档,或通过对比测试来观察。 | true | false | true |
…………
一个配置完整的 settings 元素的示例如下:
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="true"/>
<setting name="multipleResultSetsEnabled" value="true"/>
<setting name="useColumnLabel" value="true"/>
<setting name="useGeneratedKeys" value="false"/>
<setting name="autoMappingBehavior" value="PARTIAL"/>
<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
<setting name="defaultExecutorType" value="SIMPLE"/>
<setting name="defaultStatementTimeout" value="25"/>
<setting name="defaultFetchSize" value="100"/>
<setting name="safeRowBoundsEnabled" value="false"/>
<setting name="safeResultHandlerEnabled" value="true"/>
<setting name="mapUnderscoreToCamelCase" value="false"/>
<setting name="localCacheScope" value="SESSION"/>
<setting name="jdbcTypeForNull" value="OTHER"/>
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
<setting name="defaultScriptingLanguage" value="org.apache.ibatis.scripting.xmltags.XMLLanguageDriver"/>
<setting name="defaultEnumTypeHandler" value="org.apache.ibatis.type.EnumTypeHandler"/>
<setting name="callSettersOnNulls" value="false"/>
<setting name="returnInstanceForEmptyRow" value="false"/>
<setting name="logPrefix" value="exampleLogPreFix_"/>
<setting name="logImpl" value="SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING"/>
<setting name="proxyFactory" value="CGLIB | JAVASSIST"/>
<setting name="vfsImpl" value="org.mybatis.example.YourselfVfsImpl"/>
<setting name="useActualParamName" value="true"/>
<setting name="configurationFactory" value="org.mybatis.example.ConfigurationFactory"/>
</settings>
4.6 其它配置(了解即可)
4.7 映射器(mappers)
MapperRegistry:注册绑定我们的Mapper文件,每写一个dao层就要写一个Mapper文件。
既然 MyBatis 的行为已经由上述元素配置完了,我们现在就要来定义 SQL 映射语句了。 但首先,我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面,Java 并没有提供一个很好的解决方案,所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用,或完全限定资源定位符(包括 file:///
形式的 URL),或类名和包名等。例如:
方式一:建议使用
<!-- 使用相对于类路径的资源引用 -->
<mappers>
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
<mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
方式二:使用class文件绑定注册
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
注意:
- 接口和他的Mapper配置文件必须同名
- 接口和他的Mapper配置文件必须在同一个包下
方式三:使用扫描包进行注入
<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
<package name="org.mybatis.builder"/>
</mappers>
注意同方式二
练习:
- 将数据库配置文件外部引入
- 实体类别名
- 保证UserMapper接口和UserMapper.xml名称一致,且放在同一个包下
4.8 生命周期和作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ee8v4PJZ-1664800617499)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800229452.png)]
不同作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder:
-
一旦创建了 SqlSessionFactory,就不再需要SqlSessionFactoryBuilder了;
-
局部变量;
SqlSessionFactory: -
可以理解为数据库连接池;
-
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例;
-
SqlSessionFactory 的最佳作用域是应用作用域,最简单的就是使用单例模式or静态单例模式;
SqlSession: -
连接到连接池的一个请求;
-
SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求or方法作用域;
-
用完之后需要赶紧关闭,否则资源被占用;
这里每一个Mapper就代表一个具体的业务;
5、解决属性名和字段名不一致的问题
5.1 问题
数据库中的字段
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bvEGBkES-1664800617500)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800278805.png)]
新建一个项目,拷贝之前的,测试实体类字段不一样的情况;
public class User {
private int id;
private String name;
private String password;
}
导致的问题: password 为 null
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j5v37uKt-1664800617500)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800299673.png)]
问题原因:
select * from mybatis.user where id =#{id}
select id, name, pwd from mybatis.user where id =#{id}
//此时已经没有pwd
【解决方法】
- 起别名
<select id="getUserById" parameterType="int" resultType="com.yxy.pojo.User">
select id,name,pwd as password from mybatis.user where id =#{id}
</select>
- resultMap
5.2 resultMap
结果集映射
id name pwd
id name password
<!-- 结果集映射-->
<resultMap id="UserMap" type="User">
<!-- column数据库中的字段,properties实体类中的属性-->
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" parameterType="int" resultMap="UserMap">
select * from mybatis.user where id = #{id}
</select>
resultMap
元素是 MyBatis 中最重要最强大的元素- ResultMap 的设计思想是,对简单的语句做到零配置,对于复杂一点的语句,只需要描述语句之间的关系就行了
5.3 回顾步骤
新建一个mybatis-04模块:
- 在src/main/resources路径下建立mybatis-config.xml文件建立核心配置文件
- 在src/main/java/com/qjd/utils路径下编写工具类MybatisUtils.java读取配置文件获取sqlsessionfactory
- 在src/main/java/com/qjd/pojo路径下编写实体类User.java
- 在src/main/java/com/qjd/dao路径下编写接口UserMapper.java和UserMapper.xml
- 编写测试类
6、日志
6.1 日志工厂
如果一个数据库操作出现了异常,我们需要排错,日志就是最好的助手;
之前: sout,debug ;
现在:日志工厂;
- SLF4J
- LOG4J(3.5.9 起废弃) -----掌握
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING —掌握
- NO_LOGGING
在Mybatis中具体使用哪一个日志实现,在设置中设定;
STDOUT_LOGGING —标准日志输出;
在mybatis核心配置文件中,配置我们的日志;
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oliu6VJX-1664800617502)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800365323.png)]
6.2 log4j
什么是log4j
- Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
- 我们也可以控制每一条日志的输出格式
- 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程
- 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码
1、导入 log4j 依赖
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
2、log4j.properties :
### 配置根 ###
log4j.rootLogger = debug,console,file
### 配置输出到控制台 ###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold = debug
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{1}:%L - %m%n
### 配置输出到文件 ###
log4j.appender.file = org.apache.log4j.FileAppender
log4j.appender.file.File = ./log/yxy.log
log4j.appender.file.Append = true
log4j.appender.file.Threshold = debug
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
### 配置输出到文件,并且每天都创建一个文件 ###
log4j.appender.dailyRollingFile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyRollingFile.File = logs/log.log
log4j.appender.dailyRollingFile.Append = true
log4j.appender.dailyRollingFile.Threshold = debug
log4j.appender.dailyRollingFile.layout = org.apache.log4j.PatternLayout
log4j.appender.dailyRollingFile.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
### 设置输出sql的级别,其中logger后面的内容全部为jar包中所包含的包名 ###
log4j.logger.org.mybatis=debug
log4j.logger.java.sql=debug
log4j.logger.java.sql.Connection=debug
log4j.logger.java.sql.Statement=debug
log4j.logger.java.sql.PreparedStatement=debug
log4j.logger.java.sql.ResultSet=debug
3、配置log4j为日志的实现
<settings>
<!--<setting name="logImpl" value="STDOUT_LOGGING"/>-->
<setting name="logImpl" value="LOG4J"/>
</settings>
4、Log4j的使用,直接运行刚才的测试
简单使用
- 在要使用Log4j的类中,导入包import org.apache.log4j.Logger;
- 日志对象,参数为当前类的class
import org.apache.log4j.Logger;
static Logger logger = Logger.getLogger(UserMapperTest.class);
- 日志级别
logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");
7、分页
思考:为什么要分页?
- 减少数据的处理量
7.1 使用 Limit 分页
SELECT * FROM user limit startIndex,pageSize;
SELECT * FROM user limit 0,2;
SELECT * FROM user limit 3;#[0,n]
使用Mybatis实现分页,核心就是sql
1、接口
// 分页
List<User> getUserByList(Map<String, Integer> map);
2、Mapper.xml
<!-- resultMap 元素是 MyBatis 中最重要最强大的元素 -->
<resultMap id="UserMap" type="User">
<!-- column : 数据库中的字段 -->
<!-- property: 实体类中的属性 -->
<result column="pwd" property="password"></result>
</resultMap>
<!-- 分页查询 -->
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
select * from mybatis.user limit #{startIndex}, #{pageSize}
</select>
3、测试
@Test
public void getUserByLimitTest() {
//第一步:获得SqlSession对象
// 在 jdbc 中是获取 prepareStatement 对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
try{
//执行sql
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("startIndex", 0);
map.put("pageSize", 2);
List<User> userList = mapper.getUserByLimit(map);
for (User user : userList) {
System.out.println(user);
}
}
catch (Exception e){
e.printStackTrace();
}
finally {
//关闭SqlSession
sqlSession.close();
}
}
7.2 RowBounds 分页
1、接口
//分页2
List<User> getUserByRowBounds();
2、Mapper.xml
<!-- 分页2-->
<select id="getUserByRowBounds" resultMap="UserMap">
select * from mybatis.user
</select>
3、测试
@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(1, 2);
//通过java代码层面实现分页
List<User> userList = sqlSession.selectList("com.qjd.dao.UserMapper.getUserByRowBounds",null,rowBounds);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
7.3 分页插件
MyBatis 分页插件 PageHelper
如何使用----https://pagehelper.github.io/docs/howtouse/
8、使用注解开发
8.1 面向接口编程
8.1.1 、概念
1.什么是面向接口编程
面向接口编程就是先把客户的业务逻辑线提取出来,作为接口,业务具体实现通过该接口的实现类来完成。
当客户需求变化时,只需编写该业务逻辑的新的实现类,通过更改配置文件(例如Spring框架)中该接口
的实现类就可以完成需求,不需要改写现有代码,减少对系统的影响。
复制代码
2.面向接口编程的优点
1 降低程序的耦合性。其能够最大限度的解耦,所谓解耦既是解耦合的意思,它和耦合相对。耦合就是联系
,耦合越强,联系越紧密。在程序中紧密的联系并不是一件好的事情,因为两种事物之间联系越紧密,你更换
其中之一的难度就越大,扩展功能和debug的难度也就越大。
2 易于程序的扩展;
3 有利于程序的维护;
复制代码
3.接口编程在设计模式中的体现:开闭原则
其遵循的思想是:对扩展开放,对修改关闭。其恰恰就是遵循的是使用接口来实现。在使用面向接口的编程过程
中,将具体逻辑与实现分开,减少了各个类之间的相互依赖,当各个类变化时,不需要对已经编写的系统进行
改动,添加新的实现类就可以了,不在担心新改动的类对系统的其他模块造成影响。
复制代码
8.1.2、设计模式
面向过程编程
面向对象编程
面向接口编程
1、面向过程编程
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
面向过程是一种以过程为中心的编程思想。面向过程是一种最为实际的思考方式,就算是面向对象的方法也有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际的实现。一般面向过程是从上往下步步求精,所以面向过程最重要的是模块化的思想方法。
2、面向对象编程
面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。
对象:对象是要研究的任何事物。比如人类就是一个对象,然而对象是有属性和方法的,那么身高、体重、年龄、性别等等,这些是每个人都有的特征可以概括为属性。
类:类是对象的模板。即类是对一组有相同属性和相同操作的对象的定义,一个类所包含的方法和数据描述一组对象的共同属性和行为。类是在对象之上的抽象,对象则是类的具体化,是类的实例。
2.2.1 面向对象的基本特征 封装、继承、多态、抽象
封装:就是把属性私有化,提供公共方法访问私有对象。
继承:当多个类具有相同的特征(属性)和行为(方法)时,可以将相同的部分抽取出来放到一个类中作为父类,其他类继承于这个父类。继承后的子类自动拥有了父类的属性和方法,比如猫、狗、猪他们共同的特征都是动物、都会跑会叫等特征。
但是需要注意的是,父类的私有属性(private)和构造方法不能被继承。另外子类可以写自己特有的属性和方法,目的是实现功能的扩展,子类也可以重写父类的方法。
多态:简单来说就是“一种定义,多种实现”。同一类事物表现出多种形态。JAVA语言中有方法重载和对象多态两种形式的多态。
方法重载:在一个类中,允许多个方法使用同一个名字,但是方法的参数不同,完成的功能也不同
对象多态:子类对象可以与父类对象进行相互转换,而且根据其使用的子类的不同,完成的功能也不同
复制代码
3、面向接口编程
什么叫面向接口编程
在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
2.3.1 关于接口的理解。
接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
接口的本身反映了系统设计人员对系统的抽象理解。
接口应有两类:
第一类是对一个体的抽象,它可对应为一个抽象体(abstract class);
第二类是对一个体某一方面的抽象,即形成一个抽象面(interface);
复制代码
一个体有可能有多个抽象面。
抽象体与抽象面是有区别的。
面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法;
面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现;
接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题;
8.2 使用注解开发
1、接口
// 查询全部用户
@Select("select * from user")
List<User> getUsers();
2、Mapper.xml
<!-- 绑定接口 -->
<mappers>
<mapper class="com.yxy.dao.UserMapper"></mapper>
</mappers>
3、测试
@Test
public void getUsersTest() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.getUsers();
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
本质:反射机制实现
底层:动态代理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7QNGHf9O-1664800617503)(C:\Users\10374\AppData\Roaming\Typora\typora-user-images\1664800433884.png)]
8.3 Mybatis 详细执行流程
概要步骤:
- 在src/main/resources路径下建立mybatis-config.xml文件建立核心配置文件
- 在src/main/java/com/qjd/utils路径下编写工具类MybatisUtils.java读取配置文件获取sqlsessionfactory
- 在src/main/java/com/qjd/pojo路径下编写实体类User.java
- 在src/main/java/com/qjd/dao路径下编写接口UserMapper.java和UserMapper.xml
- 编写测试类
8.4 CRUD
我们可以在工具类创建的时候实现自动提交事务
1、工具类 (自动提交事务)
public static SqlSession getSqlSession() {
return sqlSessionFactory.openSession(true);
}
2、接口
public interface UserMapper {
// 查询全部用户
@Select("select * from user")
List<User> getUsers();
// 有多个参数时,必须加 @Param 注解
@Select("select * from user where id = #{id}")
User getUserById(@Param("id") int id);
@Insert("insert into user(id, name, pwd) values (#{id}, #{name}, #{password})")
int addUser(User user);
@Update("update user set name = #{name}, pwd = #{password} where id = #{id}")
int updateUser(User user);
@Delete("delete from user where id = #{uid}")
int deleteUser(@Param("uid") int id);
}
8.5 关于 @Param(“”)注解
- 基本类型的参数或者String需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话,可以忽略,但是建议大家都加上
- 我们在sql中引用的就是我们这里的@Param(“”)中设定的属性名
8.6 #{} 和 ${}
#{}
是预编译处理,$ {}
是字符串替换 ;- mybatis在处理两个字符时,处理的方式也是不同的:
- 处理
#{}
时,会将sql中的#{}
整体替换为占位符(即:?),调用PreparedStatement 的set方法来赋值; - 在处理
$ { }
时,就是把${ }
替换成变量的值。
- 处理
- 假如用
${}
来编写SQL会出现:恶意SQL注入,对于数据库的数据安全性就没办法保证了 ; - 使用
#{}
可以有效的防止SQL注入,提高系统安全性。
预编译的机制。预编译是提前对SQL语句进行预编译,而后再调用SQL,注入的参数就不会再进行SQL编译。而SQL注入是发生在编译的过程中,因为恶意注入了某些特殊字符,最后被编译时SQL时轻而易举的通过,从而导致数据泄露。而预编译机制则可以很好的防止SQL注入。
9、Lombok
Lombok项目是一个Java库,他是一个插件,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。
使用步骤:
- 在IDEA中安装Lombok插件
- 在项目中导入Lombok的jar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
- 在实体类上加注解即可
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String password;
}
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
【说明】
@Data: 无参构造,get, set, toString,hashcode,equals
@AllArgsConstructor
@NoArgsConstructor
@Getter and @Setter
@ToString
10、多对一处理
基本概念
多对一:
- 多个学生对应一个老师
- 对于学生而言,关联···多个学生关联一个老师【多对一】
- 对于老师而言,集合···一个老师有很多学生【一对多】
结果映射(resultMap)
association
– 一个复杂类型的关联;许多结果将包装成这种类型
嵌套结果映射 – 关联可以是 resultMap
元素,或是对其它结果映射的引用
collection
– 一个复杂类型的集合
嵌套结果映射 – 集合可以是 resultMap
元素,或是对其它结果映射的引用
10.1 测试环境搭建
SQL
新建学生表和教师表
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');
1、在pom.xml导入lombok(不需要自己添加构造方法等-----用@Data)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>mybatis-study</artifactId>
<groupId>com.kuang</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>mybatis-06</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
</dependencies>
</project>
2、在pojo包下新建实体类Teacher,Student
@Data
public class Student {
private int id;
private String name;
// 学生需要关联一个老师
private Teacher teacher;
}
@Data
public class Teacher {
private int id;
private String name;
}
3、建立Mapper接口
public interface StudentMapper {
}
public interface TeacherMapper {
@Select("select * from teacher where id = #{tid}")
Teacher getTeacher(@Param("tid") int id);
}
4、建立Mapper.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--核心配置文件-->
<mapper namespace="com.yxy.dao.StudentMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--核心配置文件-->
<mapper namespace="com.yxy.dao.TeacherMapper">
</mapper>
5、在核心配置文件中绑定注册我们的Mapper接口或者文件【有很多方式】
<!-- 绑定接口 -->
<mappers>
<!--<mapper class="com.yxy.dao.UserMapper"></mapper>-->
<!--<mapper class="com.yxy.dao.TeacherMapper"></mapper>-->
<mapper resource="com/yxy/dao/TeacherMapper.xml"></mapper>
<mapper resource="com/yxy/dao/StudentMapper.xml"></mapper>
</mappers>
6、测试查询是否能够成功
10.2 按照查询嵌套处理
select s.id ,s.name ,t.name from student s,teacher t where s.tid=t.id
<mapper namespace="com.yxy.dao.StudentMapper">
<!--
1. 查询所有学生的信息
2. 根据查出来学生的id,寻找对应的 teacher 信息
-->
<select id="getStudent" resultMap="Student_Teacher">
select * from student;
</select>
<resultMap id="Student_Teacher" type="com.yxy.pojo.Student">
<result property="id" column="id"></result>
<result property="name" column="name"></result>
<!--
对于复杂的属性,需要单独处理,如当前 Teacher
对象: association
集合: collection
-->
<association property="teacher" column="tid" javaType="com.yxy.pojo.Teacher" select="getTeacher"></association>
</resultMap>
<select id="getTeacher" resultType="com.yxy.pojo.Teacher">
select * from teacher where id = #{id}
</select>
</mapper>
10.3 按照结果嵌套处理
<mapper namespace="com.yxy.dao.StudentMapper">
<!-- 按照结果嵌套处理 -->
<select id="getStudent2" resultMap="Student_Teacher2">
select s.id sid, s.name sname, t.name tname
from mybatis.student s, mybatis.teacher t
where s.tid=t.id;
</select>
<resultMap id="Student_Teacher2" type="com.yxy.pojo.Student">
<!-- 注意 column 名字与 查询语句相对应 如:sid-->
<result property="id" column="sid"></result>
<result property="name" column="sname"></result>
<association property="teacher" javaType="com.yxy.pojo.Teacher">
<result property="name" column="tname"></result>
</association>
</resultMap>
</mapper>
11、一对多处理
比如:一个老师教多个学生,对于老师而言,就是一对多的关系
11.1 测试环境搭建
实体类变动
@Data
public class Teacher {
private int id;
private String name;
//一个老师拥有多个学生
private List<Student> students;
}
@Data
public class Student {
private int id;
private String name;
private int tid;
}
11.2 按照结果嵌套处理
<select id="getTeachersList" resultType="com.yxy.pojo.Teacher">
select * from mybatis.teacher;
</select>
<select id="getTeacher" resultMap="Teacher_Student">
select s.id sid, s.name sname, t.name tname, t.id tid
from mybatis.teacher t, mybatis.student s
where s.tid = t.id and t.id = #{tid};
</select>
<resultMap id="Teacher_Student" type="com.yxy.pojo.Teacher">
<result property="id" column="tid"></result>
<result property="name" column="tname"></result>
<!--
对于复杂的属性,需要单独处理,如当前 Teacher
对象: association
集合: collection
javaType 是指定的属性类型
集合中的泛型信息,使用ofType获取
-->
<collection property="students" ofType="com.yxy.pojo.Student">
<result property="id" column="sid"></result>
<result property="name" column="sname"></result>
<result property="tid" column="tid"></result>
</collection>
</resultMap>
11.3 按照查询嵌套处理
<select id="getTeacher2" resultMap="Teacher_Student2">
select * from mybatis.teacher where id = #{tid};
</select>
<resultMap id="Teacher_Student2" type="com.yxy.pojo.Teacher">
<collection property="students" javaType="ArrayList" ofType="com.yxy.pojo.Student" select="getStudentByTid" column="id"/>
</resultMap>
<select id="getStudentByTid" resultType="com.yxy.pojo.Student">
select * from mybatis.student where tid = #{tid};
</select>
11.4 小结
- 关联-association【多对一】
- 集合-collection【一对多】
- javaType & ofType
- javaType用来指定实体类中属性的类型
- ofType 用来指定映射到List或者集合中的pojo类型,泛型中的约束类型
注意点:
- 保证SQL的可读性,尽量保证通俗易懂
- 注意一对多和多对一中,属性名和字段的问题
- 如果问题不好排查错误,可以使用日志,建议使用log4j
12、动态SQL
基本概念
什么是动态SQL:动态SQL就是根据不同的条件生成不同的SQL语句。
使用动态 SQL 并非一件易事,但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言,MyBatis 显著地提升了这一特性的易用性。
如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器,你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中,需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式,MyBatis 3 替换了之前的大部分元素,大大精简了元素种类,现在要学习的元素种类比原来的一半还要少。
- if
- choose (when, otherwise)
- trim (where, set)
- foreach
12.1 搭建环境
CREATE TABLE `blog`(
`id` VARCHAR(50) NOT NULL COMMENT '博客id',
`title` VARCHAR(100) NOT NULL COMMENT '博客标题',
`author` VARCHAR(30) NOT NULL COMMENT '博客作者',
`create_time` DATETIME NOT NULL COMMENT '创建时间',
`views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8
创建一个基础工程
- 导包
- 编写配置文件
- 编写实体类
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
}
- 编写实体类对应的Mapper接口和Mapper.xml文件
- 测试
【拓展】
private Date createTime; // 属性名和字段名不一致
驼峰命名映射 create_time ==> createTime
<settings>
<!-- 标准日志工厂 -->
<setting name="logImpl" value="STDOUT_LOGGING"/>
<!-- 是否开启驼峰命名规则映射-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
12.2 if
// 查询 Blog
List<Blog> queryBlogs(Map map);
<select id="queryBlogs" parameterType="map" resultType="com.yxy.pojo.Blog">
select * from mybatis.blog where 1= 1
<if test="title != null">
and title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</select>
12.3 choose、when、otherwise
List<Blog> queryBlogChoose(Map map);
与之前 where 1=1 对比
<select id="queryBlogs" parameterType="map" resultType="com.yxy.pojo.Blog">
select * from mybatis.blog
<where>
<if test="title != null">
title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</where>
</select>
【相当于 switch-case 结构】
<select id="queryBlogChoose" parameterType="map" resultType="blog">
select * from mybatis.blog
<where> <!-- where 标签 -->
<choose>
<when test="title !=null">
title = #{title}
</when>
<when test="author !=null">
and author = #{author}
</when>
<otherwise>
and views = #{views}
</otherwise>
</choose>
</where>
</select>
12.4 trim、where、set
where:where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除.
// 更新 blog
int updateBlog(Map map);
set:set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号(这些逗号是在使用条件语句给列赋值时引入的)
<update id="updateBlog" parameterType="map">
update mybatis.blog
<set>
<if test="title != null">
title = #{title},
</if>
<if test="author != null">
author = #{author}
</if>
</set>
where id = #{id}
</update>
trim:
where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。
如果 where 元素与你期望的不太一样,你也可以通过自定义 trim 元素来定制 where 元素的功能。比如,和 where 元素等价的自定义 trim 元素为:
<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
</trim>
prefixOverrides 属性会忽略通过管道符分隔的文本序列(注意此例中的空格是必要的)。上述例子会移除所有 prefixOverrides 属性中指定的内容,并且插入 prefix 属性中指定的内容。
所谓动态SQL,本质还是SQL语句,只是我们可以在SQL层面去执行一个逻辑代码
if where set choose when
12.5 SQL片段
将一些功能的部分抽取出来,方便复用。
1、使用sql标签抽取公共部分
<sql id="if-title-author">
<if test="title != null">
and title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</sql>
2、在需要使用的地方使用include标签引用即可
<select id="queryBlogs" parameterType="map" resultType="com.yxy.pojo.Blog">
select * from mybatis.blog
<where>
<include refid="if-title-author"></include>
</where>
</select>
注意事项:
- 最好基于单表来定义sql片段
- 不要在片段中存在where标签
12.6 foreach
select *from user where 1=1 and
<foreach item="id" collection="ids"
open="(" separator="or" close=")" >
id=#{id}
(id=1 or id=2 or id=3)
动态 SQL 的另一个常见使用场景是对集合进行遍历(尤其是在构建 IN 条件语句的时候)。比如:
<select id="selectPostIn" resultType="domain.blog.Post">
SELECT *
FROM POST P
<where>
<foreach item="item" index="index" collection="list"
open="ID in (" separator="," close=")" nullable="true">
#{item}
</foreach>
</where>
</select>
代码
// 查询 第 1,2,3 号记录的Blog
List<Blog> queryBlogForeach(Map map);
<select id="queryBlogForeach" parameterType="map" resultType="com.yxy.pojo.Blog">
select * from mybatis.blog
<where>
<foreach collection="ids" item="id" open="and (" close=")" separator="or">
id = #{id}
</foreach>
</where>
</select>
@Test
public void queryBlogForeachTest() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap hashMap = new HashMap();
ArrayList<Integer> ids_list = new ArrayList<Integer>();
hashMap.put("ids", ids_list);
ids_list.add(1);
ids_list.add(2);
List<Blog> blogs = mapper.queryBlogForeach(hashMap);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
小结:
动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
建议:
- 先在Mysql中写出完整的SQL再对应去修改成为我们的动态SQL实现通用即可
- Mysql重点掌握的知识
- Mysql引擎
- InnoDB底层原理
- 索引
- 索引优化
13、缓存
13.1 简介
13.1.1、什么是缓存【Cache】
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用了从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题
13.1.2、为什么使用缓存?
- 减少和数据库的交互次数,减少系统开销,提高系统效率
13.1.3、什么样的数据能使用缓存?
- 经常查询而且不经常改变的数据
13.2 Mybatis 缓存
- MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
- MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启。(SqlSession级别的缓存,也称为本地缓存)
- 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
- 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
13.3 一级缓存
- 一级缓存也叫本地缓存:
- 与数据库同一次会话期间查询到的数据会放在本地缓存中。
- 以后如果需要获取相同的数据,直接从缓存中拿,没必须再去查询数据库;
测试步骤
- 开启日志
- 测试在Session中查询两次相同的记录
public class MyTest {
@Test
public void getUserByIdTest() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user1 = mapper.getUserById(101);
System.out.println(user1);
User user2 = mapper.getUserById(102);
System.out.println(user2);
sqlSession.close();
}
}
- 查看日志输出
缓存失效
1.查询不同的东西;
2,增删改操作,可能会改变原来的数据,所以必定会刷新缓存!
3.查询不同的Mapper.xml
4.手动清理缓存!
小结:一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段(相当于一个用户不断查询相同的数据,比如不断刷新),一级缓存就是一个map
13.4 二级缓存
- 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存
- 基于namespace级别的缓存,一个名称空间,对应一个二级缓存:
- 工作机制
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中:
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存中的数据被保存到二级缓存中;
- 新的会话查询信息,就可以从二级缓存中获取内容:
- 不同的mapperi查出的数据会放在自己对应的缓存(map)中;
13.4.1 步骤
1.开启全局缓存(settings)
<!-- 显示的开启全局缓存 -->
<setting name="cacheEnable" value="true"/>
2.在要使用二级缓存的Mapper中开启
可以不加参数,也可以自定义参数。
<!-- 在当前 Mapper.xml 中使用二级缓存 -->
<cache eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
<!--
这个更高级的配置创建了一个 FIFO 缓存,每隔 60 秒刷新,
最多可以存储结果对象或列表的 512 个引用,
而且返回的对象被认为是只读的,
因此对它们进行修改可能会在不同线程中的调用者产生冲突。
-->
可用的清除策略有:
LRU
– 最近最少使用:移除最长时间不被使用的对象。FIFO
– 先进先出:按对象进入缓存的顺序来移除它们。SOFT
– 软引用:基于垃圾回收器状态和软引用规则移除对象。WEAK
– 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
3.测试
@Test
public void getUserByIdTest() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
SqlSession sqlSession2 = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user1 = mapper.getUserById(101);
System.out.println(user1);
sqlSession.close();
UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
User user2 = mapper2.getUserById(101);
System.out.println(user2);
sqlSession2.close();
}
可以看到只运行一次sql
问题:
- 我们需要将实体类序列化(实现Serializable接口),否则就会报错
- sqlsession关闭的时候一定要在最后关闭,不能先关闭sqlsession再关闭sqlsession2,这样会导致Cause: org.apache.ibatis.executor.ExecutorException: Executor was closed
4.小结
只要开启了二级缓存,在同一个Mapper下就有效
所有的数据都会先放在一级缓存中
只有当会话提交,或者关闭的时候才会提交到二级缓存中
13.5 缓存原理
缓存顺序:
- 先看二级缓存中有没有
- 再看一级缓存中有没有
- 查询数据库
注:一二级缓存都没有,查询数据库,查询后将数据放入一级缓存。
13.6 自定义缓存-ehcache
介绍:
- EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider
- Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存
要在程序中使用ehcache,先要导包
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.1.0</version>
</dependency>
在mapper中指定使用我们的ehcache缓存实现
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
关于缓存的内容了解就可以,以后开发我们会用Redis数据库来做缓存!