Demo项目地址:https://gitee.com/future-man_1_951770031/mybatis-study
持久化是将程序数据在持久状态和瞬时状态间转换的机制。
为什么需要持久化服务呢?那是由于内存本身的缺陷引起的
什么是持久层?
Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
传统的jdbc操作 , 有很多重复代码块 .太麻烦比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
所有的事情,不用Mybatis依旧可以做到,只是用了它,所有实现会更加简单!技术没有高低之分,只有使用这个技术的人有高低之别
MyBatis的优点
最重要的一点,使用的人多!公司需要!
思路流程:搭建环境–>导入Mybatis—>编写代码—>测试
新建项目:
CREATE DATABASE `mybatis`;
USE `mybatis`;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(20) NOT NULL,
`name` varchar(30) DEFAULT NULL,
`pwd` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into `user`(`id`,`name`,`pwd`) values (1,'狂神','123456'),(2,'张三','abcdef'),(3,'李四','987654');
创建一个普通的maven项目
删除src目录 (就可以把此工程当做父工程了,然后创建子工程)
导入maven相关依赖
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.2version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
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="root"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/peng/dao/UserMapper.xml"/>
mappers>
configuration>
用于获取sqlSessionFactory,然后再获取sqlSession
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;
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
try {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
// 有了sqlSessionFactory,就可以获取sqlSession实例
// 获取SqlSession连接
public static SqlSession getSession(){
return sqlSessionFactory.openSession();
}
}
在pojo文件下创建
public class User {
private int id; //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;
}
//toString()
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
//set/get
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;
}
}
public interface UserDao {
public List<User> getUserList();
}
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.peng.dao.UserDao">
<select id="getUserList" resultType="com.peng.dao.User">
select * from USER
select>
mapper>
一般来说是在test里边这个绿色的java文件夹里边进行
注意点:经常会遇到如下错误
org.apache.ibatis.binding.BindingException: Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.
MapperRegistry是什么?
核心配置文件中注册mappers
<mappers>
<mapper resource="com/peng/dao/UserMapper.xml"/>
mappers>
问题:java.lang.ExceptionInInitializerError
Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.io.IOException: Could not find resource com/peng/dao/UserMapper.xml
<build>
<resources>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>falsefiltering>
resource>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>falsefiltering>
resource>
resources>
build>
可能会遇到的问题:
namespace的包名一定要和Dao/Mapper接口的包名一致
现在的Dao就改成Mapper要习惯这个改变
选择,查询语句;
select标签中的属性介绍:
标签中的属性与select一致,这里直接扔代码,直接理解吧
User实体类中的数据
public interface UserMapper {
// 获取全部用户信息
public List<User> getUserList();
// 获取指定用户的信息
User getUserById(int id);
// 增加用户的信息
int addUser(User user);
// 修改用户的信息
int updateUser(User user);
// 删除一个用户信息
int deleteUser(int id);
}
UserMapper.xml中的数据
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.peng.dao.UserMapper">
<select id="getUserList" resultType="com.peng.pojo.User">
select * from user
select>
<select id="getUserById" parameterType="int" resultType="com.peng.pojo.User">
select * from user where id=#{id}
select>
<insert id="addUser" parameterType="com.peng.pojo.User">
insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
insert>
<update id="updateUser" parameterType="com.peng.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>
Test类中
package com.peng.dao;
import com.peng.pojo.User;
import com.peng.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void test(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2.执行SQL
// 方式一:getMapper
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = userMapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
//关闭sqlSession
sqlSession.close();
}
@Test
public void getUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 指定查询用户的信息
User user=userMapper.getUserById(1);
System.out.println(user);
sqlSession.close();
}
@Test
public void addUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user=new User(4,"123","321");
mapper.addUser(user);
//增删改必须要commit这个东西,提交事务
sqlSession.commit();
sqlSession.close();
}
@Test
public void updateUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user=new User(1,"333","333");
mapper.updateUser(user);
//增删改必须要commit这个东西,提交事务
sqlSession.commit();
sqlSession.close();
}
@Test
public void deleteUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.deleteUser(1);
//增删改必须要commit这个东西,提交事务
sqlSession.commit();
sqlSession.close();
}
}
为什么用Map。假设实体类中的字段太多,我们就可以使用map,如果ParameterType
假设,我们的实体类,或者数据库中的表,字段或者参数过多,我们应当考虑使用Map
之前的代码都是使用User实体类去进行操作,每次都传一个实体类去操作都会添加很繁琐
而且xml中要对应实体类
但是使用map就不一样了,此乃野路子
UserMapper接口中
//用万能Map插入用户
public void addUser2(Map<String,Object> map);
UserMapper.xml中
<insert id="addUser2" parameterType="map">
insert into user (id,name,password) values (#{userid},#{username},#{userpassword})
insert>
Test类中
@Test
public void test3(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("userid",4);
map.put("username","王虎");
map.put("userpassword",789);
mapper.addUser2(map);
//提交事务
sqlSession.commit();
//关闭资源
sqlSession.close();
}
重要:
Map传递参数,直接在sql中取出key即可! 【parameter=“map”】
对象传递参数,直接在sql中取出对象的属性即可! 【parameter=“Object”】
只有一个基本类型参数的情况下,可以直接在sql中取到(即在标签中的parameterType不填,可以直接函数带参传入)
多个参数用Map , 或者注解!
模糊查询这么写?
方式一:Java代码执行的时候,传递通配符% %,比较安全
List<User> userList = mapper.getUserLike("%李%");
方式二:在sql拼接中使用通配符(xml中的东西),(存在SQL注入问题)
select * from user where name like "%"#{value}"%"
configuration(配置)
properties(属性)
settings(设置)
typeAliases(类型别名)
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)
databaseIdProvider(数据库厂商标识)
mappers(映射器)
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境
MyBatis默认的事务管理器就是JDBC ,连接池:POOLED
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
dataSource的取值有很多种,其中POOLED使用较多。
POOLED-这种数据源的实现利用”池的概念将JDBC连接对象组织起来,避免了创建新的连接实例时所必需的初始化认证时间。这是一种使得并发Web应用快速响应请求的流行处理方式。
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。比如:【db.poperties】
创建db.poperties放在resources下,内部内容如下:
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=root
在核心配置文件(db.properties)中引入,然后使用**${内容}**的格式进行导入
<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>
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置.
意在降低冗余的全限定类名书写
在resultType和parameterType这里可以使用别名
<typeAliases>
<typeAlias type="com.kuang.pojo.User" alias="User"/>
typeAliases>
也可以指定一个包,每一个在包 com.peng.pojo
中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.peng.pojo.User
的别名为 user
别名为其注解值。见下面的例子:
<typeAliases>
<package name="com.peng.pojo"/>
typeAliases>
以后在实体类的mapper.xml中就可以直接使用别名了,而不是写一大串
在实体类比较少的时候,使用第一种方式。
如果实体类十分多,建议用第二种扫描包的方式。
第一种可以DIY别名,第二种不行,如果非要改,需要在实体上增加注解。
@Alias("fuck")
//别名就是fuck
public class Author {
...
}
有很多,目前只记住这一个
在核心配置文件中写入:
<settings>
<setting name="logImpl" value="LOG4J"/>
settings>
MapperRegistry:注册绑定我们的Mapper文件;
注意之前我们在mybatis-config核心配置文件中注册的
方式一:【推荐使用】
<mappers>
<mapper resource="com/peng/dao/UserMapper.xml"/>
mappers>
方式二:使用class文件绑定注册
<mappers>
<mapper class="com.peng.dao.UserMapper"/>
mappers>
方式二注意点:
方式三:使用包扫描进行注入
<mappers>
<package name="com.peng.dao"/>
mappers>
方式三注意点:
声明周期和作用域是至关重要的,因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder:
SqlSessionFactory:
SqlSession:
这里的每一个Mapper就代表一个具体的业务
实体类与mapping.xml的属性不一致
数据库中的字段
新建一个项目,拷贝之前的,测试实体类字段不一致的情况
出现问题,出现null的情况
// select * from user where id = #{id}
// 类型处理器
// select id,name,pwd from user where id = #{id}
解决方法:
<select id="getUserById" resultType="com.kuang.pojo.User">
select id,name,pwd as password from USER where id = #{id}
select>
结果集映射,此乃解决方法二
id name pwd
id name password
<resultMap id="UserMap" type="User">
<result column="id" property="id">result>
<result column="name" property="name">result>
<result column="pwd" property="password">result>
resultMap>
<select id="getUserList" resultMap="UserMap">
select * from USER
select>
如果一个数据库操作,出现了异常,我们需要排错,日志就是最好的助手!
曾经:sout、debug
现在:日志工厂
在MyBatis中具体使用哪一个日志实现,在设置中设定
STDOUT_LOGGING
在核心配置文件中设置:
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
settings>
什么是Log4j?
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
在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/rzp.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
配置settings为log4j实现
测试运行
Log4j简单使用
在要使用Log4j的类中,导入包 import org.apache.log4j.Logger;
获取日志对象,参数为当前类的class对象
Logger logger = Logger.getLogger(UserDaoTest.class);
logger.info("info:测试log4j");
logger.debug("debug:测试log4j");
logger.error("error:测试log4j");
完整代码:
//参数为当前类的class对象
public class UserDaoTest {
static Logger logger = Logger.getLogger(UserDaoTest.class);
@Test
public void testLog4j(){
logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");
}
}
思考:为什么分页?
语法:SELECT * from user limit startIndex,pageSize
startIndex表示从第几个开始查
pageSize表示每页显示几个,
如果为:SELECT * from user limit 3表示查三条
使用MyBatis实现分页,核心SQL
//分页
List<User> getUserByLimit(Map<String,Integer> map);
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
select * from user limit #{startIndex},#{pageSize}
select>
@Test
public void getUserByLimit(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("startIndex",1);
map.put("pageSize",2);
List<User> list = mapper.getUserByLimit(map);
for (User user : list) {
System.out.println(user);
}
}
不再使用SQL实现分页
//分页2
List<User> getUserByRowBounds();
<select id="getUserByRowBounds">
select * from user limit #{startIndex},#{pageSize}
select>
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(1, 2);
//通过Java代码层面实现分页
List<User> userList = sqlSession.selectList("com.kaung.dao.UserMapper.getUserByRowBounds", null, rowBounds);
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
三个面向区别
简单的可以使用,复杂的就别去用了
//直接将sql写在方法这里,干掉了Mapper.xml里的简单SQL语句,但是还是用得少
@Select("select * from user")
List<User> getUsers();
<mappers>
<mapper class="com.kuang.dao.UserMapper"/>
mappers>
测试
本质:反射机制实现
底层:动态代理
MyBatis详细执行流程
注意:openSession()方法可以设置参数,当参数为true的时候可以自动提交事务,此时可以不用再去写sqlSession.commit();
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
//方法存在多个参数,所有的参数前面必须加上@Param("id")注解
//@Param里uid的与注解里的uid联系
@Delete("delete from user where id = ${uid} and name=${name}")
int deleteUser(@Param("uid") 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);
@Delete("delete from user where id = #{uid}")
int deleteUser(@Param("uid") int id);
关于@Param( )注解
**#{} 和 ${}**是有区别的
一般使用#{}可以最大程度防止sql注入,能用#{}尽量用
Lombok项目是一个Java库,它会自动插入编辑器和构建工具中,Lombok提供了一组有用的注释,用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净,简洁且易于维护的Java类。
使用步骤:
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.10version>
<scope>providedscope>
dependency>
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
常用的注解:
@data使用最多,使用@data时,会自动的生成无参构造、get、set、toString、hashcode、equals方法,无需再在实体类中重写一大堆
@AllArgsConstructor生成有参构造
@NoArgsConstructor生成无参构造
4.在实体类中加注解
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String password;
}
多个学生一个老师;
对于学生这边而言,称之为关联,多个学生关联一个老师【多对一】,每个Student类里边有一个Teacher类作为属性
对于老师而言,称之为集合,一个老师有很多学生【一对多】,Teacher类里边有一个List的集合
alter table student ADD CONSTRAINT fk_tid foreign key (tid) references teacher(id)
物理外键进行连接,通过tid关联老师id
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;
}
建立Mapper接口
建立Mapper.xml文件
在核心配置文件中绑定注册我们的Mapper接口或者文件 【方式很多,随心选】
测试查询是否能够成功
就是连表查,其实要写sql很快就能解决,但是现在使用框架所以需要按照框架的结构来,要改变思路,也相当于是一种解耦的妥协吧
子查询就是类似于下方,使用查询出的东西再作为条件,再查询:
select id,name,tid from student where tid=(select id from …)
<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 property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
resultMap>
<select id="getTeacher" resultType="Teacher">
select * from teacher where id=#{tid}
select>
即sql查出来之后我们在xml中去处理
联表查询:直接查询两个表
<select id="getStudent2" resultMap="StudentTeacher2">
select s.id sid,s.name sname,t.name tname
from student s,teacher t
where s.tid=t.id
select>
<resultMap id="StudentTeacher2" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="teacher">
<result property="name" column="tname"/>
association>
resultMap>
回顾Mysql多对一查询方式:
一个老师多个学生;
对于老师而言,就是一对多的关系;
实体类
@Data
public class Student {
private int id;
private String name;
private int tid;
}
@Data
public class Teacher {
private int id;
private String name;
//一个老师拥有多个学生
private List<Student> students;
}
注:Student里边的tid与老师的id对应
<select id="getTeacher" resultMap="StudentTeacher">
SELECT s.id sid, s.name sname,t.name tname,t.id tid FROM student s, teacher t
WHERE s.tid = t.id AND tid = #{tid}
select>
<resultMap id="StudentTeacher" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
collection>
resultMap>
<select id="getTeacher2" resultMap="TeacherStudent2">
select * from teacher where id=#{tid}
select>
<resultMap id="TeacherStudent2" type="Teacher" >
<result property="id" column="id"/>
<result property="name" column="name"/>
<collection property="students" javaType="ArrayList" ofType="student"
select="getStudentByTeacherId" column="id">
collection>
resultMap>
<select id="getStudentByTeacherId" resultType="student">
select * from student where tid=#{tid}
select>
小结:
注意点:
面试高频
什么是动态SQL:动态SQL就是根据不同的条件生成不同的SQL语句
所谓的动态SQL,本质上还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码
动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架,你应该能理解根据不同条件拼接 SQL 语句有多痛苦,例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL,可以彻底摆脱这种痛苦。
CREATE TABLE `mybatis`.`blog` (
`id` varchar(255) NOT NULL AUTO_INCREMENT COMMENT '博客id',
`title` varchar(30) NOT NULL COMMENT '博客标题',
`author` varchar(30) NOT NULL COMMENT '博客作者',
`create_time` datetime(0) NOT NULL COMMENT '创建时间',
`views` int(30) NOT NULL COMMENT '浏览量',
PRIMARY KEY (`id`)
)
创建一个基础工程
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;// 此处属性名和字段名不一致
private int views;
}
传入map操作,很nice
<select id="queryBlogIF" parameterType="map" resultType="blog">
select * from blog
<where>
<if test="title!=null">
and title = #{title}
if>
<if test="author!=null">
and author = #{author}
if>
where>
select>
类似于switch,满足一个就走了,同时满足多个也走一个。只会选择其中一个去实现
<select id="queryBlogChoose" parameterType="map" resultType="blog">
select * from mybatis.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>
定制化,其实where和set标签的功能都是这样定制出来的
where:
<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
trim>
set
<trim prefix="SET" suffixOverrides=",">
...
trim>
where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。
where解决拼接SQL时where和and同时拼接的情况,如:
错误示例:select * from mybatis.blog where and title = #{title}
按照以前的老方法,拼接语句的有时候会出现where and遇到一块的情况,此时sql语句是有问题的。
此时where标签就会自动的进行操作,拼接的语句有or或者and就会自动去除。
在外边包一层where标签即可
<where>
<if test="title != null">
title = #{title}
if>
<if test="author != null">
and author = #{author}
if>
where>
与where类似,在我们写update语句的时候会有很多逗号,当末尾出现逗号的时候就会出错
update mybatis.blog set title = #{title},author = #{author},
此时set标签的作用就和where类似,如果末尾有逗号,会将末尾的逗号取消掉
update mybatis.blog
title = #{title},
author = #{author}
where id = #{id}
有的时候,我们可能会将一些功能的部分抽取出来,方便代码的复用!
<sql id="if-title-author">
<if test="title!=null">
title = #{title}
if>
<if test="author!=null">
and author = #{author}
if>
sql>
<select id="queryBlogIF" parameterType="map" resultType="blog">
select * from blog
<where>
<include refid="if-title-author">include>
where>
select>
注意事项:
动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
建议:
foreach元素的功能非常强大,它允许你指定一个集合,声明可以在元素体内使用的集合项(item) 和索引(index) 变量。
它也允许你指定开头与结尾的字符串以及在迭代结果之间放置分隔符。这个元素是很智能的,因此它不会偶然地附加多余的分隔符。
<select id="queryBlogForeach" parameterType="map" resultType="blog">
select * from mybatis.blog
<where>
<foreach collection="ids" item="id" open="and (" close=")" separator="or">
id = #{id}
foreach>
where>
select>
select * from user where 1=1 and
<foreach item="id" collection="ids open="(" separator="or" close=")">
#{id}
foreach>
(id=1 or id=2 or id=3)
java代码:
@Test
public void queryBlogForEach(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
//我们在这里创建了一个名为ids的集合
//创建一个ArrayList作为map中的key
ArrayList<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
ids.add(3);
map.put("ids",ids);
List<Blog> blogs = mapper.queryBlogForeach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
查询 : 连接数据库,耗资源
比如有一次查询的结果,给他暂存一个可以直接取到的地方! --> 内存,这个就叫缓存
我们再次查询的相同数据的时候,直接走缓存,不走数据库了
什么是缓存[Cache]?
为什么使用缓存?
什么样的数据可以使用缓存?
在sqlSession范围内:在Close之前与创建之前的查询都会被缓存起来
测试步骤:
@Test
public void test1() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.getUserById(1);
System.out.println(user);
System.out.println("=====================================");
User user2 = mapper.getUserById(1);
System.out.println(user2 == user);
}
缓存失效的情况:
sqlSession.clearCache();
一级缓存开启(SqlSession级别的缓存,也称为本地缓存)
步骤:
开启全局缓存,在核心配置文件中(默认开启的,但是为了代码的可读性,还是写一下,提示一下)
<setting name="cacheEnabled" value="true"/>
在Mapper.xml中使用缓存
<cache
flushInterval="60000"
size="512"
readOnly="true"/>
测试
小结:
此乃查询顺序。查询数据库后又将数据保存到以及缓存中
注意:
<select id="getUserById" resultType="user" useCache="true">
select * from user where id = #{id}
select>
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存
操作步骤:
<dependency>
<groupId>org.mybatis.cachesgroupId>
<artifactId>mybatis-ehcacheartifactId>
<version>1.2.1version>
dependency>
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
maxElementsOnDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
ehcache>
这里了解即可,以后使用Redis来做缓存,以后缓存以什么key-value的形式之类的去实现
``xml
```
这里了解即可,以后使用Redis来做缓存,以后缓存以什么key-value的形式之类的去实现