SSM框架:MyBatis
SSM框架:配置文件的。最好的方式:看官网文档
官网中文手册:https://mybatis.net.cn/
https://mybatis.org/mybatis-3/
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.11version>
dependency>
真正的力量在时间手里, 留下脚印比创造世界更难。
留下记忆,对数据进行长期存储,成为了文明延续的必要条件。
Dao层、Service层、Controller层
最重要的一点:使用的人多!
Spring SpringMVC SpringBoot
思路:搭建环境 --> 导入Mybatis --> 编写代码 --> 测试!
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')
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
idea 2022.1 创建maven卡死问题
关闭当前项目project -close 后 重新创建项目即可
<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.0modelVersion>
<groupId>com.qiagroupId>
<artifactId>Mybatis-StudyartifactId>
<packaging>pompackaging>
<version>1.0-SNAPSHOTversion>
<modules>
<module>mybatis-01module>
modules>
<dependencies>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.11version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
resources>
build>
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
properties>
project>
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>
<mappers>
<mapper resource="com/qia/dao/UserMapper.xml"/>
mappers>
configuration>
(此处注意mappers,是后续增加的配置)
工厂模式
读取配置文件把它加载成流
工厂类直接封装成工具类防止多次申请工厂而造成资源浪费
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 这个方法用于 获取SqlSession
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
}
此处的dao相当于以后的mapper
package com.qia.dao;
import com.qia.pojo.User;
import java.util.List;
public interface UserDao {
List<User> getUserList();
}
由原来的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代码解耦合
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qia.dao.UserDao">
<select id="getUserList" resultType="com.qia.pojo.User">
select * from user
select>
mapper>
在UserDaoImpl页面Alt + Insert点击测试Test生成
项目代码规范
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 {
@Test
public 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);
}
//用完之后,关闭SqlSession
sqlSession.close();
}
}
遇到的问题:
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
resources>
build>
如果报了UTF8字符集编码错误
可以pom.xml配置一下
<properties>
<project.build.sourceEncoding>UTF-8project.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 {
@Test
public 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 userList = sqlSession.selectList("com.qia.dao.UserDao.getUserList");
for (User user : userList) {
System.out.println(user);
}
// 第三步:用完之后,关闭SqlSession
sqlSession.close();
}
}
//方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
/*
既然有了SqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实例了。SqlSession完全包含了面向数据库执行SQL命令的所有方法。你可以通过SqlSession实例来直接执行已映射的SQL语。
诚然,这种方式能够正常工作,并且对于使用旧版本Mybatis的用户来说也比较熟悉。但现在有了一种更简洁的方式————使用正确描述每个语句的参数和返回值的接口(比如UserMapper.class,即对应接口的类对象),你现在不仅可以执行更清晰和类型安全的代码,而且还不用担心易错的字符串你字面值以及强制类型转换
*/
dao和daoimpl --> mapper(接口:数据库操作的方法)和mapper.xml(sql)
现在的mybatis必须指定命名空间namespace的唯一绑定
SqlSessionFactoryBuilder --> SqlSessionFactory --> SqlSession
直上青天揽日月,欲倾东海洗乾坤(3/32)
namespace中的包名要和接口的包名一致 (Dao/Mapper)
绑定异常一定要反复确认检查 mapper.xml 文件的 namespace 和 mybatis-config.xml 文件的 mapper注册(几乎肯定是这里错了)
select查询语句
三步走
1.编写接口
2.编写接口对应的mapper.xml中的sql语句
3.编写测试方法
上面第三个是只有写新的mapper时才要注册,即 二 的 小总结里的步骤
红框内代码不变,变得是绿框里的
代码实现三步走
注意点:
增删改查需要提交事务!
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);
}
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qia.mapper.UserMapper">
<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>
<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>
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id};
delete>
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;
import java.util.List;
public class UserMapperTest {
@Test
public 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 userList = sqlSession.selectList("com.qia.mapper.UserDao.getUserList");
for (User user : userList) {
System.out.println(user);
}
}catch (Exception e){
e.printStackTrace();
}finally {
// 第三步:用完之后,关闭SqlSession
sqlSession.close();
}
//方式二:sqlSession.对应方法(不推荐使用(还要方法与方法对应 getUserList --> selectList ,要解耦的思想))
/*
既然有了SqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实例了。SqlSession完全包含了面向数据库执行SQL命令的所有方法。你可以通过SqlSession实例来直接执行已映射的SQL语。
诚然,这种方式能够正常工作,并且对于使用旧版本Mybatis的用户来说也比较熟悉。但现在有了一种更简洁的方式————使用正确描述每个语句的参数和返回值的接口(比如UserMapper.class,即对应接口的类对象),你现在不仅可以执行更清晰和类型安全的代码,而且还不用担心易错的字符串你字面值以及强制类型转换
*/
}
@Test
public void getUserById_test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
try {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.getUserById(1);
// User user = mapper.getUserById(0);//null
System.out.println(user);
}catch (Exception e){
e.printStackTrace();
}finally {
sqlSession.close();
}
}
//增删改需要提交事务,否则数据库数据不会变。如果你的表用的是Myisam引擎,不支持事务,会有数据变化的
@Test
public 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();
}
}
@Test
public 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();
}
}
@Test
public 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();
}
}
}
// ↓ ========== ========== 将上面的方法改成利用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的好处,不需要知道数据库里有什么 ========== ==========
<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>
@Test
public 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();
}
}
@Test
public 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();
}
}
假设实体类,或者数据库中的表,字段或者参数过多,可以考虑使用Map
用map你要用什么参数就写什么参数;用实体类的话new的时候要写所有的成员
当字段可以设为空时,插入时值为空的字段,就可以省略不写了
使用实体类传参,实例化实体类时需要把值设为空,实体类是全参构造器
这种方法就直接免了实体类,着用一个方法代替了一系列的方法
不正规,但万能
Map传递参数,直接在sql中取对象的key即可!【parameterType=“Map”】
对象传递参数,直接在sql中取对象的属性即可!【parameterType=“Object”】
只有一个基本类型参数的情况下,可以直接在sql中取到
多个参数用Map,或者注解!!!
接口
//根据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
@Test
public 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();
}
}
用通配符拼接字符串
法一:拼好再传
法二:传后再拼
代码实现
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>
@Test
public 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();
}
}
@Test
public 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预编译
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>
前面的都是mybatis的基础能力,配置及之后的才是真正需要掌握的
https://mybatis.net.cn/
configuration(配置):
(必须按以下顺序,否则会报错)
properties(属性)
settings(设置)
typeAliases(类型别名)
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)
databaseIdProvider(数据库厂商标识)
mappers(映射器)
将mybatis-01项目 复制粘贴到 mybatis-02
可以配置多个环境,但每个 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);
学会使用配置多套运行环境!
<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>
注意各项配置的书写顺序
我们可以通过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 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>
也可以这样写
<properties resource="db.properties">
<property name="username" value="root"/>
<property name="password" value="123456"/>
properties>
多种设置properties的方法,优先级问题:
首先读取在properties元素体内指定的属性
根据properties元素中的resource属性读取类路径下的属性文件,或根据url属性指定的路径读取属性文件,并覆盖之前读取过的同名属性
最后读取作为方法参数传递的属性,并且覆盖之前读取过的同名属性
优先级高的先执行,内部配置就被后执行的外部覆盖了
即:
类型别名是为 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 {
}
不建议使用别名,简洁但不方便维护
这是Mybatis中极为重要的调整设置,他们会改变Mybatis的运行时行为
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改为一致!并且放在同一个包下!
不同作用域和生命周期类是至关重要的,因为错误的使用会导致非常严重的并发问题。
我们可以先画一个流程图,分析一下Mybatis的执行过程!
这里面的每一个Mapper,就代表一个具体的业务
新建一个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>
解决方法:
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
结果集映射
id name pwd
id name password
<resultMap id="UserMap" type="User">
<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 用于复杂的结果集,简单单表查询没必要使用
什么字段不一样就映射哪个字段就可以了
实体类间,一对多,多对一,多对多的关系
多个学生关联一个老师
一个老师包含多个学生,是集合
resultType 自动映射
ResultMap 手动映射
先回顾一下代码,拷贝到新模块
如果一个数据库操作,出现了异常,我们需要排错,日志就是最好的助手!
曾经:sout、debug
现在:日志工厂
environment --> setting --> logImpl
在Mybatis中具体使用哪个日志实现,在设置中设定
STDOUT_LOGGING标准日志输出
在mybatis核心配置文件中,配置我们的日志!
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
settings>
Log4j
类未加载到,未下载
什么是Log4j?
1.先导入log4j的包
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
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);
@Test
public void testLog4j() {
logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");
}
@Test
public void getUserById_test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
try {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.getUserById(1);
// User user = mapper.getUserById(0);//null
System.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控制控制台输出和形成日志文件等
思考:为什么要分页?
减少数据的处理量!!!
节约资源优化查询性能,避免一次查询大量数据
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
DOCTYPE mapper
PUBLIC "-//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">
<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 {
@Test
public 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();
}
}
}
开发中不建议使用
是内存分页
不再使用SQL进行分页
1.接口
//分页2
List<User> getUserByRowBounds();
2.mapper.xml
<select id="getUserByRowBounds" resultMap="UserMap">
select * from user
select>
3.test
@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(1, 2);
//通过Java代码层面实现分页
// List 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();
}
了解即可,万一以后公司的架构师,说要使用,你需要知道它是什么东西!!
关于接口的理解:
三个面向的区别:
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 {
@Test
public 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 客户端)
我们可以在工具类创建的时候实现自动提交事务!
将工具类的getSqlSession方法修改一下
openSession设置为true
即默认开启提交
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
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);
}
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 {
@Test
public void test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//底层主要应用反射
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.deleteUser(6);
sqlSession.close();
}
//getUsers
// List 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(" ")注解
#{} 和 ${} 区别:
Lombok项目是一个Java库,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。
使用步骤:
Settings --> Plugins
重启IEDA
idea官方支持 2022版本以后 默认内置了lombok插件,无需再下载
安装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
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');
一般一对多的关系,都是由多端来维护关系
所以学生新增成员属性
resource资源目录下,建多级目录,用 “ / ”
1.拷贝mybatis核心配置文件的代码
2.删除中间部分的代码,剩下面的
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
configuration>
3.所有 config --> mapper
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper>
mapper>
要修改 5 处
4.写上命名空间namespace
<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”/> 不能用通配符会报错
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 {
@Test
public void getTeacher_test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
Teacher teacher = mapper.getTeacher(1);
System.out.println(teacher);
sqlSession.close();
}
}
<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"/>
<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:实体类中字段
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 tname
from student s,teacher t
where 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>
比如:一个老师有多个学生!
对于老师而言,就是一对多的关系!
环境搭建,和刚才一样
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;
}
<select id="getTeacher" resultMap="TeacherStudent">
select t.id tid, t.name tname, s.id sid, s.name sname
from student s, teacher t
where s.tid = t.id and t.id=#{tid}
select>
<resultMap id="TeacherStudent" type="com.qia.pojo.Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="com.qia.pojo.Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
collection>
resultMap>
<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id=#{tid};
select>
<resultMap id="TeacherStudent2" type="com.qia.pojo.Teacher">
<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};
动态SQL就是指根据不同的条件生成不同的SQL语句
利用动态SQL这一特性可以摆脱这种痛苦。
动态SQL元素和JSTL或基于类似XML的文本处理器相似。在Mybatis之前的版本中,有很多元素需要花时间了解。Mybatis 3大大精简了元素种类,现在只需要学习原来的一半的元素便可以了。Mybatis采用功能强大的基于OGNL的表达式来淘汰其他大部分元素
if
choose (when,otherwise)
trim (where, set)
foreach
数据库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);
}
DOCTYPE mapper
PUBLIC "-//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 {
@Test
public 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; 改成 &
//查询博客 IF
List<Blog> queryBlogIF(Map map);
<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>
相当于 switch - case
//查询博客 Choose
List<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 author = #{author}
when>
<otherwise>
and views =# {views}
otherwise>
choose>
where>
select>
@Test
public 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,只会选择其一,优先走第一条满足的条件
注意调整判断条件的位置
<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>
set可以多个条件成立,where只可以一个
set元素会动态前置set关键字,同时也会删除无关的逗号。
(建议逗号都写上,无关的,运行时会自动删除,没写的话,需要用的时候不会给你自动添加)
set语句至少要有一个值被满足,否则会报错(update blog直接运行报错)
//更新博客
int updateBlog(Map map);
<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>
@Test
public 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();
}
< trim prefix=“” suffix=“” suffixOverrides=“” prefixOverrides=“”>< /trim>
<trim prefix="WHERE" prefixOverrides="AND |OR ">trim>
AND |OR 的空格别忘了
所谓的动态SQL,本质还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码
if where set choose when,本质是 if
在官方中文文档的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标签引用即可
<select id="queryBlogIF" parameterType="map" resultType="blog">
select * from mybatis.blog
<where>
<include refid="sql-if-title-author"/>
where>
select>
完整代码
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qia.mapper.BlogMapper">
<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 {
@Test
public 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 的另一个常见使用场景是对集合进行遍历(尤其是在构建 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>
foreach 元素的功能非常强大,它允许你指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符,看它多智能!
提示 你可以将任何可迭代对象(如 List、Set 等)、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时,index 是当前迭代的序号,item 的值是本次迭代获取到的元素。当使用 Map 对象(或者 Map.Entry 对象的集合)时,index 是键,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>
@Test
public 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();
}
bind 元素允许你在 OGNL 表达式以外创建一个变量,并将其绑定到当前的上下文。比如:
<select id="selectBlogsLike" resultType="Blog">
<bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />
SELECT * FROM BLOG
WHERE title LIKE #{pattern}
select>
动态SQL就是拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
建议:
先在Mysql中写出完整的SQL,再对应的去修改成为我们的动态SQL实现通用即可
查询 : 连接数据库,耗资源
一次查询的结果,给他暂存一个可以直接取到的地方 --> 内存:缓存
我们再次查询的相同数据的时候,直接走缓存,不走数据库了
1、什么是缓存[Cache]?
2、为什么使用缓存?
3、什么样的数据可以使用缓存?
缓存策略
LRU – 最近最少使用:移除最长时间不被使用的对象。
FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用:更积极地基于垃圾收集器状态和弱引用规则移除对象。
默认的清除策略是 LRU。
测试步骤:
1、基本框架
2、开启日志
3、测试在一个Session中查询两次记录
4、查看日志输出
缓存失效的情况:(读写操作,读,读缓存,写,刷新缓存)
即使这里查询和更新的数据不是同一条,缓存也还是会被刷新,因为缓存是整体的
小结:
一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!
一级缓存就是一个map
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="db.properties">properties>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
settings>
<typeAliases>
<typeAlias type="com.qia.pojo.User" alias="user">typeAlias>
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);
}
DOCTYPE mapper
PUBLIC "-//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 {
@Test
public 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();
}
}
默认情况下,只启用了本地的会话缓存(一级缓存),它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存,只需要在你的 SQL 映射文件中添加一行:
<cache/>
步骤:
1、在核心配置文件中开启全局缓存
<settings>
<setting name="cacheEnabled" value="true"/>
settings>
2、在当前mapper.xml文件中开启二级缓存
<setting name="cacheEnabled" value="true"/>
也可以自定义参数
<cache
eviction="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 {
@Test
public 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();
}
@Test
public 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{}
程序运行的时候,会产生很多对象,而对象信息也只是在程序运行的时候才在内存中保持其状态,一旦程序停止
小结:
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存
要在程序中使用ehcache,先要导包!
<dependency>
<groupId>org.mybatis.cachesgroupId>
<artifactId>mybatis-ehcacheartifactId>
<version>1.2.1version>
dependency>
在mapper中指定使用我们的ehcache缓存实现!
<cache type="org.mybatis.caches.ehche.EhcacheCache"/>
ehcache.xml
<ehcache>
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="4"
eternal="true"
timeToIdleSeconds="100"
timeToLiveSeconds="200"
overflowToDisk="false"
memoryStoreEvictionPolicy="LFU"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="15"
/>
ehcache>
Redis数据库来做缓存!K - V
mybatis动态sql练习题(个人整理)smbms-ssm
https://blog.csdn.net/qq_38616503/article/details/107149495