SSM框架:MyBatis
SSM框架:MyBatis
文章目录
- 前言
- 一、简介
- 1. 什么是MyBatis
- 如何获得Mybatis?
- 2. 持久化
- 3. 持久层
- 4. 为什么需要MyBatis
- 二、第一个MyBatis程序
- 1. 搭建环境
- 1、搭建数据库
- mysql 8.0 sql文件转至 5.7
- 2、新建项目
- 1、新建一个普通的maven项目
- 2、删除src目录
- 3、导入maven依赖
- 2、创建一个模块
- 1、编写mybatis的核心配置文件
- 2、编写mybatis的工具类
- 3、编写代码
- 1、实体类
- 2、Dao接口
- 3、接口实现类
- 4、测试
- junit测试
- 小总结
- 三、CRUD
- 1. 增删改查实现
- 1、namespace
- 2、select
- 3、insert
- 4、update
- 5、delete
- 6、代码实现
- 1、编写接口
- 2、编写接口对应的mapper.xml中的sql语句(核心)
- 3、编写测试方法
- 2. 分析错误 错误排查
- 3. Map和模糊查询拓展
- 1、万能的Map
- 1、UserMapper接口
- 2、UserMapper.xml
- 3、UserMapperTest
- 4、好处
- 5、自己写的代码
- 4、模糊查询怎么写
- mybatis模糊查询防止sql注入的方法:
- 四、配置解析
- 1. 配置之属性优化
- 1、核心配置文件
- 1、查看官网手册
- 2、项目准备
- 2、环境配置(environments)
- 3、属性(properties)
- 2. 配置之别名优化
- 1、类型别名(typeAliases)
- 2、设置(settings)
- 3. 配置之映射器(简单)说明
- 1、其他配置
- 2、mappers(映射器)
- 4. 生命周期和作用域
- 5. ResultMap结果集映射
- 1、解决属性名和字段名不一致的问题
- 2、ResultMap
- 六、日志
- 1、日志工厂
- 2、Log4j讲解
- 七、分页
- 1. 使用Limit实现分页
- 2. RowBounds分页
- 3. 分页插件
- 八、使用注解开发
- 1. 面向接口编程
- 2. 使用注解开发
- 探寻注解是如何实现开发的
- Mybatis执行流程剖析
- 3. 注解增删改查 CRUD
- 1、设置自动提交事务
- 2、编写接口,增加注解
- 3、测试类
- 九、Lombok的使用
- 1.在IDEA中安装Lombok插件
- 2.在项目中导入lombok的jar包
- 3、在实体类上加注解即可
- 十、复杂查询
- 1. 复杂查询环境搭建
- 1、数据库SQL
- 2、自写mapper.xml 文件
- 3、在核心配置文件注册mapper
- 4、测试环境搭建
- 2. 多对一的处理
- 方式一、按照查询嵌套处理
- 方式二、按照结果嵌套处理
- 回顾Mysql多对一查询方式:
- 3. 一对多的处理
- 1、环境搭建
- 2、一对多的处理
- 1、按照结果嵌套查询
- 2、按照查询嵌套处理
- 小结
- 十一、动态SQL
- 1. 动态SQL环境搭建
- 1、什么是动态SQL:
- 2、搭建环境
- 2. 动态SQL常用标签
- 1. IF
- 2. choose(when,otherwise)
- 3. trim(where,set)
- 1. where-if
- 2. set-if
- 3. trim
- 4. SQL片段
- 5. Foreach
- 测试
- 6. bind
- 小总结
- 十二、缓存(了解即可)
- 1. 缓存简介
- 1、简介
- 2、Mybatis缓存
- 2. 一级缓存
- 代码
- 3. 二级缓存
- 4. Mybatis缓存原理
- 5. 自定义缓存Ehcache
- 练习:29道练习题实战
- Mybatis总结
- 聊聊Spring
前言
- 环境
- JDK 1.8
- Mysql 5.7
- maven 3.6.1
- IDEA
- 回顾:
- Java基础(JavaSE)
- Mysql(SQLyog)
- JDBC
- Maven
- Junit(JvaWeb Servlet Test)
SSM框架:配置文件的。最好的方式:看官网文档
官网中文手册:https://mybatis.net.cn/
https://mybatis.org/mybatis-3/
一、简介
1. 什么是MyBatis
- MyBatis 是一款优秀的持久层框架;
- 它支持定制化 SQL、存储过程以及高级映射。
- MyBatis 避免了几乎所有的 JDBC 代码以及手动设置参数和获取结果集的工作。
- MyBatis 可以通过简单的 XML 或 注解 来配置和映射原始类型、接口和 Java 的 POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
- MyBatis本是apache的一个开源项目iBatis,2010年这个项目由apache software foundation迁移到了google code,并且改名为MyBatis。
- 2013年11月迁移到Github。
如何获得Mybatis?
- maven仓库:https://mvnrepository.com/
- Github下载地址:https://github.com/mybatis/mybatis-3/releases
- Github中文文档:https://mybatis.org/mybatis-3/
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.11</version>
</dependency>
2. 持久化
- 数据持久化
- 持久化就是将程序的数据在 持久状态 和 瞬时状态 转化的过程
- 内存:断电即失的特性
- 数据库(Jdbc),io文件持久化。
- 例如,生活中的冷藏品、罐头…
- 为什么需要持久化?
- 有一些对象
- 不能让他丢掉
- 内存太贵了
真正的力量在时间手里, 留下脚印比创造世界更难。
留下记忆,对数据进行长期存储,成为了文明延续的必要条件。
3. 持久层
Dao层、Service层、Controller层
- 完成持久化工作的代码块
- 层界限十分明显
4. 为什么需要MyBatis
- 帮助程序员将数据存入到数据库中
- 方便
- 传统的JDBC代码太复杂了.简化、框架、自动化
- 不用MyBatis也可以。Mybatis更容易上手。技术没有高低之分
- 优点:
- 简单易学
- 灵活
- sql和代码的分离,提高了可维护性
- 提供映射标签,支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签,支持对象关系组建维护
- 提供xml标签,支持编写动态sql
最重要的一点:使用的人多!
Spring SpringMVC SpringBoot
二、第一个MyBatis程序
思路:搭建环境 --> 导入Mybatis --> 编写代码 --> 测试!
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=utf8;INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'狂神','123456'),
(2,'张三','123456'),
(3,'李四','123890')
mysql 8.0 sql文件转至 5.7
1.将8.0 sql文件用记事本打开进行编辑
2.将sql文件中的 utf8mb4_0900_ai_ci 全替换为 utf8_general_ci
3.将sql文件中的utf8mb4 全替换为 utf8
4.在mysql 5.7版新建一个数据库,字符集选择 utf8 ;排序规则选择 utf8_general_ci,双击点开,选择刚处理好的SQL文件导入 即导入成功。
utf8mb4_0900_ai_ci
↓
utf8_general_ci
utf8mb4
↓
utf8
2、新建项目
1、新建一个普通的maven项目
idea 2022.1 创建maven卡死问题
关闭当前项目project -close 后 重新创建项目即可
2、删除src目录
3、导入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.qia</groupId><artifactId>Mybatis-Study</artifactId><packaging>pom</packaging><version>1.0-SNAPSHOT</version><modules><module>mybatis-01</module></modules><!-- 导入依赖 --><dependencies><!-- mysql驱动 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><!-- mybatis --><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.11</version></dependency><!-- junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency></dependencies><build><resources><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>true</filtering></resource><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>true</filtering></resource></resources></build><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties></project>
2、创建一个模块
1、编写mybatis的核心配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration核心配置文件 -->
<configuration>
<!-- environments配置多个环境(此处的默认环境是开发环境) --><environments default="development">
<!-- 这个环境 id 也可以是 test,然后让默认环境是 test 环境 --><environment id="development">
<!-- 事务管理,默认用的是JDBC的 --><transactionManager type="JDBC"/>
<!-- 数据库 的 连接池的配置 --><dataSource type="POOLED"><!-- 加载驱动 --><property name="driver" value="com.mysql.jdbc.Driver"/><!-- 数据库url --><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"/><!-- 加载驱动 -->
<!-- <property name="driver" value="${driver}"/>--><!-- 数据库url -->
<!-- <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/qia/dao/UserMapper.xml"/></mappers></configuration>
(此处注意mappers,是后续增加的配置)
工厂模式
读取配置文件把它加载成流
工厂类直接封装成工具类防止多次申请工厂而造成资源浪费
2、编写mybatis的工具类
package com.qia.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 --> sqlSession
// 读取配置文件把它加载成流!!!
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 命令所需的所有方法。// 即 getSqlSession 这个方法用于 获取SqlSessionpublic static SqlSession getSqlSession(){return sqlSessionFactory.openSession();}
}
3、编写代码
1、实体类
package com.qia.pojo;//实体类
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;}@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +", pwd='" + pwd + '\'' +'}';}
}
2、Dao接口
此处的dao相当于以后的mapper
package com.qia.dao;import com.qia.pojo.User;import java.util.List;public interface UserDao {List<User> getUserList();
}
3、接口实现类
由原来的UserDaoImpl转变为一个Mapper配置文件
以前,是UserDaoImpl
package com.qia.dao;import com.qia.pojo.User;import java.sql.Connection;
import java.sql.ResultSet;
import java.util.List;// MyBatis 避免了几乎所有的 JDBC 代码以及手动设置参数和获取结果集的工作。(即取代了dao层实现类的工作)
public class UserDaoImpl implements UserDao{public List<User> getUserList() {String sql = "select * from mybatis.user";// (结果集之类的操作)...return null;}
}
现在,是 UserMapper.xml
因为 MyBatis 避免了几乎所有的 JDBC 代码以及手动设置参数和获取结果集的工作。
即 其实就是 取代了 dao层实现类 的工作
所以也可以命名为UserDao.xml
专门用来编写SQL语句的,和Java代码解耦合
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace=绑定一个对应的Dao/Mapper接口 -->
<!-- 命名空间,通过这个来唯一定位,与UserDao进行绑定,就相当于原来的实现接口,本质:简化操作数据库 -->
<mapper namespace="com.qia.dao.UserDao"><!-- select查询语句,id对应原来的方法名字,id是必填项 --><select id="getUserList" resultType="com.qia.pojo.User">select * from user</select></mapper><!-- 因为 MyBatis 避免了几乎所有的 JDBC 代码以及手动设置参数和获取结果集的工作。 --><!-- 即 其实就是 取代了 dao层实现类 的工作 --><!-- 所以也可以命名为UserDao.xml --><!-- 门用来编写SQL语句的,和Java代码解耦合 -->
4、测试
在UserDaoImpl页面Alt + Insert点击测试Test生成
项目代码规范
junit测试
package com.qia.dao;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.List;public class UserDaoTest {@Testpublic void test(){//第一步:获取SqlSession对象SqlSession sqlSession = MybatisUtils.getSqlSession();//执行SQL //此处的UserDao.class是反射,反射获取类对象相当于 new UserDao //这里的UserDao也可以改名成UserMapper,与getMapper相对应UserDao userDao = sqlSession.getMapper(UserDao.class);//因为java文件和xml文件已经绑定了,相当于是一个东西。类似动态代理,根据接口以及配置文件生成对应的Impl。配置文件的映射直接帮你拿到了实现接口的实例List<User> userList = userDao.getUserList();for (User user : userList) {System.out.println(user);}//用完之后,关闭SqlSessionsqlSession.close();}
}
遇到的问题:
- 重要问题:
org.apache.ibatis.binding.BindingException: Type interface com.qia.dao.UserDao is not known to the MapperRegistry.
Mapper文件未绑定错误(MapperRegistry是什么?)
解决方法:核心配置文件中注册 mappers - 绑定后还是报错
空指针错误,因为找不到文件
maven规定了配置文件(.xml文件)一定要放在resource文件里
但是maven由于它的约定大于配置,当配置文件无法被导出或者生效时,解决方法:查找文件失败 --> 开启过滤
<build><resources><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>true</filtering></resource><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>true</filtering></resource></resources></build>
如果报了UTF8字符集编码错误
可以pom.xml配置一下
<properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>
可能会遇到的问题:
1、配置文件没有注册 mapper
2、绑定接口错误 namespace
3、方法名不对 id
4、返回类型不对
5、maven导出资源问题
旧版本的执行SQL方法:
下面的 方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
既然有了SqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实例了。SqlSession完全包含了面向数据库执行SQL命令的所有方法。你可以通过SqlSession实例来直接执行已映射的SQL语。
诚然,这种方式能够正常工作,并且对于使用旧版本Mybatis的用户来说也比较熟悉。但现在有了一种更简洁的方式————使用正确描述每个语句的参数和返回值的接口(比如UserMapper.class,即对应接口的类对象),你现在不仅可以执行更清晰和类型安全的代码,而且还不用担心易错的字符串你字面值以及强制类型转换
所以现在的mybatis必须指定命名空间namespace的唯一绑定
(完全限定名,短名称)
package com.qia.dao;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.List;public class UserDaoTest {@Testpublic void test(){// 第一步:获取SqlSession对象SqlSession sqlSession = MybatisUtils.getSqlSession();// 第二步:执行SQL// 方式一:getMapper// 此处的UserDao.class是反射,反射获取类对象相当于 new UserDao //这里的UserDao也可以改名成UserMapper,与getMapper相对应UserDao userDao = sqlSession.getMapper(UserDao.class);//因为java文件和xml文件已经绑定了,相当于是一个东西。类似动态代理,根据接口以及配置文件生成对应的Impl。配置文件的映射直接帮你拿到了实现接口的实例List<User> userList = userDao.getUserList();// 方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
// List<User> userList = sqlSession.selectList("com.qia.dao.UserDao.getUserList");for (User user : userList) {System.out.println(user);}// 第三步:用完之后,关闭SqlSessionsqlSession.close();}
}//方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
/*
既然有了SqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实例了。SqlSession完全包含了面向数据库执行SQL命令的所有方法。你可以通过SqlSession实例来直接执行已映射的SQL语。
诚然,这种方式能够正常工作,并且对于使用旧版本Mybatis的用户来说也比较熟悉。但现在有了一种更简洁的方式————使用正确描述每个语句的参数和返回值的接口(比如UserMapper.class,即对应接口的类对象),你现在不仅可以执行更清晰和类型安全的代码,而且还不用担心易错的字符串你字面值以及强制类型转换*/
小总结
- pom.xml
junit.jar(test)
mysql.jar
mybatis.jar - mybatis-config.xml
- MybatisUtils(SqlSession)(会读取配置文件,配置文件去读取数据库)
- pojo(User)
- mapper接口
- mapper.xml
- UserDaoTest
dao和daoimpl --> mapper(接口:数据库操作的方法)和mapper.xml(sql)
现在的mybatis必须指定命名空间namespace的唯一绑定
SqlSessionFactoryBuilder --> SqlSessionFactory --> SqlSession
- SqlSessionFactoryBuilder:创建SqlSessionFactory后即没用了,可被丢弃
- SqlSessionFactory:被创建后在应用的运行期间会一直存在,应用作用域。(例如使用单例模式或者静态单例模式也是这样)
- SqlSession:最佳作用域是请求或方法作用域,所以用后最好马上close。每收到一个请求,就会打开一个SqlSession,返回一个响应,就立即关闭
直上青天揽日月,欲倾东海洗乾坤(3/32)
三、CRUD
1. 增删改查实现
1、namespace
namespace中的包名要和接口的包名一致 (Dao/Mapper)
绑定异常一定要反复确认检查 mapper.xml 文件的 namespace 和 mybatis-config.xml 文件的 mapper注册(几乎肯定是这里错了)
2、select
select查询语句
- id:对应原来的方法名字,是必填项
- resultType:Sql执行的返回值!Class类 或 基本数据类型
- parameterType:参数类型!
三步走
1.编写接口
2.编写接口对应的mapper.xml中的sql语句
3.编写测试方法
上面第三个是只有写新的mapper时才要注册,即 二 的 小总结里的步骤
红框内代码不变,变得是绿框里的
3、insert
4、update
5、delete
6、代码实现
代码实现三步走
注意点:
增删改查需要提交事务!
1、编写接口
package com.qia.mapper;import com.qia.pojo.User;import java.util.List;public interface UserMapper {//查询全部用户List<User> getUserList();//根据id查询用户User getUserById(int id);//insert一个用户,返回值int是数据库受影响行数,用来判断操作成功与否int addUser(User user);//修改用户int updateUser(User user);//删除一个用户int deleteUser(int id);
}
2、编写接口对应的mapper.xml中的sql语句(核心)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 因为 MyBatis 避免了几乎所有的 JDBC 代码以及手动设置参数和获取结果集的工作。 -->
<!-- 即 其实就是 取代了 dao层实现类 的工作 -->
<!-- 所以也可以命名为UserDao.xml -->
<!-- 门用来编写SQL语句的,和Java代码解耦合 --><!-- namespace=绑定一个对应的Dao/Mapper接口 -->
<!-- 命名空间,通过这个来唯一定位,与UserDao进行绑定,就相当于原来的实现接口,本质:简化操作数据库 -->
<mapper namespace="com.qia.mapper.UserMapper"><!-- select查询语句,id对应原来的方法名字,id是必填项 --><select id="getUserList" resultType="com.qia.pojo.User" >select * from user;</select><select id="getUserById" parameterType="int" resultType="com.qia.pojo.User">select * from user where id = #{id};</select><!-- User getUserById(int id); 接口里传的参数是id,我们就接收一个id --><!-- #{}有预编译机制,可以防止sql注入攻击,效率高,字符型两边要加单引号 --><!-- insert没有resultType。对象中的属性,可以直接取出来 --><insert id="addUser" parameterType="com.qia.pojo.User">insert into user(id,name,pwd) values (#{id},#{name},#{pwd})</insert><update id="updateUser" parameterType="com.qia.pojo.User">update user set name=#{name},pwd=#{pwd} where id=#{id};</update><!-- 此处的int可以不用写 --><delete id="deleteUser" parameterType="int">delete from user where id=#{id};</delete></mapper>
3、编写测试方法
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.List;public class UserMapperTest {@Testpublic void getUserList_test(){// 第一步:获取SqlSession对象SqlSession sqlSession = MybatisUtils.getSqlSession();try {// 第二步:执行SQL// 方式一:getMapper// 此处的UserDao.class是反射,反射获取类对象相当于 new UserDao //这里的UserDao也可以改名成UserMapper,与getMapper相对应UserMapper userMapper = sqlSession.getMapper(UserMapper.class);//因为java文件和xml文件已经绑定了,相当于是一个东西。类似动态代理,根据接口以及配置文件生成对应的Impl。配置文件的映射直接帮你拿到了实现接口的实例List<User> userList = userMapper.getUserList();// 方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
// List<User> userList = sqlSession.selectList("com.qia.mapper.UserDao.getUserList");for (User user : userList) {System.out.println(user);}}catch (Exception e){e.printStackTrace();}finally {// 第三步:用完之后,关闭SqlSessionsqlSession.close();}//方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))/*既然有了SqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实例了。SqlSession完全包含了面向数据库执行SQL命令的所有方法。你可以通过SqlSession实例来直接执行已映射的SQL语。诚然,这种方式能够正常工作,并且对于使用旧版本Mybatis的用户来说也比较熟悉。但现在有了一种更简洁的方式————使用正确描述每个语句的参数和返回值的接口(比如UserMapper.class,即对应接口的类对象),你现在不仅可以执行更清晰和类型安全的代码,而且还不用担心易错的字符串你字面值以及强制类型转换*/}@Testpublic void getUserById_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();try {UserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = mapper.getUserById(1);
// User user = mapper.getUserById(0);//nullSystem.out.println(user);}catch (Exception e){e.printStackTrace();}finally {sqlSession.close();}}//增删改需要提交事务,否则数据库数据不会变。如果你的表用的是Myisam引擎,不支持事务,会有数据变化的@Testpublic void addUser_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);try {int i = mapper.addUser(new User(4,"哈哈","123333"));
// int i = mapper.addUser(new User(6,"123456789123456789123456789123456789123456789123456789",""));if (i==1){System.out.println("插入成功!");}//提交事务sqlSession.commit();}catch (Exception e){System.out.println("插入失败!");}finally {sqlSession.close();}}@Testpublic void updateUser_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);try {int i = mapper.updateUser(new User(4,"呵呵","123123"));
// int i = mapper.updateUser(new User(4,"123456789123456789123456789123456789123456789123456789",""));if (i==1){System.out.println("修改成功!");}//提交事务sqlSession.commit();}catch (Exception e){System.out.println("修改失败!");}finally {sqlSession.close();}}@Testpublic void deleteUser_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);try {int i = mapper.deleteUser(4);
// int i = mapper.deleteUser(6);if (i==1){System.out.println("删除成功!");}else {System.out.println("删除失败!");}//提交事务sqlSession.commit();}catch (Exception e){System.out.println("删除失败!");}finally {sqlSession.close();}}
}
2. 分析错误 错误排查
- mapper.xml里的标签和数据库操作要一致
例如这里别写成select标签,然后去执行了cud操作 - mapper.xml里的namespace是 包名.包名.接口名
mybatis-config.xml里的mapper注册路径是 包名/包名/接口对应的mapper.xml - mybatis-config.xml内代码别写错
- 空指针异常,没有注册到资源
看看工具类里的sqlSessionFactory调用成功了吗 - xml文件中存在中文乱码问题
- maven资源没有导出问题 --> 资源过滤
3. Map和模糊查询拓展
1、万能的Map
1、UserMapper接口
// ↓ ========== ========== 将上面的方法改成利用map键值对进行操作 ========== ==========//根据id查询用户User getUserById2(Map<String,Object> map);//insert一个用户,返回值int是数据库受影响行数,用来判断操作成功与否int addUser2(Map<String,Object> map);//修改用户int updateUser2(Map<String,Object> map);//删除一个用户int deleteUser2(Map<String,Object> map);//insert一个用户,返回值int是数据库受影响行数,用来判断操作成功与否int addUser3(Map<String,Object> map);// ↑ ========== ========== 用map的好处,不需要知道数据库里有什么 ========== ==========
2、UserMapper.xml
<insert id="addUser2" parameterType="Map">insert into user(id,name,pwd) values (#{mapid},#{mapname},#{mappwd})</insert><insert id="addUser3" parameterType="Map">insert into user(id,name) values (#{mapid},#{mapname})</insert>
3、UserMapperTest
@Testpublic void addUser2_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);Map<String ,Object> map = new HashMap<String, Object>();map.put("mapid",4);map.put("mapname","哈哈");map.put("mappwd","123333");
// map.put("mapname","");
// map.put("mappwd","123456789123456789123456789123456789123456789123456789");try {int i = mapper.addUser2(map);if (i==1){System.out.println("插入成功!");}//提交事务sqlSession.commit();}catch (Exception e){System.out.println("插入失败!");}finally {sqlSession.close();}}@Testpublic void addUser3_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);Map<String ,Object> map = new HashMap<String, Object>();map.put("mapid",5);map.put("mapname","嘿嘿");
// map.put("mapname","123456789123456789123456789123456789123456789123456789");try {int i = mapper.addUser3(map);if (i==1){System.out.println("插入成功!");}//提交事务sqlSession.commit();}catch (Exception e){System.out.println("插入失败!");}finally {sqlSession.close();}}
4、好处
假设实体类,或者数据库中的表,字段或者参数过多,可以考虑使用Map
用map你要用什么参数就写什么参数;用实体类的话new的时候要写所有的成员
当字段可以设为空时,插入时值为空的字段,就可以省略不写了
使用实体类传参,实例化实体类时需要把值设为空,实体类是全参构造器
这种方法就直接免了实体类,着用一个方法代替了一系列的方法
不正规,但万能
Map传递参数,直接在sql中取对象的key即可!【parameterType=“Map”】
对象传递参数,直接在sql中取对象的属性即可!【parameterType=“Object”】
只有一个基本类型参数的情况下,可以直接在sql中取到
多个参数用Map,或者注解!!!
5、自己写的代码
接口
//根据id查询用户List<User> getUserById3(Map<String,Object> map);
xml
<select id="getUserById3" parameterType="Map" resultType="com.qia.pojo.User">select * from user where id in (#{id1},#{id2},#{id3});</select>
test
@Testpublic void getUserById3_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);Map<String ,Object> map = new HashMap<String, Object>();map.put("id1",8);map.put("id2",2);map.put("id3",4);if (!map.isEmpty()) {System.out.println("查询条件map不为空");}try {List<User> user = mapper.getUserById3(map);System.out.println(user);}catch (Exception e){e.printStackTrace();}finally {sqlSession.close();}}
4、模糊查询怎么写
用通配符拼接字符串
法一:拼好再传
法二:传后再拼
代码实现
List<User> getUserLike(String name);List<User> getUserLike2(String name);
<select id="getUserLike" resultType="com.qia.pojo.User">select * from user where name like #{name}</select><select id="getUserLike2" resultType="com.qia.pojo.User">select * from user where name like "%"#{name}"%";</select><!-- select * from user where name like concat('%',#{name},'%'); --><!-- select * from user where name like "%"#{name}"%"; -->
@Testpublic void getUserLike_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);String value = "李";//这里可以修改成前端接受的参数值
// String value = "";//不安全try {String str = "";str = str + "%";str = str + value;str = str + "%";System.out.println("模糊查询的条件:"+str);List<User> user = mapper.getUserLike(str);System.out.println(user);}catch (Exception e){e.printStackTrace();}finally {sqlSession.close();}}@Testpublic void getUserLike2_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);String value = "李";//这里可以修改成前端接受的参数值
// String value = "";//不安全try {System.out.println("模糊查询的条件:"+value);List<User> user = mapper.getUserLike2(value);System.out.println(user);}catch (Exception e){e.printStackTrace();}finally {sqlSession.close();}}
不安全,会导致sql注入不安全攻击问题,例如直接传个空字符串
select * from user where id = ?;
select * from user where id = 1;//查询出了id = 1的User
select * from user where id = 1 or 1=1//查询出了全部User
#{} 的底层就是preparedStatement预编译
mybatis模糊查询防止sql注入的方法:
bind + #{}模糊查询可以防止SQL注入,bind元素可以从OGNL表达式中创建一个变量并将其绑定到上下文
一定得加引号 但是加引号了识别不出# 换成$会有sql注入问题
<select id="getUserLike2" resultType="com.qia.pojo.User"><bind name="like_name" value="'%${name}%'"/>select * from user where name like #{like_name};</select><!-- 以下方法都不安全 --><!-- select * from user where name like concat('%',#{name},'%'); --><!-- select * from user where name like "%"#{name}"%"; --><!-- select * from user where name like '%${name}%'; --><!-- 一定得加引号 但是加引号了识别不出# -->
四、配置解析
前面的都是mybatis的基础能力,配置及之后的才是真正需要掌握的
1. 配置之属性优化
1、核心配置文件
1、查看官网手册
https://mybatis.net.cn/
configuration(配置):
(必须按以下顺序,否则会报错)
properties(属性)
settings(设置)
typeAliases(类型别名)
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)
databaseIdProvider(数据库厂商标识)
mappers(映射器)
2、项目准备
将mybatis-01项目 复制粘贴到 mybatis-02
- mybatis-config.xml
- MybatisUtils
- 实体类
- mapper 接口和xml
- 删干净,都只剩5个方法就行
2、环境配置(environments)
可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
想连接两个数据库,就需要创建两个 SqlSessionFactory 实例,每个数据库对应一个。而如果是三个数据库,就需要三个实例,依此类推
每个数据库对应一个 SqlSessionFactory 实例
为了指定创建哪种环境,只要将它作为可选的参数传递给 SqlSessionFactoryBuilder 即可。可以接受环境配置的两个方法签名是:
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, properties);
如果忽略了环境参数,那么将会加载默认环境,如下所示:
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, properties);
学会使用配置多套运行环境!
<!-- 然后把 environments 的 default="test"--><environment id="test"><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>
- 事务管理器
- JDBC
- MANAGED
- 数据源
- UNPOOLED
- POOLED
- JNDI
(池:用完可以回收,让web响应更快一点)
注意各项配置的书写顺序
3、属性(properties)
我们可以通过properties属性来实现引用配置文件
这些属性都是可外部配置且可动态替换的,既可以在典型的 Java 属性文件中配置,亦可通过 properties 元素的子元素来传递。【db.properties】
编写一个数据库的配置文件
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8
username=root
password=123456
在核心配置文件中引入
<!-- 引入外部配置文件 --><properties resource="db.properties"></properties><!-- environments配置多个环境(此处的默认环境是开发环境) --><environments default="development"><!-- 这个环境 id 也可以是 test,然后让默认环境是 test 环境 --><environment id="development"><!-- 事务管理,默认用的是JDBC的 --><transactionManager type="JDBC"/><!-- 数据库 的 连接池的配置 --><dataSource type="POOLED"><!-- 加载驱动 --><property name="driver" value="${driver}"/><!-- 数据库url --><property name="url" value="${url}"/><!-- 数据库用户名 --><property name="username" value="${username}"/><!-- 用户密码 --><property name="password" value="${password}"/></dataSource></environment></environments>
也可以这样写
<!-- 引入外部配置文件 --><properties resource="db.properties"><property name="username" value="root"/><property name="password" value="123456"/></properties>
多种设置properties的方法,优先级问题:
首先读取在properties元素体内指定的属性
根据properties元素中的resource属性读取类路径下的属性文件,或根据url属性指定的路径读取属性文件,并覆盖之前读取过的同名属性
最后读取作为方法参数传递的属性,并且覆盖之前读取过的同名属性
优先级高的先执行,内部配置就被后执行的外部覆盖了
即:
- 可以直接引入外部文件
- 可以在其中增加一些属性配置
- 如果两个文件有同一个字段,优先使用外部配置文件的!
2. 配置之别名优化
1、类型别名(typeAliases)
类型别名是为 Java 类型设置一个短的名字‘
存在的意义仅在于用来减少类完全限定名的冗余
<!--可以给实体类起别名--><typeAliases><typeAlias type="com.kuang.pojo.User" alias="User"/></typeAliases>
<select id="getUserList" resultType="User" >select * from user;</select>
要写在核心配置文件里才能生效
也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:
扫描实体类的包,它的默认别名就为这个类的 类名,首字母小写
<!--可以给实体类起别名-->
<typeAliases><package name="com.kuang.pojo"/>
</typeAliases>
<select id="getUserList" resultType="user" >select * from user;</select>
在实体类比较少的时候,建议使用第一种方式
在实体类比较多的时候,建议使用第二种方式
第一种可以diy别名,第二种则不行
如果非要改,可以在实体类上增加注解起别名
//实体类
@Alias("hello")
public class User {}
加 _ 杠的对应是基本类型
没加的自动对应包装类
不建议使用别名,简洁但不方便维护
2、设置(settings)
这是Mybatis中极为重要的调整设置,他们会改变Mybatis的运行时行为
目前暂时记住这几个就可以了
日志、缓存…
3. 配置之映射器(简单)说明
1、其他配置
无需了解
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- mybatis-generator-core
- mybatis-plus
- 通用mapper
https://baomidou.com/
2、mappers(映射器)
其中,url方式别用
MapperRegistry:注册绑定我们的mapper文件
(报错这个MapperRegistry,就看一下是不是未注册)
方式一:
<mappers><mapper resource="com/qia/Mapper/UserMapper.xml"/></mappers>
方式二:使用class文件绑定注册
<mappers><mapper class="com/qia/Mapper/UserMapper"/></mappers>
方式二 和 方式三 的注意点:
接口和他的Mapper配置文件必须同名!!!
接口和他的Mapper配置文件必须在同一个包下!!!
方式三:使用扫描包进行注入绑定
<mappers><package name="com.qia.dao"/>
</mappers>
练习时间:
1.将数据库配置文件外部引入
2.实体类别名
3.保证UserMapper接口和UserMapper.xml改为一致!并且放在同一个包下!
4. 生命周期和作用域
不同作用域和生命周期类是至关重要的,因为错误的使用会导致非常严重的并发问题。
我们可以先画一个流程图,分析一下Mybatis的执行过程!
- SqlSessionFactoryBuilder:
- 一旦创建了 SqlSessionFactory,就不再需要它了
- 局部变量
- SqlSessionFactory:
- 说白了就是可以想象为 :数据库连接池
- SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。
- 因此 SqlSessionFactory 的最佳作用域是应用作用域。
- 最简单的就是使用单例模式或者静态单例模式。
- SqlSession
- 连接到连接池的一个请求!
- SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
- 用完之后需要赶紧关闭,否则资源被占用!
这里面的每一个Mapper,就代表一个具体的业务
5. ResultMap结果集映射
1、解决属性名和字段名不一致的问题
新建一个Maven Module,拷贝之前的项目代码
1.拷贝配置文件
2.删除其他方法代码,剩下getUserById方法代码
3.改写User实体类中的属性
pwd --> password
private int id;
private String name;
private String password;
4.测试出现问题
<select id="getUserById" parameterType="int" resultType="com.qia.pojo.User">select * from user where id = #{id};</select>
<!-- select * from user where id = #{id}; -->
<!-- 类型处理器-->
<!-- select id,name,pwd from user where id = #{id}; -->
解决方法:
1.起别名
<select id="getUserById" parameterType="int" resultType="com.qia.pojo.User">select id,name,pwd as password from user where id = #{id};</select>
2.结果集映射ResultMap
2、ResultMap
结果集映射
id name pwd
id name password
<!--结果集映射-->
<resultMap id="UserMap" type="User"><!--column数据库中的字段,property实体类中的属性--><result column="id" property="id"/><result column="name" property="name"/><result column="pwd" property="password"/>
</resultMap><select id="getUserById" resultMap="UserMap">select * from mybatis.user where id = #{id}
</select>
- ResultMap 元素是 MyBatis 中最重要最强大的元素
- ResultMap 的设计思想是,对于简单的语句根本不需要配置显式的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。
- ResultMap 最优秀的地方在于,虽然你已经对它相当了解了,但是根本就不需要显式地用到他们。
- 如果世界总是这么简单就好了
总结:ResultMap 用于复杂的结果集,简单单表查询没必要使用
什么字段不一样就映射哪个字段就可以了
实体类间,一对多,多对一,多对多的关系
多个学生关联一个老师
一个老师包含多个学生,是集合
resultType 自动映射
ResultMap 手动映射
六、日志
先回顾一下代码,拷贝到新模块
1、日志工厂
如果一个数据库操作,出现了异常,我们需要排错,日志就是最好的助手!
曾经:sout、debug
现在:日志工厂
environment --> setting --> logImpl
- LOG4J 【掌握】
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING 【掌握】
- NO_LOGGING
在Mybatis中具体使用哪个日志实现,在设置中设定
STDOUT_LOGGING标准日志输出
在mybatis核心配置文件中,配置我们的日志!
<settings><setting name="logImpl" value="STDOUT_LOGGING"/></settings>
Log4j
类未加载到,未下载
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.og4j.properties
#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
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=[%c]-%m%n
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/qia.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sq1.PreparedStatement=DEBUG
3.在核心配置文件配置log4j为日志的实现
<settings><setting name="logImpl" value="LOG4J"/></settings>
4.log4j的使用,直接测试运行原来的代码
简单使用
1.在要使用log4j的类中,导入包 import org.apache.log4j.Logger;
2.日志对象,参数为当前类class
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;public class UserMapperTest {static Logger logger = Logger.getLogger(UserMapperTest.class);@Testpublic void testLog4j() {logger.info("info:进入了testLog4j");logger.debug("debug:进入了testLog4j");logger.error("error:进入了testLog4j");}@Testpublic void getUserById_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();try {UserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = mapper.getUserById(1);
// User user = mapper.getUserById(0);//nullSystem.out.println(user);}catch (Exception e){e.printStackTrace();}finally {sqlSession.close();}}
}
3.日志级别
logger.info("info:进入了testLog4j");logger.debug("debug:进入了testLog4j");logger.error("error:进入了testLog4j");
下载了log4j到项目中,也写好了log4j配置文件,就会自动使用log4j控制控制台输出和形成日志文件等
七、分页
思考:为什么要分页?
减少数据的处理量!!!
节约资源优化查询性能,避免一次查询大量数据
1. 使用Limit实现分页
SELECT * from user limit startIndex,pageSize
pageSize 设为-1 报错问题:
是一个bug,低优先级,他被列在了已知bug部分中,最后他被修复了,所以limit不在=再接收否定的参数,用一个大的正数
在学习mybatis等持久层框架的时候,会经常对数据进行增删改查操作,使用最多的是对数据库进行查询操作,如果查询大量数据的时候,我们往往使用分页进行查询,也就是每次处理小部分数据,这样对数据库压力就在可控范围内。
使用mybatis实现分页,核心SQL
1.接口
package com.qia.mapper;import com.qia.pojo.User;import java.util.List;
import java.util.Map;public interface UserMapper {//分页List<User> getUserByLimit(Map<String,Integer> map);
}
2.mapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.qia.mapper.UserMapper"><!--结果集映射--><resultMap id="UserMap" type="com.qia.pojo.User"><!--column数据库中的字段,property实体类中的属性--><result column="id" property="id"/><result column="name" property="name"/><result column="pwd" property="password"/></resultMap><!-- 分页 --><select id="getUserByLimit" parameterType="map" resultMap="UserMap">select * from user limit #{startIndex},#{pageSize}</select></mapper>
parameterType
注意,类型的映射
基本类型变成_基本类型
其他的是包装类
3.测试
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;import java.util.HashMap;
import java.util.List;
import java.util.Map;public class UserMapperTest {@Testpublic void getUserByLimit_test() {SqlSession sqlSession = MybatisUtils.getSqlSession();Map<String, Integer> map = new HashMap<String, Integer>();map.put("startIndex", 0);map.put("pageSize", 2);try {UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> userList = mapper.getUserByLimit(map);for (User user : userList) {System.out.println(user);}} catch (Exception e) {e.printStackTrace();} finally {sqlSession.close();}}
}
2. RowBounds分页
开发中不建议使用
是内存分页
不再使用SQL进行分页
1.接口
//分页2List<User> getUserByRowBounds();
2.mapper.xml
<!-- 分页2 --><select id="getUserByRowBounds" resultMap="UserMap">select * from user</select>
3.test
@Testpublic void getUserByRowBounds(){SqlSession sqlSession = MybatisUtils.getSqlSession();//RowBounds实现RowBounds rowBounds = new RowBounds(1, 2);//通过Java代码层面实现分页
// List<User> userList = sqlSession.selectList("com.qia.mapper.UserMapper.getUserByRowBounds");List<User> userList = sqlSession.selectList("com.qia.mapper.UserMapper.getUserByRowBounds", null, rowBounds);
// sqlSession.selectList(Sting,Object,RowBounds);for (User user : userList) {System.out.println(user);}sqlSession.close();}
3. 分页插件
https://pagehelper.github.io/
了解即可,万一以后公司的架构师,说要使用,你需要知道它是什么东西!!
八、使用注解开发
1. 面向接口编程
- 大家都学过面向对象编程,也学习过接口,但真正的开发中,很多时候我们都会选择面向接口编程
- 根本原因:解耦,可扩展,提高复用,分层开发中,上层开发中,上层不用管具体的实现,大家都会遵守共同的标准,使得开发变得容易,规范性更好
- 在一个面向对象的系统中,系统的各个功能是由许许多多下的不同对象协作完成的。再这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了
- 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各个模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要内容。面向接口编程就是指按照这种思想来编程。
关于接口的理解:
- 接口从更深层次的理解,应是定义(规范,约束)与实现(实名分离的原则)的分离
- 接口的本身反映了系统设计人员对系统的抽象理解
- 接口应该有两类
- 对一个个体的抽象,它可对应为一个抽象体(abstract class);
- 对一个个体某方面的抽象,即形成一个抽象面(interface);
- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的
三个面向的区别:
- 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性和方法;
- 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现;
- 接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题,更多的体现就是对系统整体的架构;
2. 使用注解开发
1.注解在接口上实现
package com.qia.mapper;import com.qia.pojo.User;
import org.apache.ibatis.annotations.Select;import java.util.List;
import java.util.Map;public interface UserMapper {@Select("select * from user")List<User> getUsers();}
2.需要在核心配置文件中绑定接口
<mappers><mapper class="com.qia.mapper.UserMapper"></mapper></mappers>
3.测试
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;import java.util.HashMap;
import java.util.List;
import java.util.Map;public class UserMapperTest {@Testpublic void test(){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();}
}
发现:能运行,查出来结果,但密码为空,即要取别名不方便
简单的单表查询等操作可以使用注解来开发,复杂操作不建议这样
探寻注解是如何实现开发的
通过反射获取注解,反射可以动态获取方法等所有的内容
本质是反射机制
底层:实现了动态代理
(Clent 客户端)
Mybatis执行流程剖析
Mybatis详细的执行流程!
3. 注解增删改查 CRUD
1、设置自动提交事务
我们可以在工具类创建的时候实现自动提交事务!
将工具类的getSqlSession方法修改一下
openSession设置为true
即默认开启提交
public static SqlSession getSqlSession(){return sqlSessionFactory.openSession(true);}
2、编写接口,增加注解
package com.qia.mapper;import com.qia.pojo.User;
import org.apache.ibatis.annotations.*;import java.util.List;
import java.util.Map;public interface UserMapper {@Select("select * from user")List<User> getUsers();//方法存在多个参数,所有的参数前面必须加上@Param("参数名")@Select("select * from user where id = #{id}")User getUserById(@Param("id") int id);
// User getUserById(@Param("id") int id,@Param("name") String name);@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);//@Param("参数名")@Delete("delete from user where id=#{paramId}")int deleteUser(@Param("paramId") int id);}
3、测试类
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;import java.util.HashMap;
import java.util.List;
import java.util.Map;public class UserMapperTest {@Testpublic void test(){SqlSession sqlSession = MybatisUtils.getSqlSession();//底层主要应用反射UserMapper mapper = sqlSession.getMapper(UserMapper.class);mapper.deleteUser(6);sqlSession.close();}//getUsers
// List<User> users = mapper.getUsers();
// for (User user : users) {// System.out.println(user);
// }//getUserById
// User userById = mapper.getUserById(2);
// System.out.println(userById);//addUser
// mapper.addUser(new User(6,"hello","123123"));//updateUser
// mapper.updateUser(new User(6,"tutu","323232"));}
重点注意:我们必须要将接口注册绑定到我们的核心配置文件中!!!
注册时可以使用通配符
<mappers><mapper class="com.qia.mapper.UserMapper"></mapper><mapper resource="com/qia/mapper/*Mapper.xml"></mapper></mappers>
关于@Param(" ")注解
- 基本类型的参数或者String类型,需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话,可以忽略,但是建议大家都加上
- 我们在SQL中引用的就是我们这里的@Param()中设定的属性名
#{} 和 ${} 区别:
- #{} 可以防止sql注入 安全
- ${} 不可以防止sql注入 不安全(早期用法,不推荐)
- 类似Statement和PreparedStatement
- #{}底层原理就是预编译
九、Lombok的使用
Lombok项目是一个Java库,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。
- java library
- plugs
- build tools
- with one annotation your class
使用步骤:
1.在IDEA中安装Lombok插件
Settings --> Plugins
重启IEDA
idea官方支持 2022版本以后 默认内置了lombok插件,无需再下载
2.在项目中导入lombok的jar包
3、在实体类上加注解即可
安装lombok插件后,可以使用的注解
@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
@StandardException
@val
@var
experimental @var
@UtilityClass
加注解前
加注解后
@Data:无参构造,get,set,equals、canEqual、hashCode、toString
package com.qia.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;//实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {private int id;private String name;private String password;
}
注意:显式的定义了有参构造,想要有无参构造,就必须也显式定义无参构造
常用:
@Data
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@ToString
@EqualsAndHashCode
十、复杂查询
1. 复杂查询环境搭建
- 多个学生 对应 一个老师
- 对于这边而言,关联。。 多个学生,关联一个老师【多对一】
- 对于老师而言,集合。。 一个老师,有很多学生 【一对多】
1、数据库SQL
CREATE TABLE `teacher`(`id` INT(10) NOT NULL,`name` VARCHAR (30) DEFAULT NULL,PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8INSERT 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=utf8INSERT 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');
一般一对多的关系,都是由多端来维护关系
所以学生新增成员属性
resource资源目录下,建多级目录,用 “ / ”
2、自写mapper.xml 文件
1.拷贝mybatis核心配置文件的代码
2.删除中间部分的代码,剩下面的
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><!-- configuration核心配置文件 -->
<configuration></configuration>
3.所有 config --> mapper
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><!-- configuration核心配置文件 -->
<mapper></mapper>
要修改 5 处
4.写上命名空间namespace
3、在核心配置文件注册mapper
<!--绑定接口--><mappers><mapper resource="com/qia/mapper/StudentMapper.xml"/><mapper resource="com/qia/mapper/TeacherMapper.xml"/></mappers>
或者
<mapper resource="com/qia/mapper/*Mapper.xml"/>
发现< mapper resource=“com/qia/mapper/*Mapper.xml”/> 不能用通配符会报错
4、测试环境搭建
1、导入Lombok
2、新建实体类
3、建立mapper接口
4、建立mapper.xml文件
5、在核心配置文件中绑定注册我们的mapper接口或者文件!
6、测试查询是否能够成功
package com.qia.pojo;import lombok.*;@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {private int id;private String name;//学生需要关联一个老师!private Teacher teacher;
}
package com.qia.pojo;import lombok.*;@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {private int id;private String name;
}
package com.qia.mapper;import com.qia.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;public interface TeacherMapper {@Select("select * from teacher where id=#{tid}")Teacher getTeacher(@Param("tid") int id);}
package com.qia.mapper;import com.qia.pojo.Teacher;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;public class TeacherMapperTest {@Testpublic void getTeacher_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);Teacher teacher = mapper.getTeacher(1);System.out.println(teacher);sqlSession.close();}}
2. 多对一的处理
方式一、按照查询嵌套处理
<!--思路:1. 查询所有的学生信息2. 根据查询出来的学生的tid寻找特定的老师 (子查询)--><select id="getStudent" resultMap="StudentTeacher">select * from student</select><resultMap id="StudentTeacher" type="com.qia.pojo.Student"><result property="id" column="id"/><result property="name" column="name"/><!--复杂的属性,我们需要单独出来 对象:association 集合:collection--><collection property="teacher" column="tid" javaType="com.qia.pojo.Teacher" select="getTeacher"/></resultMap><select id="getTeacher" resultType="com.qia.pojo.Teacher">select * from teacher where id = #{tid}</select>
mybatis中collection的标签属性:
- property: resultMap返回实体类中字段和result标签中的property一样
- column: 数据库的列名,或者列标签别名,是关联查询往下一个语句传送值。注意:在处理组合键时,您可以使用column=“{prop1=col1,prop2=col2}”这样的语法,设置多个列名传入到嵌套查询语句。这就会把prop1和prop2设置到目标嵌套选择语句的参数对象中。
- javaType: 对应的java类型。一般为ArrayList或是java.util.List
- ofType: 对应的数据库类型。java的实体类,对应数据库表的列名称,即关联查询select对应返回的类
- select: 执行一个其他映射的sql语句返回一个java实体类型
字段名:
property:实体类中字段
column:数据库的列名
.
数据类型:
javaType:对应的java类型
jdbcType:对应的数据库类型
javaType(ofType):Java类型+泛型; 如 List< Student>
少用这种子查询的方法
(禁止嵌套)
方式二、按照结果嵌套处理
<!--按照结果嵌套查询--><select id="getStudent2" resultMap="StudentTeacher2">select s.id sid , s.name sname, t.id tid,t.name tnamefrom student s,teacher twhere s.tid=t.id</select><!--结果封装,将查询出来的列封装到对象属性中--><resultMap id="StudentTeacher2" type="com.qia.pojo.Student"><result property="id" column="sid"/><result property="name" column="sname"/><association property="teacher" javaType="com.qia.pojo.Teacher"><result property="id" column="tid"/><result property="name" column="tname"/></association></resultMap>
回顾Mysql多对一查询方式:
- 子查询 (按照查询嵌套)
- 联表查询 (按照结果嵌套)
3. 一对多的处理
比如:一个老师有多个学生!
对于老师而言,就是一对多的关系!
1、环境搭建
环境搭建,和刚才一样
1.拷贝resource目录
2.拷贝src.java目录
3.拷贝test目录
4.清除无关无用代码
5.修改实体类
package com.qia.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;import java.util.List;@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {private int id;private String name;//一个老师拥有多个学生private List<Student> students;
}
2、一对多的处理
1、按照结果嵌套查询
<!--按照结果嵌套处理--><select id="getTeacher" resultMap="TeacherStudent">select t.id tid, t.name tname, s.id sid, s.name snamefrom student s, teacher twhere s.tid = t.id and t.id=#{tid}</select>
<!-- where s.tid = t.id --><resultMap id="TeacherStudent" type="com.qia.pojo.Teacher"><result property="id" column="tid"/><result property="name" column="tname"/><!--复杂的属性,我们需要单独出来 对象:association 集合:collection指定的属性类型使用 javaType=""集合中的泛型信息使用 ofTYpe=" " 获取--><collection property="students" ofType="com.qia.pojo.Student"><result property="id" column="sid"/><result property="name" column="sname"/></collection></resultMap>
2、按照查询嵌套处理
<select id="getTeacher2" resultMap="TeacherStudent2">select * from teacher where id=#{tid};</select><resultMap id="TeacherStudent2" type="com.qia.pojo.Teacher">
<!-- <result property="id" column="id" />-->
<!-- <result property="name" column="name" />--><collection property="students" column="id" javaType="ArrayList" ofType="com.qia.pojo.Student" select="getStudent"/></resultMap><select id="getStudent" resultType="com.qia.pojo.Student">select * from student where tid=#{tid};
小结
- 关联 - association 【多对一】
- 集合 - collection 【对多】
- JavaType & ofType
- JavaType 用来指定实体类中属性的类型
- ofType 用来指定映射到List或者集合中的pojo类型,泛型中的约束类型
- 注意点:
- 尽量保证SQL的可读性,尽量保证通俗易懂
- 注意一对多、多对一 中,属性名和字段问题!!
- 如果问题不好排除,可以使用日志~ 建议Log4j 【其实默认的也够用了】
- 避免慢SQL
- 面试:
- Mysql 引擎 (InnoDB 和 Mys…)
- InnoDB底层原理
- 索引
- 索引优化!
十一、动态SQL
1. 动态SQL环境搭建
1、什么是动态SQL:
动态SQL就是指根据不同的条件生成不同的SQL语句
利用动态SQL这一特性可以摆脱这种痛苦。
动态SQL元素和JSTL或基于类似XML的文本处理器相似。在Mybatis之前的版本中,有很多元素需要花时间了解。Mybatis 3大大精简了元素种类,现在只需要学习原来的一半的元素便可以了。Mybatis采用功能强大的基于OGNL的表达式来淘汰其他大部分元素
if
choose (when,otherwise)
trim (where, set)
foreach
2、搭建环境
数据库SQL
CREATE TABLE `blog`(`id` VARCHAR(50) NOT NULL COMMENT '博客',`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
创建一个基础工程
1、导包
2、编写配置文件
3、编写实体类
package com.qia.pojo;import lombok.*;import java.util.Date;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Blog {private int id;private String title;private String author;private Date createTime;// 属性名和字段名不一致private int views;
}
在配置文件中添加驼峰命名规则 解决属性名和字段名不一致的问题
<settings><!--开启驼峰形式字段匹配--><setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
4、编写实体类对应的Mapper接口和Mapper.xml文件
package com.qia.mapper;import com.qia.pojo.Blog;public interface BlogMapper {//插入数据int addBlog(Blog blog);
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.qia.mapper.BlogMapper"><insert id="addBlog" parameterType="blog">insert into blog(id,title,author,create_time,views)values (#{id},#{title},#{author},#{createTime},#{views})</insert></mapper>
package com.qia.mapper;import com.qia.pojo.Blog;
import com.qia.utils.IDutils;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;import java.util.Date;@SuppressWarnings("all")
public class BlogMapperTest {@Testpublic void addInitBlog() {SqlSession sqlSession = MybatisUtils.getSqlSession();BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);Blog blog = new Blog();blog.setId(IDutils.getId());blog.setTitle("Mybatis如此简单");blog.setAuthor("狂神说");blog.setCreateTime(new Date());blog.setViews(9999);mapper.addBlog(blog);blog.setId(IDutils.getId());blog.setTitle("Java如此简单");mapper.addBlog(blog);blog.setId(IDutils.getId());blog.setTitle("Spring如此简单");mapper.addBlog(blog);blog.setId(IDutils.getId());blog.setTitle("微服务如此简单");mapper.addBlog(blog);sqlSession.close();}
}
发现插入数据后,中文变成了问号
把db.properties里的 & amp; 改成 &
2. 动态SQL常用标签
1. IF
//查询博客 IFList<Blog> queryBlogIF(Map map);
<!--parameterType 输入类型resultType 返回结果集--><select id="queryBlogIF" parameterType="map" resultType="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>
2. choose(when,otherwise)
相当于 switch - case
//查询博客 ChooseList<Blog> queryBlogChoose(Map map);
<select id="queryBlogChoose" parameterType="map" resultType="blog">select * from blog<where><choose><when test="title != null">title = #{title}</when>
<!-- <when test="author != null and views!=null">-->
<!-- and author = #{author} and views = #{views}-->
<!-- </when>--><when test="author != null">and author = #{author}</when><otherwise>and views =# {views}</otherwise></choose></where></select>
@Testpublic void queryBlogChoose_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);HashMap map = new HashMap();
// System.out.println(mapper.queryBlogChoose(map));
// map.put("title","Java如此简单");
// System.out.println(mapper.queryBlogChoose(map));map.put("author","狂神说");
// System.out.println(mapper.queryBlogChoose(map));map.put("views","9999");System.out.println(mapper.queryBlogChoose(map));sqlSession.close();}
直接写1=1多判断了一个条件,在数据量大的时候会有额外的开销,影响性能
mybatis 的 where标签 会自动判断组合条件下的sql,看是否有多余的and、or、where
相当于 switch - case,只会选择其一,优先走第一条满足的条件
注意调整判断条件的位置
3. trim(where,set)
1. where-if
<!-- where标签 会去除多余的 “AND” 或 “OR”,或 "where" -->
<select id="queryBlogIF" parameterType="map" resultType="blog">select * from mybatis.blog<where><if test="title != null">and title = #{title}</if><if test="author != null">and author = #{author}</if></where>
</select>
2. set-if
set可以多个条件成立,where只可以一个
set元素会动态前置set关键字,同时也会删除无关的逗号。
(建议逗号都写上,无关的,运行时会自动删除,没写的话,需要用的时候不会给你自动添加)
set语句至少要有一个值被满足,否则会报错(update blog直接运行报错)
//更新博客int updateBlog(Map map);
<!-- set标签 会去除多余的 "逗号",或 "set" --><update id="updateBlog" parameterType="map" >update blog<set><if test="title != null">title = #{title},</if><if test="author != null">author = #{author},</if></set>where id = #{id}</update>
@Testpublic void updateBlog_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);HashMap map = new HashMap();map.put("id","666");map.put("title","疑是地上霜");map.put("author","嘿嘿");System.out.println(mapper.updateBlog(map));sqlSession.close();}
3. trim
< trim prefix=“” suffix=“” suffixOverrides=“” prefixOverrides=“”>< /trim>
- prefix:在trim标签内sql语句加上前缀。
- suffix:在trim标签内sql语句加上后缀。
- prefixOverrides:指定去除多余的前缀内容
- suffixOverrides:指定去除多余的后缀内容,如:suffixOverrides=“,”,去除trim标签内sql语句多余的后缀","。
<trim prefix="WHERE" prefixOverrides="AND |OR "></trim>
AND |OR 的空格别忘了
所谓的动态SQL,本质还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码
if where set choose when,本质是 if
4. SQL片段
在官方中文文档的xml映射器里
有的时候,我们可能会将一些功能的部分抽取出来,方便复用
1、使用SQL标签抽取公共部分
<sql id="sql-if-title-author"><if test="title != null">title = #{title}</if><if test="author != null">and author = #{author}</if>
</sql>
2、在需要使用的地方使用Include标签引用即可
<!--parameterType 输入类型resultType 返回结果集-->
<select id="queryBlogIF" parameterType="map" resultType="blog">select * from mybatis.blog<where><include refid="sql-if-title-author"/></where>
</select>
完整代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.qia.mapper.BlogMapper"><!-- 类似html<include>的静态包含 --><sql id="sql-if-title-author"><set><if test="title != null">title = #{title},</if><if test="author != null">author = #{author},</if></set></sql><update id="updateBlog" parameterType="map">update blog<include refid="sql-if-title-author"></include>where id = #{id}</update>
</mapper>
@SuppressWarnings("all")
public class BlogMapperTest {@Testpublic void updateBlog_test(){SqlSession sqlSession = MybatisUtils.getSqlSession();BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);HashMap map = new HashMap();map.put("id","666");map.put("title","举头望明月");map.put("author","嘿嘿");System.out.println(mapper.updateBlog(map));sqlSession.close();}}
注意事项:
- 最好基于单表定义SQL片段!!
- sql标签不要存在where标签 因为他是动态的
5. Foreach
动态 SQL 的另一个常见使用场景是对集合进行遍历(尤其是在构建 IN 条件语句的时候)。比如:
<select id="getUser" resultType="User">select * from user where 1=1 and <foreach item="id" collection="ids" index="index" open="(" separator="or" close=")">#{id}</foreach>
</select>
<!-- (id=1 or id=2 or id=3) -->
foreach 元素的功能非常强大,它允许你指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符,看它多智能!
提示 你可以将任何可迭代对象(如 List、Set 等)、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时,index 是当前迭代的序号,item 的值是本次迭代获取到的元素。当使用 Map 对象(或者 Map.Entry 对象的集合)时,index 是键,item 是值。
测试
1、修改数据库表的id字段
2、编写代码
<!-- 查询第1-2-3号记录的博客 --><!-- select * from user where 1=1 and (id=1 or id=2 or id=3)我们现在传递一个万能的map,这map可以存在一个集合!collection:集合 item:集合里的数据 --><select id="queryBlogForeach" parameterType="map" resultType="blog">select * from blog<where><foreach item="id" collection="ids" open="and (" separator="or" close=")">id=#{id}</foreach></where></select>
@Testpublic void queryBlogForeach(){SqlSession sqlSession = MybatisUtils.getSqlSession();BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);Map map = new HashMap();ArrayList<Integer> ids = new ArrayList<Integer>();ids.add(1);ids.add(3);map.put("ids",ids);List<Blog> list = blogMapper.queryBlogForeach(map);for (Blog blog : list) {System.out.println(blog);}sqlSession.close();}
6. bind
bind 元素允许你在 OGNL 表达式以外创建一个变量,并将其绑定到当前的上下文。比如:
<select id="selectBlogsLike" resultType="Blog"><bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />SELECT * FROM BLOGWHERE title LIKE #{pattern}
</select>
小总结
动态SQL就是拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
建议:
先在Mysql中写出完整的SQL,再对应的去修改成为我们的动态SQL实现通用即可
十二、缓存(了解即可)
1. 缓存简介
1、简介
查询 : 连接数据库,耗资源
一次查询的结果,给他暂存一个可以直接取到的地方 --> 内存:缓存
我们再次查询的相同数据的时候,直接走缓存,不走数据库了
1、什么是缓存[Cache]?
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题
2、为什么使用缓存?
- 减少和数据库的交互次数,减少系统开销,提高系统效率
3、什么样的数据可以使用缓存?
- 经常查询并且不经常改变的数据 【可以使用缓存】
2、Mybatis缓存
- MyBatis包含一个非常强大的查询缓存特性,它可以非常方便的定制和配置缓存,缓存可以极大的提高查询效率。
- MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启(SqlSession级别的缓存,也称为本地缓存)
- 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
- 为了提高可扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。
缓存策略
LRU – 最近最少使用:移除最长时间不被使用的对象。
FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
默认的清除策略是 LRU。
2. 一级缓存
- 一级缓存也叫本地缓存:SqlSession
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库
测试步骤:
1、基本框架
2、开启日志
3、测试在一个Session中查询两次记录
4、查看日志输出
缓存失效的情况:(读写操作,读,读缓存,写,刷新缓存)
- 查询不同的东西
- 增删改操作,可能会改变原来数据的,所以必定会刷新缓存!
- 查询不同的Mapper.xml
- 手动清理缓存 : sqlSession.clearCache() ;
- 关闭缓存: sqlSession.close() ;
即使这里查询和更新的数据不是同一条,缓存也还是会被刷新,因为缓存是整体的
小结:
一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!
一级缓存就是一个map
代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration核心配置文件 -->
<configuration><properties resource="db.properties"></properties><settings><!-- 标准的日志工厂实现 --><setting name="logImpl" value="STDOUT_LOGGING"/></settings><typeAliases><typeAlias type="com.qia.pojo.User" alias="user"></typeAlias>
<!-- <package name="com.qia.pojo"/>--></typeAliases><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><!--绑定接口--><mappers><mapper resource="com/qia/mapper/UserMapper.xml"/></mappers></configuration>
package com.qia.mapper;import com.qia.pojo.User;
import org.apache.ibatis.annotations.Param;public interface UserMapper {//根据id查询用户User queryUserById(@Param("id") int id);//修改int updateUser(User user);
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.qia.mapper.UserMapper"><select id="queryUserById" parameterType="_int" resultType="user">select * from user where id=#{id}</select><update id="updateUser" parameterType="user">update user set name=#{name},pwd=#{pwd} where id=#{id}</update></mapper>
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;public class UserMapperTest {@Testpublic void test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = mapper.queryUserById(1);System.out.println(user);System.out.println("=====================================");
// mapper.updateUser(new User(1,"李白","床前明月光"));sqlSession.clearCache();//手动清理缓存System.out.println("=====================================");User user2 = mapper.queryUserById(1);System.out.println(user2);System.out.println(user == user2);sqlSession.close();}
}
3. 二级缓存
默认情况下,只启用了本地的会话缓存(一级缓存),它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存,只需要在你的 SQL 映射文件中添加一行:
<cache/>
- 二级缓存也叫全局缓存,一级缓存作用域太低了,所以诞生了二级缓存
- 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
- 工作机制
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,会话关闭了,一级缓存中的数据被保护到二级缓存中
- 新的会话查询信息,就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map)中
步骤:
1、在核心配置文件中开启全局缓存
<settings><!-- 默认是已开启的,但一般会再显式的开启缓存 --><setting name="cacheEnabled" value="true"/></settings>
2、在当前mapper.xml文件中开启二级缓存
<!--显示的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>
也可以自定义参数
<!-- 在当前Mapper.xml中使用二级缓存 --><cacheeviction="FIFO"flushInterval="60000"size="512"readOnly="true"/>
3、测试
package com.qia.mapper;import com.qia.pojo.User;
import com.qia.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;public class UserMapperTest {@Testpublic void test(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = mapper.queryUserById(1);System.out.println(user);System.out.println("=====================================");
// mapper.updateUser(new User(1,"李白","床前明月光"));sqlSession.clearCache();//手动清理缓存System.out.println("=====================================");User user2 = mapper.queryUserById(1);System.out.println(user2);System.out.println(user == user2);sqlSession.close();}@Testpublic void test2(){SqlSession sqlSession = MybatisUtils.getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);User user = mapper.queryUserById(1);System.out.println(user);sqlSession.close();System.out.println("=====================================");SqlSession sqlSession2 = MybatisUtils.getSqlSession();UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);User user2 = mapper2.queryUserById(1);System.out.println(user2);sqlSession2.close();}
}
需要被二级缓存的对象必须要实现java的序列化接口。
将JavaBean实现序列化接口即可序列化
public class User implements Serializable {}
问题:我们需要将实体类序列化!否则就会报错!
Caused by: java.io.NotSerializableException:com.kun.pojo.User
public class User implements Serializable{}
程序运行的时候,会产生很多对象,而对象信息也只是在程序运行的时候才在内存中保持其状态,一旦程序停止
小结:
- 只要开启二级缓存,在同一个Mapper下就会有效
- 所有的数据都会先放在一级缓存中
- 只有当会话提交,或者关闭的时候,才会提交二级缓存中!
4. Mybatis缓存原理
缓存顺序:
1.先看二级
2.再看一级
3.查询数据库
5. 自定义缓存Ehcache
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存
要在程序中使用ehcache,先要导包!
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency><groupId>org.mybatis.caches</groupId><artifactId>mybatis-ehcache</artifactId><version>1.2.1</version>
</dependency>
在mapper中指定使用我们的ehcache缓存实现!
<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehche.EhcacheCache"/>
ehcache.xml
<ehcache><!-- 如果缓存支持硬盘存储,则指定硬盘的存储路径 --><diskStore path="java.io.tmpdir"/><!-- maxElementsInMemory="10000": 内存中支持的最大对象存储数量eternal="false": 是否在内存中永久存储. 建议为false,如果为true,则后面两个参数无效,即不会有时间的限制timeToIdleSeconds="20": 如果20秒没有访问此对象,则对象销毁timeToLiveSeconds="120" 对象的总存活时间,120之后无论访问多么频繁都会销毁overflowToDisk="true": 是否支持溢出到硬盘, 建议为truememoryStoreEvictionPolicy="LRU" 内存的替换算法FIFO 先进先出LRU 按时间计算LFU 按频率计算diskPersistent="false" 是否支持硬盘的持久化, 多个相同的项目共享数据diskExpiryThreadIntervalSeconds="120" 存储到硬盘中的时间,100秒,则如果下此JVM启动的时间间隔少于100则可以访问到前面的数据,否则访问不到--><defaultCachemaxElementsInMemory="4"eternal="true"timeToIdleSeconds="100"timeToLiveSeconds="200"overflowToDisk="false"memoryStoreEvictionPolicy="LFU"diskPersistent="false"diskExpiryThreadIntervalSeconds="15"/>
</ehcache>
Redis数据库来做缓存!K - V
练习:29道练习题实战
mybatis动态sql练习题(个人整理)smbms-ssm
https://blog.csdn.net/qq_38616503/article/details/107149495
Mybatis总结
聊聊Spring
https://spring.io/
SSM框架:MyBatis相关推荐
- ssm框架mybatis的作用
今天答辩: 老师问了我ssm框架,mybatis的作用 ssm框架是spring mvc,spring和mybatis框架的整合,是标准的mvc模式,讲整个系统划分为表现层,controller层,s ...
- SSM框架-MyBatis(一)
目录 1 MyBatis概述 1.1 框架 1.2 MyBatis在三层架构的位置 1.3 JDBC的不足 1.4 关于MyBatis 2 MyBatis入门程序 2.1 组件版本 2.2 MyBat ...
- [SSM框架]—Mybatis入门
文章目录 前言 Mybatis搭建 下载 环境 创建maven工程 创建Mybatis核心文件 驱动类driver-class-name 链接地址url 创建mapper接口 创建mybatis映射文 ...
- SSM框架-MyBatis(二)
目录 1 手写MyBatis框架(理解原理) 2 在web中应用MyBatis(使用MVC架构模式) 2.1 准备数据库表 2.2 实现步骤 2.3 事务处理 2.4 生命周期 2.5 当前程序存在的 ...
- SSM框架——Mybatis增删改查
目录 目录 环境配置 增删改查的实现 查询全部 查询单个ID 添加用户 修改用户 删除用户 增删改查-使用注解开发 思路流程:搭建环境-->导入Mybatis--->编写代码---> ...
- SSM框架——Spring+SpringMVC+Mybatis的搭建教程
一:概述 SSM框架在项目开发中经常使用到,相比于SSH框架,它在仅几年的开发中运用的更加广泛. Spring作为一个轻量级的框架,有很多的拓展功能,最主要的我们一般项目使用的就是IOC和AOP. S ...
- MyBatis框架学习 DAY_02:使用XML配置文件/多参数问题 / FOREACH /IF / #{}和${} / 创建SSM框架流程
XML文件配置SQL 1. 使用XML文件配置SQL语句 2. 关于多参数的问题 2. 练习 3. 动态SQL -- foreach 4. 动态SQL -- if 5. 关于#{}和${}格式的占位符 ...
- JavaWeb学习之路——SSM框架之Mybatis(三)
数据库配置和相关类创建看上篇:JavaWeb学习之路--SSM框架之Mybatis(二) https://blog.csdn.net/kuishao1314aa/article/details/832 ...
- SSM框架——使用MyBatis Generator自动创建代码
SSM框架--使用MyBatis Generator自动创建代码 这是通过命令行, 不用ide插件. 若在IDEA中通过插件generator, 还可以参考另一篇: IDEA搭建Spring+Spri ...
- SSM框架搭建(四) springmvc和mybatis的配置
SSM框架搭建(一) JDK和MAVEN环境搭建 SSM框架搭建(二) 创建MAVEN项目 SSM框架搭建(三) 数据库创建和MyBatis生成器自动生成实体类.DAO接口和Mapping映射文件 S ...
最新文章
- Hessian RPC示例和基于Http请求的Hessian序列化对象传输
- 自己搭建个对象存储服务难不难?
- 腾讯财付通漏洞遭***利用 威胁QQ彩钻等付费用户
- .NET 4.5 Task异步编程学习资料
- 再次记录 Visual Studio 2015 CTP 5 的一个坑
- 1859. 将句子排序
- Java CompletableFuture
- Microsoft Office Visio 2003画ER图
- 幅频特性和相频特性的物理意义
- 牛顿吼 苹果把老子头砸了 于是 爱翁发现 谭
- [干货] 一文看懂numpy.nonzero() 与 numpy.argwhere()非零元素处理
- 用APICloud开发仿微信聊天App制作经验分享
- Axmath:一款Word公式编辑神器
- windows10删除多余顽固输入法
- base64编码类------原始码(C#)
- 《工程伦理》网课第十章课后习题答案
- 成功解决 pycharm一直indexing
- 超级简洁的Python风格加解密
- 根据内核Oops 定位代码工具使用— addr2line 、gdb、objdump
- 基于微信小程序的图书销售商城系统源码