MyBatis
SSM框架
环境:
- JDK1.8
- Mysql 5.7 或者升版本
- maven3.6.1或者升版本
- IDEA
回顾:
- JDBC
- Mysql
- Java基础
- Maven
- Junit
**框架:**配置文件的。学习框架最好的方式:看官方文档;
**Mybatis3官方开发文档:**https://mybatis.org/mybatis-3/zh/getting-started.html
1.简介
1.1 什么是MyBatis
-
MyBatis 是一款优秀的持久层框架
-
它支持自定义 SQL、存储过程以及高级映射。
-
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
-
MyBatis 可以通过简单的XML或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
-
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604),并且改名为MyBatis 。2013年11月迁移到Github。
-
iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAOs)
获取方式:
- gitHub搜索下载 https://github.com/mybatis/mybatis-3/releases
- Maven仓库 https://mvnrepository.com/search?q=mybatis
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
1.2 持久化
持久化是一个动作
数据持久化
-
持久化就是
将程序的数据在持久状态和瞬时状态 转化的过程。
-
内存:断电即失
-
持久化方式:数据库(jdbc),io文件持久化。
-
生活:冷藏 罐头
为什么需要持久化
- 有一些对象,不能让他丢掉。
- 内存太贵了
1.3 持久层
持久层是一个概念
Dao层 ,Service层, Controller层…
- 完成持久化工作的代码块
- 层界限十分明显
1.4 为什么需要Mybatis?
- 帮助程序员将数据存入到数据库中
- 方便
- 传统的JDBC代码太复杂了。简化,框架。自动化
- 不用Mybatis也可以,更容易上手。
- 优点:
- 简单易学
- 灵活
- 解除sql与程序代码的耦合
- 提供映射标签,支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签,支持对象关系组建维护
- 提供xml标签,支持编写动态sql。
最重要的一点:是用的人多,Spring SpringMVC SpringBoot
2.第一个Mybatis程序
思路:搭建环境–>导入Mybatis包–>编写代码–>测试
项目结构:
2.1 搭建环境
创建数据库和表:
CREATE DATABASE `mybatis`
USE mybatis
CREATE TABLE `user`(
`id` INT(20) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `user`(`name`,`pwd`)VALUES
('狂神','123456'),
('张三','123456'),
('李四','123456');
新建项目:
1.新建一个普通的maven项目
2.删除src目录,便于后面创建子模块
3.导入maven依赖
导入mysql、mabatis、junit包
在build中配置resources,来防止我们资源导出的失败的问题
在父工程的pom.xml中
<?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>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!--父工程-->
<groupId>org.example</groupId>
<artifactId>mybatis</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>simpleDemo</module>
</modules>
<dependencies>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
</dependencies>
<!--在build中配置resources,来防止我们资源导出的失败的问题-->
<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>
</project>
2.2 创建一个子模块
(1)编写Mybatis的核心配置文件
在resources目录下创建mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!--每一个Mapper都需要在mybatis-config.xml中注册-->
<!--易错:分隔出采用斜杠,不是点-->
<mappers>
<mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>
</configuration>
(2)编写Mybatis工具类
获取SqlSession对象(相当于connection对象),封装成工具类。
在utils包下建立工具类MybatisUtils
package com.kuang.utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
//工具类
//需要获得数据库操作对象SqlSession
//SqlSessionFactory---->SqlSession
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;//提升作用域
static {
//使用Mybatis的第一步:获取SqlSessionFactory对象
try {
String resource = "mybatis-config.xml";
InputStream inputStream =Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//有了SqlSessionFactory以后,我们可以从中获得SqlSession的实例
//SqlSession提供了在数据库执行 SQL命令 所需的所有方法。
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
(3)创建实体类
在pojo包下面创建实体类User
package com.kuang.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 + '\'' +
'}';
}
}
(4)dao层:UserDao接口和UserMapper.xml
持久层操作数据库执行sql
UserDao接口,UserMapper.xml采用配置文件形式 替换 以前的UserDaoImpl实现类实现操作数据库
UserDao接口:
public interface UserDao {
public List<User> getUserList();
}
UserMapper.xml:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserDao">
<select id="getUserList" resultType="com.kuang.pojo.User">
select * from `user`;
</select>
</mapper>
(5)测试
在test目录下建立对应的dao包:test/com.kuang.dao
再建立UserDaoTest类添加测试方法
1.先获取SqlSession对象
2.利用SqlSession调用Mapper得到UserDao对象
3.操作数据库,返回与实体类对应的结果
package com.kuang.dao;
import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void test(){
//获取SqlSession对象
SqlSession sqlSession= MybatisUtils.getSqlSession();
//操作数据库 方式一:getMapper 推荐使用
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> userList = userDao.getUserList();
for (User user : userList) {
System.out.println(user);
}
//关闭SqlSession
sqlSession.close();
}
}
2.3 可能会遇到的问题
1.配置文件getUserMapper.xml没有注册
每一个Mapper.xml都需要在Mybatis核心配置文件mybatis-config.xml中注册
注册的资源路径,采用斜杠,而不是点 分隔
<!--每一个Mapper都需要在mybatis-config.xml中注册-->
<!--易错:分隔出采用斜杠,不是点-->
<mappers>
<mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>
2.Maven导出资源问题,先放到外层pom.xml,如果没生效,子模块的pom.xml再放一次
<!--在build中配置resources,来防止我们资源导出的失败的问题-->
<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>
3.注意Mapper.xml文件中:绑定接口、方法名、返回类型
错误:
Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep
解决方法:之前在pom.xml文件中删除了下面代码,现在加上:
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
2.4 运行思路
- 连接数据库,导入jar包(mysql、mabatis、junit、此处还可以配置好maven的资源导出问题build)
- 操作数据库需要一个SqlSession对象,为此建造了一个工具类utils/MybatisUtils,编写了配置文件mybatis-config.xml(配置文件一上来连接了数据库,仅需修改选项参数;删除mapper.xml的注册配置)
- 创建实体类User
- 创建接口UserDao,并创建getUserList()抽象方法
- 写Mapper配置文件UserMapper.xml,代替原来实现类Impl:namespace绑定接口,标签id绑定接口方法,标签体专注sql,返回类型专注返回值类型;每一个mapper写完需要到mabatis-config.xml中去注册
3.CURD
namespace:
Mapper.xml中使用的namespace中分包名,要和Dao/Mapper接口中的包名一致。
过程:
完成MyBatis的实现后,操作数据库:
- 所有的操作只和“接口”和“配置文件”有关
- 实体类、工具类、mybatis.config.xml不在需要改变
- mapper.xml只需要去mybatis.config.xml中配置一次,mapper.xml中只需要有一个
<mapper>
dao层:
UserMapper接口(从UserDao改名为UserMapper)
UserMapper配置文件(相当于实体类UserMapperImpl)
Mapper.xml元素概念
- id: 就是对应的nsmespace中的方法名
- resultType: Sql语句执行的返回值
- parameterType: 参数类型
步骤:
3.1编写接口
在UserMapper中
public interface UserMapper {
//根据id查询用户
User getUserById(int id);
//insert用户
int insertUser(User user);
//修改用户
int updateUser(User user);
//删除用户
int deleteUserById(int id);
}
3.2编写对应的mapper.xml中的sql语句
在UserMapper.xml中
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserMapper">
<!--根据id查询用户-->
<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
select * from `user` where `id`=#{id};
</select>
<!--Insert用户-->
<insert id="insertUser" parameterType="com.kuang.pojo.User">
insert into `user`(`name`,`pwd`) values ('zhaoliu','zhao123456');
</insert>
<!--修改用户-->
<update id="updateUser" parameterType="com.kuang.pojo.User">
update `user` set `name`=#{name},`pwd`=#{pwd} where id=#{id};
</update>
<!--根据id删除用户-->
<delete id="deleteUserById" parameterType="int">
delete from `user` where id=#{id};
</delete>
</mapper>
3.3测试
在UserMapperTest中
public class UserMapperTest {
//根据id查找用户
@Test
public void getUserById() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class); //相当于获得实现类对象
User user = mapper.getUserById(1);
System.out.println(user);
sqlSession.close();
}
//插入用户
@Test
public void insertUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.insertUser(new User(0, "liu", "liu123"));
if(i>0){
System.out.println("插入成功");
}
//【关键】Mybatis中增删改查,需要提交事务才能生效
sqlSession.commit();
sqlSession.close();
}
//修改用户
@Test
public void updateUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.updateUser(new User(1, "liu", "liu123"));
if(i>0){
System.out.println("修改成功");
}
//【关键】Mybatis中增删改查,需要提交事务才能生效
sqlSession.commit();
sqlSession.close();
}
//删除用户
@Test
public void deleteUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.deleteUserById(4);
if(i>0){
System.out.println("删除成功");
}
//【关键】Mybatis中增删改查,需要提交事务才能生效
sqlSession.commit();
sqlSession.close();
}
}
在Mapper.xml中,对象中的属性,可以直接取出来,与实体类对应
Mybatis增删改必须提交事务才能生效
注意SqlSession对象使用完后关闭
3.4遇到的问题
-
Mapper.xml的curd标签不要匹配错
-
Mapper.xml需要到resource中的mybatis-config.xml中注册,路径要用‘/’,前面的命名空间使用的是包名 ‘.’
<mappers> <mapper resource="com/kuang/dao/UserMapper.xml"/> </mappers>
-
程序配置文件mybatis-config.xml必须符合规范
-
NullPointerException,没有注册到资源,MybatisUtils中提升作用域内外定义变量
sqlSessionFactory
public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory;//提升作用域 static { //使用Mybatis的第一步:获取SqlSessionFactory对象 try { String resource = "mybatis-config.xml"; InputStream inputStream =Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } //有了SqlSessionFactory以后,我们可以从中获得SqlSession的实例 //SqlSession提供了在数据库执行 SQL命令 所需的所有方法。 public static SqlSession getSqlSession(){ return sqlSessionFactory.openSession(); } }
-
输出的xml文件如果存在乱码,删除即可
-
maven资源导出问题,pom.xml中加
<build>
3.5万能的Map
- Mapper.xml中参数类型如果为实体类,在测试时需要初始化所有字段,传递整个实体类对象;如果sql操作只需要少量字段,则不合适;
实体类中的字段名和参数中字段名必须一致。
在接口方法中,参数直接传递实体类User;
//insert用户
int insertUser(User user);
编写sql语句的时候,需要传递参数类型,参数类型为实体类"com.kuang.pojo.User"
<!--Insert用户-->
<!--使用实体类:test中传入的“对象中的属性”必须和“数据库表中字段名”对应-->
<insert id="insertUser" parameterType="com.kuang.pojo.User">
insert into `user`(`name`,`pwd`) values (#{name},#{pwd});
</insert>
在使用方法的时候,需要创建实体类User对象,赋值所有属性
使用实体类:test中传入的“对象中的属性”必须和“数据库表中字段名”对应
//插入用户
@Test
public void insertUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.insertUser(new User(0, "田七1", "tian123456"));
if(i>0){
System.out.println("插入成功");
}
//【关键】Mybatis中增删改查,需要提交事务才能生效
sqlSession.commit();
sqlSession.close();
}
- 考虑用map作为参数,map中的key值也可以自定义,只需要在测试类中定义相应的key值。
在接口方法中,参数直接传递Map;
//insert用户
int insertUser(User user);
编写sql语句的时候,需要传递参数类型,参数类型为Map
<!--Insert用户-->
<!--使用万能的Map:test中传入的“map的key值”可以自定义,无需和“数据库表中字段名”对应-->
<insert id="insertUser2" parameterType="map">
insert into `user`(`name`,`pwd`) values (#{username},#{password});
</insert>
在使用方法的时候,需要创建实体类User对象,赋值所有属性
使用万能的Map:test中传入的“map的key值”可以自定义,无需和“数据库表中字段名”对应
//插入用户
@Test
public void insertUser2(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String,Object> map=new HashMap<>();
map.put("username","田七");
map.put("password","tian123456");
int i = mapper.insertUser2(map);
if(i>0){
System.out.println("插入成功");
}
//【关键】Mybatis中增删改查,需要提交事务才能生效
sqlSession.commit();
sqlSession.close();
}
传递参数类型:
- 对象传递参数:直接在sql中取出对象的属性(实体类定义时属性和数据库表字段名一一对应)【parameterType=“Object”】
- Map传递参数:直接在sql中取出key即可,map的key值无需和数据库表字段名一致,【parameterType=“map”】
- 传递参数类型只有一个,且为基本类型,如int,可省略不写,直接在sql中取到。
多个参数用map,或者注解
返回结果类型:当为实体类对象时需要写,当为int时可省略。
3.6模糊查询
1.test中传递的字符串采用拼接,传递通配符%
容易造成sql注入,用户传入的值一般我们要求只能为值,不能拼接字符串
List<User> userList = mapper.getUserLike("%李%");
2.在Mapper.xml的sql中拼接,使用通配符,推荐
select * from `user` where name like "%"#{name}"%"
4.配置解析
核心配置文件mybatis-config.xml
【注意】在mybatis-config.xml的<configuration>
标签中,所有配置标签有顺序
4.1环境配置(enviroments)
- MyBatis 可以配置成适应多种环境
- 不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
事务管理器(transactionManager)
在 MyBatis 中有两种类型的事务管理器(也就是 type="[JDBC|MANAGED]"):
-
JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施,它依赖从数据源获得的连接来管理事务作用域。
-
MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接,而是让容器来管理事务的整个生命周期(比如 JEE 应用服务器的上下文)。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭,因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。
数据源(dataSource)
是否使用连接池
Mybatis默认的事务管理器就是JDBC,连接池:POOLED
学会使用配置多套运行环境。
4.2属性(properties)
我们可以通过properties属性来实现引用配置文件。
mybatis-config.xml使用到的属性可以在外部进行配置,并可以进行动态替换:
-
既可以在典型的 Java 属性文件中配置这些属性【db.properties】
db.properties
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8 username=root password=123456
mybatis-config.xml中引入配置文件并使用
<properties resource="db.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 元素的子元素中设置
<properties resource="db.properties"> <property name="username" value="root"/> <!--可以动态增加属性--> <property name="password" value="123456"/> </properties>
mybatis-config.xml的<dataSource>
属性配置:
- 可以直接配置
- 可以全部放到db.properties中,再在mybatis-config.xml中引用
- 可以部分放到db.properties中,mybatis-config.xml中
<properties>
可以动态增加属性(如果两个文件有同一个字段,优先使用外部配置文件。properties里面的属性优先)
4.3类型别名(typeAliases)
- 类型别名可为 Java 类型设置一个缩写名字。
- 它仅用于 XML 配置,意在降低冗余的全限定类名书写
- 常用于在mybatis-config.xml中,为实体类起别名,简化在Mapper.xml中对实体类引用包名的书写
(1)为具体实体类指定类型别名
<typeAliases>
<typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>
在Mapper.xml中使用
<select id="getUserList" parameterType="map" resultType="User">
select * from `user` where `name` like "%"#{name}"%";
</select>
(2)指定一个包名
MyBatis会在包名下面搜索需要的实体类(JavaBean)
扫描实体类的包,它的默认别名就为这个类的类名,首字母小写
<typeAliases>
<package name="com.kuang.pojo"/>
</typeAliases>
在Mapper.xml中使用
<select id="getUserList" parameterType="map" resultType="user">
select * from `user` where `name` like "%"#{name}"%";
</select>
(3)自定义类型别名
-
为具体实体类指定类型别名,可以自定义包名
-
指定一个包名,别名默认类名,且首字母小写。但可以通过在实体类上增加注解自定义包名
//实体类 @Alias("user") public class User { ... }
4.4映射器(mapper)
MapperRegistry:每一个Mapper.xml都需要到mybatis-config.xml中的<mapper>
中去配置
配置方法:
1.使用resource绑定注册
注意路径采用 反斜杠 分隔
<mappers>
<mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>
2.使用class文件绑定注册
<mappers>
<mapper class="com.kuang.dao.UserMapper"/>
</mappers>
注意点:
- 接口和他的Mapper配置文件必须同名!
- 接口和他的Mapper配置文件必须在同一个包下!(方式一Mapper.xml随便放)
3.使用扫描包进行注册绑定
<mappers>
<package name="com.kuang.dao"/>
</mappers>
注意点:
- 接口和他的Mapper配置文件必须同名!
- 接口和他的Mapper配置文件必须在同一个包下!(方式一随便放)
4.5设置(enviroments)
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。
数据库命名与实体类字段 转换,需要Mabatis框架的设置支持
4.6其他
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- mybatis-generator-core
- mybatis-plus
- 通用mapper
4.7生命周期和作用域
生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题
SqlSessionFactoryBuilder:
-
这个类可以被实例化、使用和丢弃;一旦创建了SqlSessionFactory,就不再需要它了
-
设为局部变量
SqlSessionFactory:
- 说白了就是可以想象为:数据库连接池。
- 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例
- SqlSessionFactory 的作用域是全局作用域(应用作用域 ApplicationContext)
- 最简单的就是使用单例模式或者静态单例模式。
SqlSession:
- 连接池的一个请求。
- SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的作用域是请求或方法作用域。
- 用完之后赶紧关闭,否则资源被占用。
这里的每一个Mapper,就代表一个具体的业务!
5.ResultMap结果集映射
要解决的问题:属性名和字段名不一致
5.1 实体类属性和数据库字段不匹配问题
数据库字段:
实体类属性:
public class User {
private int id;
private String name;
private String password; //字段和属性不一致
}
测试字段不一致问题:
Mapper.xml
<!--根据id查询用户-->
<select id="getUserById" parameterType="_int" resultType="com.kuang.pojo.User">
select * from `user` where `id`=#{id};
</select>
查询结果:password属性为null
解决办法:
-
sql查询字段起别名 pwd as password
select id,name,pwd as password from mybatis.user where id = #{id}
-
结果集映射resultMap,属性名和字段名映射
5.2 resultMap
结果集映射
实体类User: id name pwd
数据库user表:id name password
在Mapper.xml中配置resultMap
<mapper namespace="com.kuang.dao.UserMapper">
<!--结果集映射:可以只映射不一致的字段和属性-->
<!--Column:数据库中的字段,properties实体类中的属性-->
<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>
</mapper>
resultMap
元素时MyBatis中最重要的最强大的元素。- ResultMap 的设计思想是,对简单的语句做到零配置,对于复杂一点的语句,只需要描述语句之间的关系就行了。
ResultMap
的优秀之处——你完全可以不用显式地配置它们,可以只映射不一致的字段和属性
6.日志
如果一个数据库操作,出现了异常,我们需要排错。日志就是最好的助手。
曾经:sout 、debug
现在:日志工厂
- SLF4J
- LOG4J 【掌握】
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING 【掌握】
- NO_LOGGING
在mybatis-config.xml中配置<setting name="logImpl" value=""/>
在Mybatis中具体使用哪一个日志实现,在设置中设定。
6.1.STDOUT_LOGGING标准日志输出
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
【注意】书写日志不要有空格
STDOUT_LOGGING日志只需要配置一下setting,就能使用。
6.2.LOG4J 拓展日志输出
什么是LOG4J:
- Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是**控制台、文件、**GUI组件等;
- 我们也可以控制每一条日志的输出格式;
- 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
- 可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
1.先导出log4j的包
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
2.在resources目录下创建log4j.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/kuang.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.sql.PreparedStatement=DEBUG
3.配置log4j为日志实现
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
4.Log4j的使用,直接测试运行刚才的查询
简单实用:
1.在要使用Log4j的类中,导入包import org.apache.log4j.Logger;
2.日志对象,参数为当前类的class
3.可以设置日志级别
import org.apache.log4j.Logger; //导入包
public class log4j{
static Logger logger=Logger.getLogger(log4j.class); //获取当前类的反射
@Test
public void testLog(){
logger.info("info:进入selectUser方法");
logger.debug("debug:进入selectUser方法");
logger.error("error: 进入selectUser方法");
SqlSession session= MybatisUtils.getSqlSession();
UserMapper mapper = session.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
session.close();
}
}
7.分页
思考:为什么要分页?
- 减少数据的处理量
7.1 sql层面limit实现分页
1.接口
//分页查询
List<User> getUserByLimit(Map<String,Integer> map);
2.Mapper.xml
<!--结果集映射-->
<!--Column:数据库中的字段,properties实体类中的属性-->
<resultMap id="UserMap" type="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>
3.测试
//分页查询
@Test
public void getUserByLimit(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Map<String,Object> map=new HashMap<>();
map.put("startIndex",0);
map.put("pageSize",3);
List<User> userList = mapper.getUserByLimit(map);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
7.2 使用RowBounds实现分页
1.接口
//分页查询
List<User> getUserByRowBounds();
2.Mapper.xml
<!--结果集映射-->
<!--Column:数据库中的字段,properties实体类中的属性-->
<resultMap id="UserMap" type="User">
<!--可以只映射不一致的字段和属性-->
<!--<result column="id" property="id"/>-->
<!--<result column="name" property="name"/>-->
<result column="pwd" property="password"/>
</resultMap>
<!--分页查询-->
<select id="getUserByRowBounds" parameterType="map" resultMap="UserMap">
select * from `user` limit #{startIndex},#{pageSize};
</select>
3.测试
//RowBounds分页查询
@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
int currentPage=2; //第几页
int pageSize=2; //每页显示几个
RowBounds rowBounds = new RowBounds((currentPage - 1) * pageSize, pageSize);
List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds", null, rowBounds);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
7.3 分页插件
MyBatis分页插件 PageHelper
https://pagehelper.github.io/
了解即可,万一以后公司的架构师,说要使用,你需要知道它是什么东西。
8.使用注解开发
8.1面向接口编程
-
大家之前都学过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口 编程
-
根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
-
在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下, 各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
-
而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按 照这种思想来编程
关于接口的理解:
-
接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
-
接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
-
接口应有两类:
- 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class)
- 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface)
-
一个个体可能有多个抽象面,抽象体和抽象面是有区别的。
三个“面向”区别:
- 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法
- 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现
- 接口设计与非接口设计是针对复用技术而言的,与面向对象和面向过程不是一个问题,更多的体现是对系统整体的架构
8.2利用注解开发
- mybatis最初配置信息是基于XML,映射语句(SQL)也是定义在XML中的。到Mybatis3提供了新的基于注解的配置。
- 不幸的是,Java注解的表达力和灵活性十分有限。最强到的MyBatis映射并不能用注解来构建,所以真实项目开发尽量少用
- Sql类型主要分成:
- @Select()
- @Update()
- @Insert()
- @Delete()
- **利用注解开发,就不需要Mapper.xml映射文件了。**利用在Mapper接口中注解 代替 Mapper.xml
1.在我们的接口中直接添加注解
//查询所有用户
@Select("select * from user")
List<User> getUserList();
2.记得每个Mapper都要去mybatis-config.xml核心配置文件中注册
利用mapper.xml时可以采用三种注册方式,利用注解开发只能使用class绑定接口
<mappers>
<mapper class="com.kuang.dao.UserMapper"/>
<!--<mapper resource="com/kuang/dao/UserMapper.xml"/>-->
<!--<package name="com.kuang.dao"/>-->
</mappers>
3.测试
//查找所有用户
@Test
public void getUserList() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
4.查看Debugben本质
在test中打断点Debug
5.本质上利用了jvm的动态代理机制
6.Mybatis详细执行流程
8.3 采用注解CURD
可以改造MybatisUtils工具类的getSession( ) 方法,开启自动提交;但是实际开发中一般不采用自动提交
public static SqlSession getSession(boolean flag){
return sqlSessionFactory.openSession(flag);
}
UserMapper接口:
//根据id查询用户
@Select("select * from `user` where id=#{id}")
User selectUserById(@Param("id") int id);
//添加一个用户
@Insert("insert into `user`(id,name,pwd) values(#{id},#{name},#{pwd})")
int addUser(User user);
//修改用户
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int updateUser(User user);
//删除用户
@Delete("delete from `user` where id=#{id}")
int deleteUser(@Param("id") int id);
测试:
//根据id查询用户
@Test
public void selectUserById() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.selectUserById(3);
System.out.println(user);
sqlSession.close();
}
//添加一个用户
@Test
public void addUser() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.addUser(new User(8,"zhangsan","zhang123"));
sqlSession.commit();
sqlSession.close();
}
//修改用户
@Test
public void updateUser() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.updateUser(new User(8,"zhangsan333","zhang123"));
sqlSession.commit();
sqlSession.close();
}
//删除用户
@Test
public void deleteUser() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.deleteUser(8);
sqlSession.commit();
sqlSession.close();
}
- 注意增删改需要提交事务
- 采用注解开发,需要确保实体类和数据库字段对应
- 在需要传参的情况下,接口中 基本类型和String类型 需要使用@Param声明,对象实体类不需要
关于@Param:
@Param注解用于给方法参数起一个名字。以下是总结的使用原则:
- 在方法只接受一个参数的情况下,可以不使用@Param。
- 在方法接受多个参数的情况下,建议一定要使用@Param注解给参数命名。
- 如果参数是 JavaBean , 则不能使用@Param。
- 不使用@Param注解时,参数只能有一个,并且是Javabean。
#{}和${}区别:
-
#{}的作用主要是替换预编译语句(PrepareStatement)中占位符【推荐使用】
INSERT INTO user (name) VALUES (#{name}); INSERT INTO user (name) VALUES (?);
-
${}的作用是直接进行字符串替换
INSERT INTO user (name) VALUES ('${name}'); INSERT INTO user (name) VALUES ('kuangshen');
8.4 Lombok注解插件
Lombok是为了偷懒,主要是自动实体类生成:无参构造和有参构造、getter和setter、toString等
优点:
- 能够通过注解的形式自动生成代码:构造器、getter/setter,equals,hashcode,toString等方法,提高了一定的开发效率
- 让代码变得简洁,不用过多的去关注相应的方法
- 属性做修改时,也简化了维护这些属性所生成的getter/setter方法等
缺点:
- 不支持多种参数构造器的重载,但可以在类中手动添加重载
- 虽然省去了手动创建getter/setter方法的麻烦,但大大降低了源代码的可读性和完整性,降低了阅读源代码的舒适度,公司一般不建议使用,了解即可
常用注解:
使用步骤:
1.在IDEA中安装Lombok插件,一般自动安装了,如果没有手动安装
file->setting->plugins,Marketplace,Browse repositories
2.使用lombok需要添加jar包
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
3.实体类中直接应用
@Data //无参构造。get set toString hashcode equals
@AllArgsConstructor //有参构造
@NoArgsConstructor //无参构造
public class User {
private int id;
private String name;
private String pwd;
}
9.多表查询结果集映射
问题:
-
需要多表查询,但是返回的结果集往往只能是一个实体类型;
-
数据库多表查询结果(可能多张表的字段),与实体类(可能涉及多个实体类),但是Mybatis返回结果中,只有一个returnType——结果集映射
两种情况:
student表:id,name,tid
techear表:id,name
-
多对一:需要查询所有学生,及其对应的老师姓名(s.id s.name t.name),主体是学生(查询结果存在多个学生对应一个老师)
查询条件是所有的学生,学生表join老师表
-
**一对多:**需要查询指定老师,及其所有的学生信息(s.id s.name t.name),主体是老师(一个老师对应多个学生)
查询结果是指定老师,老师表join学生表
此处把握住是**“谁是主体”+“谁连接谁”**,join后面的是一个对象(多对一),join后面是一个集合(一对多)
9.1 老师学生例子数据库表
- 对于学生而言:多个学生对应一个老师,association关系,多对一
- 对于老师而言:一个老师对应多个学生,collection关系,一对多
新建数据库表:
SQL:
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');
9.2多对一
需求:
-
需要查询所有学生,及其对应的老师姓名(s.id s.name t.name),主体是学生(查询结果存在多个学生对应一个老师)
-
查询条件是所有的学生,学生表join老师表
(1)测试环境搭建
项目结构:
导入lombok
1.新建实体类
Student:
@Data
public class Student {
private int id;
private String name;
//学生需要关联一个老师,此处属性为一个对象
private Teacher teacher;
}
Teacher:
@Data
public class Teacher {
private int id;
private String name;
}
2.建立Mapper接口
StudentMapper:
public interface StudentMapper {
//查找所有学生,以及每个学生对应的老师姓名
List<Student> getStudent();
}
TeacherMapper:
public interface TeacherMapper {
//根据id查找老师,及老师的所有学生
Teacher getTeacher(int id);
}
3.建立Mapper.xml文件(后续改)
在Resources目录下,建立和java目录下同样的包结构com.kuang.dao
,易错:resources下建包用 / 分隔,java下建包用 . 分隔
而且Mapper.xml需要和Mapper同名
StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-Mapper.dtd">
<mapper namespace="com.kuang.dao.StudentMapper">
</mapper>
TeacherMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-Mapper.dtd">
<mapper namespace="com.kuang.dao.TeacherMapper">
</mapper>
5.在核心配置文件中绑定注册Mapper接口或者Mapper.xml或者包
<mappers>
<mapper class="com.kuang.dao.TeacherMapper"/>
<mapper class="com.kuang.dao.StudentMapper"/>
</mappers>
6.测试是否能够查询成功(后续改)
(2)按照结果嵌套处理(类连接查询、重点)
查询主体是学生
StudentMapper.xml:
<select id="getStudent" resultMap="StudentTeacher">
select s.id sid,s.name sname,t.name tname
from student s,teacher t
where s.tid = t.id;
</select>
<!--查询主体是学生,学生表join老师表-->
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<!--在学生实体类中,Teacher属性是一个对象-->
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
</association>
</resultMap>
先通过sql查询出结果,再 “sql结果字段” 与“实体类对象属性” 映射
测试:
@Test
public void testStudent(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> studentList = mapper.getStudent();
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
(3)按照查询嵌套处理(类子查询)
查询主体是学生
StudentMapper.xml:
<mapper namespace="com.kuang.dao.StudentMapper">
<!--
思路:
1.查询所有学生的信息
2.根据查询出来的学生的tid,寻找对应的老师
-->
<!--查询主体是学生,学生表join老师表-->
<select id="getStudent" resultMap="StudentTeacher">
select * from student
</select>
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!--复杂的属性,我们需要单独处理
对象association 集合:collection
javaType="" 指定属性的类型
集合中的泛型信息,我们使用ofType获取(一对多采用)
-->
<!--在学生实体类中,Teacher属性是一个对象-->
<association property="teacher" javaType="Teacher" select="getTeacher" column="tid" />
</resultMap>
<select id="getTeacher" resultType="Teacher">
select * from teacher where id = #{id}
</select>
</mapper>
测试:
@Test
public void testStudent(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> studentList = mapper.getStudent();
for (Student student : studentList) {
System.out.println(student);
}
sqlSession.close();
}
9.3一对多
需求:
-
需要查询指定老师,及其所有的学生信息(s.id s.name t.name),主体是老师(一个老师对应多个学生)
-
查询结果是指定老师,老师表join学生表
(1)测试环境搭建
实体类:
Student:
@Data
public class Student {
private int id;
private String name;
private int tid;
}
Teacher:
@Data
public class Teacher {
private int id;
private String name;
//一个老师拥有多个学生,此处属性为一个List
private List<Student> students;
}
(2)按照结果嵌套处理(类连接查询、重点)
查询主体是老师
TeacherMapper.xml:
<select id="getTeacher" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.name tname,t.id tid
from teacher t
inner join student s
on t.id=s.tid
where t.id=#{id}
</select>
<!--查询主体是老师,老师表join学生表-->
<resultMap id="TeacherStudent" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<!--在Teacher实体类中,Student属性是一个List,泛型需要指明类型-->
<collection property="students" javaType="ArrayList" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
先通过sql查询出结果,再 “sql结果字段” 与“实体类对象属性” 一一映射
测试:
public class TeacherMapperTest {
@Test
public void getTeacher(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
Teacher teacher = mapper.getTeacher(1);
System.out.println(teacher);
sqlSession.close();
}
}
(3)按照查询嵌套处理(类子查询)
查询主体是老师
TeacherMapper.xml:
<select id="getTeacher" resultMap="TeacherStudent">
select * from `teacher` where id=#{id}
</select>
<resultMap id="TeacherStudent" type="Teacher">
<collection property="students" javaType="ArrayList" ofType="Student"
select="getStudent" column="id"/>
</resultMap>
<select id="getStudent" resultType="Student">
select * from `student` where tid=#{id};
</select>
测试:
public class TeacherMapperTest {
@Test
public void getTeacher(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
Teacher teacher = mapper.getTeacher(1);
System.out.println(teacher);
sqlSession.close();
}
}
小结:
- 关联 association,多对一
- 集合 collection,一对多
- javaType 和 ofType
- javaType 用来制定实体类中属性的类型
- ofType用来指定映射到List(或者集合)中的pojo类型,泛型中的约束类
注意点:
- 保证SQL的可读性,尽量保证通俗易懂
- 注意一对多和多对一中 属性名和字段的问题
- 如果问题不好排查错误,可以使用日志,建议使用Log4j
面试高频:
- MySQL引擎
- InnoDB底层原理
- 索引
- 索引优化
10.动态SQL
10.1简介
什么是动态SQL:
- 动态SQL是指根据==不同的查询条件,拼接生成不同的Sql语句==
简介:
-
MyBatis 的强大特性之一便是它的动态 SQL
-
如果你有使用 JDBC 或其它类似框架的经验,你 就能体会到根据不同条件拼接 SQL 语句的痛苦:
- 拼接是要确保不能忘记 添加必要的空格
- 第一个查询条件不要and
where id=1 and name=“zhangsan” and password=“123456”
- 去掉列名最后一个列名的逗号
insert into user(id,name,value) values(1,”zhangsna”,”123456)
update user set name=”zhangsan2”,password=”123” where id=1
-
动态sql元素和 JSTL标签类似;
-
复杂的SQL语句,往往需要拼接。而拼接SQL稍微不注意,由于引号,空格等的缺失可能都会导致错误。
解决办法:
使用MyBatis的动态SQL,通过if
where,set,trim
foreach
choose,when,otherwise
等标签,可以组合成非常灵活的SQL语句,从而在提高SQL语句的准确性的同时,也大大提高了开发人员的效率。
10.2搭建环境
新建一个数据库表:blog
CREATE TABLE `blog` (
`id` varchar(50) NOT NULL COMMENT '博客id',
`title` varchar(100) NOT NULL COMMENT '博客标题',
`author` varchar(30) NOT NULL COMMENT '博客作者',
`create_time` datetime NOT NULL COMMENT '创建时间',
`views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1.创建一个maven基础工程
2.IDutils工具类
使用UUID创建唯一id
IDUtils:
public class IDUtils {
public static String getId(){
return UUID.randomUUID().toString().replaceAll("-","");
}
}
3.实体类的编写
Blog:
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
}
4.编写Mapper接口及xml文件
BlogMapper:
public interface BlogMapper {
}
BlogMapper.xml:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.dao.BlogMapper">
</mapper>
5.mybatis核心配置文件,下划线命名 驼峰命名自动转换
<settings>
<!--下划线命名 驼峰命名自动转换-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--注册Mapper.xml-->
<mappers>
<mapper class="com.kuang.dao.BlogMapper"/>
</mappers>
6.初始化接口数据
编写接口:
//新增一个博客
int addBlog(Blog blog);
Mapper.xml:
<insert id="addBlog" parameterType="Blog">
insert into mybatis.blog (id,title,author,create_time,views)
values (#{id},#{title},#{author},#{createTime},#{views});
</insert>
test:初始化博客数据
@Test
public void addInitBlog(){
SqlSession session = MybatisUtils.getSqlSession();
BlogMapper mapper = session.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);
session.commit();
session.close();
}
10.3 if标签
应用场景:
根据条件append查询条件,拼接SQL
需求:根据作者名字author和博客名字title来查询博客:
- 如果author和title都为空,查询全部博客
- author不为空,title为空,查询所有属于author的博客
- author为空,title不为空,查询指定博客名字的博客
- author和title都不为空,查询符合两者条件的博客
1.编写接口类:
//需求1
List<Blog> queryBlogIf(Map map);
2.编写Mapper.xml中SQL语句
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from `blog` where
<if test="author!=null">
author=#{author}
</if>
<if test="title!=null">
and title=#{title}
</if>
</select>
3.测试
@Test
public void test(){
SqlSession session = MybatisUtils.getSqlSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
Map<String,Object> map=new HashMap<String, Object>();
map.put("author","狂神说");
map.put("title","Mybatis如此简单");
List<Blog> blogs = mapper.queryBlogIf(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
session.close();
}
问题:
当author为null,title不为空时,select语句为:select * from blog where and title=#{title}
,这是错误的SQL语句。如何解决呢?采用下面where标签;
10.4 where标签
应用场景:
- 如果查询条件有返回值,就插入where;没有查询条件不插入where;
- 如果第一个查询条件前有and,就去除该and
修改上面的SQL语句:
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from `blog`
<where>
<if test="author!=null">
author=#{author}
</if>
<if test="title!=null">
and title=#{title}
</if>
</where>
</select>
set标签
应用场景:
- update操作,尾部 最后一个逗号
,
剔除 - 当author不为null,title为null时,造成错误: SQL尾部多了一个逗号
update blog set author=#{author},
编写Mapper.xml中SQL语句
<update id="updateBlog" parameterType="map">
update `blog`
<set>
<if test="author!=null">
author=#{author},
</if>
<if test="title!=null">
title=#{title}
</if>
</set>
where id=#{id}
</update>
trim标签
10.5 foreach标签
应用场景:
- **对应于
select * from blog where id in (1,2,3,4)
**
1.编写接口类:
List<Blog> queryBlogForeach(Map map);
2.编写Mapper.xml中SQL语句
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
select * from blog
<where>
<!--
collection:指定输入对象中的集合属性
item:每次遍历生成的对象
open:开始遍历时的拼接字符串
close:结束时拼接的字符串
separator:遍历对象之间需要拼接的字符串
select * from blog where 1=1 and (id=1 or id=2 or id=3)
-->
<foreach collection="idList" item="id" open="(" close=")" separator="or">
id=#{id}
</foreach>
</where>
</select>
3.测试
@Test
public void test(){
SqlSession session = MybatisUtils.getSqlSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
Map<String,Object> map=new HashMap<String, Object>();
List<String> idList=new ArrayList<String>();
idList.add("ae52b845132a4a7190d4c3e192265fd2");
map.put("idList",idList); //List是map的一个属性
List<Blog> blogs = mapper.queryBlogForeach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
session.commit();
session.close();
}
10.6 choose、when、otherwise标签
应用场景:
- 有时候我们不想用所有的查询条件,只想选择其中一个,查询条件有一个满足即可
- 使用choose,类似switch语句,前面的优先匹配优先级更高
1.编写接口类:
List<Blog> queryBlogChoose(Map map);
2.编写Mapper.xml中SQL语句
<select id="queryBlogChoose" parameterType="map" resultType="Blog">
select * from blog
<where>
<choose>
<when test="author!=null">
author=#{author}
</when>
<when test="title!=null">
title=#{title}
</when>
<otherwise>
and views=#{views}
</otherwise>
</choose>
</where>
</select>
3.测试
@Test
public void test(){
SqlSession session = MybatisUtils.getSqlSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
Map<String,Object> map=new HashMap<String, Object>();
map.put("title","Java如此简单2");
map.put("author","狂神说2");
map.put("views",9999);
List<Blog> blogs = mapper.queryBlogChoose(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
session.commit();
session.close();
}
10.7 提取SQL片段
有时候可能某个sql语句我们用的特别多,为了增加代码的复用性,简化代码,我们需要将这些代码抽取出来,然后使用时直接调用。
提取SQL片段:
<sql id="if-title-author">
<if test="author!=null">
author=#{author}
</if>
<if test="title!=null">
and title=#{title}
</if>
</sql>
引用SQL片段:
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from `blog`
<where>
<!-- 引用 sql 片段,如果refid 指定的不在本文件中,那么需要在前面加上 namespace-->
<include refid="if-title-author"/>
<!-- 在这里还可以引用其他的 sql 片段 -->
</where>
</select>
注意:
- 最好基于单表定义sql片段,提高片段的可重用性
- 在sql片段中不要包括where
动态SQL小结:
- 动态SQL语句的编写往往就是一个拼接的问题
- 为了保证拼接准确,最好先写出原生的sql语句
- 然后再通过mabatis动态SQL对照修改,防止出错
11.缓存
11.1简介
问题:
查询:连接数据库,耗费资源。
一次查询的结果,给他暂存在一个可以直接取到的地方——内存:缓存
我们再次查询相同数据的时候,直接走缓存,就不用走数据库了。
1.什么是缓存?
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。
2.为什么使用缓存?
- 减少和数据库的交互次数,减少系统开销,提高系统效率。
3.什么样的数据能使用缓存
- 经常查询并且不经常改变的数据
- 不经常查询 or 经常改变的数据不使用缓存
11.2Mybatis缓存
-
MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
-
MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下,只有一级缓存开启(SQLSession级别的缓存,也称本地缓存,作用域从SQLSession开启到结束
- 二级缓存需要手动配置和开启,它是基于namespace级别的缓存(在一个Mapper中有效,也称全局缓存;查询数据库,数据存入一级缓存,当SQLSession关闭时,将其缓存交付给二级缓存)
- MyBatis自定义了缓存接口Cache,可以自定义二级缓存
- 缓存清除策略:
11.3一级缓存
- 一级缓存也叫本地缓存,SqlSession级别,从SqlSession开始到关闭期间
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 这期间需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库;
- 一级缓存自动开启
1.测试
在同一SqlSession中查询两次相同记录
-
开启日志
-
测试代码:
Mapper接口:
//根据id查询用户
User queryUserbyId(@Param("id") int id);
Mapper.xml:
<select id="queryUserbyId" resultType="com.kuang.pojo.User">
select * from `user` where id=#{id};
</select>
test:
public void testQueryUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user1 =mapper.queryUserbyId(1);
System.out.println(user1);
System.out.println("===========同一个SqlSession中两次查询相同记录================");
User user2 =mapper.queryUserbyId(1);
System.out.println(user2);
System.out.println("user1==user2:"+(user1==user2));
sqlSession.close();
}
-
测试结果:
2.一级缓存失效
SqlSession一级缓存失效的情况
(1)SqlSession不同
public void testQueryUserById(){
SqlSession sqlSession1 = MybatisUtils.getSqlSession();
SqlSession sqlSession2 = MybatisUtils.getSqlSession();
//第一次查询
UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
User user1 =mapper1.queryUserbyId(1);
System.out.println(user1);
System.out.println("===========Sqlsession不同================");
//第二次查询
UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
User user2 =mapper2.queryUserbyId(1);
System.out.println(user2);
sqlSession1.close();
sqlSession2.close();
}
观察结果:两次查询都查询了数据库;
结论:每个SqlSession中缓存相互独立
(2)SqlSession相同,查询条件不同
public void testQueryUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user1 =mapper.queryUserbyId(1);
System.out.println(user1);
System.out.println("===========SqlSession相同,查询条件不同================");
User user2 =mapper.queryUserbyId(2);
System.out.println(user2);
System.out.println("user1==user2:"+(user1==user2));
sqlSession.close();
}
(3)增删改操作,可能会改变原来的数据,所以必定会刷新缓存
增删改之后,再次查询,会重新查询数据库;
//第一次查询
User user1 =mapper.queryUserbyId(1);
System.out.println(user1);
System.out.println("===========增删改操作,会刷新缓存================");
//更新
Map<String,Object> map=new HashMap<String, Object>();
map.put("id",1);
map.put("name","zhangsan2");
map.put("pwd","zhang123321");
mapper.updateUser(map);
//第二次查询
User user2 =mapper.queryUserbyId(1);
System.out.println(user2);
(4)SqlSession相同,手动清除一级缓存
第二次查询会重新查询数据库
public void testQueryUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//第一次查询
UserMapper mapper1 = sqlSession.getMapper(UserMapper.class);
User user1 =mapper1.queryUserbyId(1);
System.out.println(user1);
System.out.println("===========手动清除以及缓存================");
//手动清除以及缓存
sqlSession.clearCache();
//第二次查询
UserMapper mapper2 = sqlSession.getMapper(UserMapper.class);
User user2 =mapper2.queryUserbyId(1);
System.out.println(user2);
sqlSession.close();
}
一级缓存就是一个Map,key-value键值对
11.4二级缓存
-
二级缓存也叫全局缓存,一级缓存作用域只在一个SqlSession内,作用于太低,所以诞生了二级缓存
-
基于namespace级别的缓存,一个命名空间,对应一个二级缓存
-
工作机制:
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中;
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的是,会话关闭了,一级缓存的数据被保存到二级缓存中;
- 新的会话查询信息,就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map)中
使用步骤
1.在mybatis-config.xml核心配置文件中,开启全局缓存
<!--显式的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>
2.在要使用二级缓存的Mapper.xml中开启
<cache/>
也可以自定义参数
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
3.测试
(1)遇到问题:实体类需要序列化,否则就会报错
Cause: java.io.NotSerializableException: com.kuang.pojo.User
解决:
public class User implements Serializable {......}
(2)两个SqlSession测试二级缓存:
public void testQueryUserById(){
//第一次查询
SqlSession sqlSession1 = MybatisUtils.getSqlSession();
UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
User user1 =mapper1.queryUserbyId(1);
System.out.println(user1);
sqlSession1.close();
System.out.println("===========两个SqlSession测试二级缓存================");
//第二次查询
SqlSession sqlSession2 = MybatisUtils.getSqlSession();
UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
User user2 =mapper2.queryUserbyId(1);
System.out.println(user2);
sqlSession2.close();
}
小结
- 只要开启了二级缓存,在同一个Mapper下就有效
- 所有的数据都会先放在一级缓存中
- 只有当会话提交或者关闭时,才会提交到二级缓存中
11.5缓存原理
采用缓存后,查询数据先后顺序:
1.先看二级缓存中有没有
2.再看二级缓存中有没有
3.都没有查询数据库
11.6自定义缓存ehcache
- ehcache是第三方缓存,是一个纯Java的进程内缓存框架
- 是一种广泛使用的java分布式缓存,用于通用缓存
1.使用需要导入jar包
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
2.在mapper.xml中使用对应的缓存即可
<mapper namespace="com.kuang.dao.UserMapper">
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
</mapper>
3.编写ehcache.xml配置文件,放在resources中;如果在加载时未找到/ehcache.xml资源,将使用默认配置
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<!--
diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
user.home – 用户主目录
user.dir – 用户当前工作目录
java.io.tmpdir – 默认临时文件路径
-->
<diskStore path="./tmpdir/Tmp_EhCache"/>
<defaultCache
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="259200"
memoryStoreEvictionPolicy="LRU"/>
<cache
name="cloud_user"
eternal="false"
maxElementsInMemory="5000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="1800"
memoryStoreEvictionPolicy="LRU"/>
<!--
defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
-->
<!--
name:缓存名称。
maxElementsInMemory:缓存最大数目
maxElementsOnDisk:硬盘最大缓存个数。
eternal:对象是否永久有效,一但设置了,timeout将不起作用。
overflowToDisk:是否保存到磁盘,当系统当机时
timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
clearOnFlush:内存数量最大时是否清除。
memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
FIFO,first in first out,这个是大家最熟的,先进先出。
LFU, Less Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
LRU,Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
-->
</ehcache>
Mybatis缓存使用不多,大多被Redis缓存数据库,key-value键值对。
12.错误
【错误1】测试类不要和Mapper接口同名,测试类的测试函数不要和Mapper中接口函数同名
否则会出现找不到java方法
或者找到测试类的测试函数,但是传递方法参数不对
【错误2】
Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep
解决方法:之前在pom.xml文件中删除了下面代码,现在加上:
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
【错误3】
新建Mapper接口时不要建成了类
13.Mybatis常用配置总结
13.1Mybatis流程
项目结构
Mapper.xml和Mapper接口放在一起
Mapper.xml和Mapper接口放在相同包名下,Mapper.xml放在Resources目录下
Mybatis项目构建
1.新建配置文件
- mybatis-config.xml 核心配置文件(后续不要忘记在此注册Mappper)
- db.properties 数据库配置文件
- log4j.properties 日志配置文件
2.新建工具类
- MybatisUtils 提取生成SqlSession工具类
- 其他工具类
3.新建实体类
4.新建dao层
- Mapper接口
- Mapper.xml(类实现类,书写sql)(每个需要在mybatis-config.xml 核心配置文件中注册)
5.测试
13.2常用配置
MyBatis的maven项目pom.xml常用依赖
<?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>org.example</groupId>
<artifactId>mybatis3</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
<!--log4j日志输出 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!--lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
<!--mybatis-ehcache-->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
</dependencies>
<!--在build中配置resources,来防止我们资源导出的失败的问题-->
<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>
</project>
1.新建配置文件
-
mybatis-config.xml 核心配置文件(后续不要忘记在此注册Mappper)
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <properties resource="db.properties"/> <settings> <!--开启日志--> <setting name="logImpl" value="LOG4J"/> <!--驼峰命名转换--> <setting name="mapUnderscoreToCamelCase" value="true"/> <!--开启缓存--> <setting name="cacheEnabled" value="true"/> </settings> <!--简化Mapper.xml中书写returnType类型,为实体类起别名--> <typeAliases> <package name="com.kuang.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> <!--注册Mapper--> <mappers> <mapper class="com.kuang.dao.BlogMapper"/> </mappers> </configuration>
-
db.properties 数据库配置文件
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8 username=root password=123456
-
log4j.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/kuang.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.sql.PreparedStatement=DEBUG
2.新建工具类
-
MybatisUtils 提取生成SqlSession工具类
//工具类 //需要获得数据库操作对象SqlSession //SqlSessionFactory---->SqlSession public class MybatisUtils { private static SqlSessionFactory sqlSessionFactory;//提升作用域 static { //使用Mybatis的第一步:获取SqlSessionFactory对象 try { String resource = "mybatis-config.xml"; InputStream inputStream =Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } } //有了SqlSessionFactory以后,我们可以从中获得SqlSession的实例 //SqlSession提供了在数据库执行 SQL命令 所需的所有方法 public static SqlSession getSqlSession(){ return sqlSessionFactory.openSession(); } }
-
其他工具类,如IDUtils
public class IDUtils { public static String getId(){ return UUID.randomUUID().toString().replaceAll("-",""); } }
3.新建实体类
import java.util.Date;
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
}
4.新建dao层
-
Mapper接口
public interface BlogMapper { //查询 List<Blog> queryBlogIf(Map map); }
-
Mapper.xml(类实现类,书写sql)(每个需要在mybatis-config.xml 核心配置文件中注册)
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.kuang.dao.BlogMapper"> <select id="queryBlogIf" parameterType="map" resultType="Blog"> select * from `blog` <where> <if test="author!=null"> author=#{author} </if> <if test="title!=null"> and title=#{title} </if> </where> </select> </mapper>
5.测试
public class BlogTest {
@Test
public void test(){
SqlSession session = MybatisUtils.getSqlSession();
BlogMapper mapper = session.getMapper(BlogMapper.class);
Map<String,Object> map=new HashMap<String, Object>();
map.put("title","Java如此简单2");
map.put("author","狂神说2");
List<Blog> blogs = mapper.queryBlogIf(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
session.commit();
session.close();
}
}