Mybatis学习心得
环境：百度配置
回顾：
1. JDBC
2. Mysql
3. java基础
4. Maven
5. Junit
一、Mybits简述：
1.1什么是Mybist？
- MyBatis 是一款优秀的持久层框架；
- 它支持自定义 SQL、存储过程以及高级映射。
- MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
- MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
如何获得Mybatis？
- Maven
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>x.x.x</version>
</dependency>
- Github ：
- 中文文档：https://mybatis.org/mybatis-3/zh/configuration.html#
1.2持久化
数据持久化
- 持久化就是将程序的数据在持久状态和顺势状态转化的过程
- 内存：断电即失
- 数据库(jdbc),io文件等都可以将数据持久化
- 生活：银行放在前里面，冷藏等
为什么要持久化？
- 有一些对象，不能让他丢掉！！！
- 内存太贵了，需要将大部分数据放在外存里面存储
1.3 持久层
我们学过几个层，有Dao层，有Service层，有Controller层，所有的层都有很明显的特点：
- 层与层之间的界限非常明显，如果Service不去调用Dao层，两个层之间是不会有交集的
- 持久层是完成持久化工作的代码块，也就是与数据库打交道的地方
1.4 为什么需要Mybatis？
- 帮助程序员更加方便将数据存到数据库中！
- 传统的JDBC太复杂
Mybatis的特点：
- 简单易学
- 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。
- sql写在xml里，便于统一管理和优化。sql和代码的分离，提高了可维护性。
- 提供映射标签，支持对象与数据库的orm字段关系映射 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql。
2、第一个Mybatis程序
思路：环境搭建->导入jar包->编写代码->测试代码!
2.1、搭建环境
- 搭建数据库
CREATE DATABASE `mybatis`;
USE `mybatis`;
CREATE TABLE `user`(
`id` INT(20) PRIMARY KEY,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL
);
INSERT INTO `user` VALUES
(1,'小明','123123'),
(2,'李四','123123'),
(3,'小王','123123')
- 新建项目
1、新建一个maven项目
2、删除src目录
3、导入maven依赖
<!--导入依赖-->
<dependencies>
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.25</version>
</dependency>
<!--mybatis依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<!--juit依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
2.2创建一个新模块
- 编写Mybatis的核心配置文件
<?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代表mybatis核心配置-->
<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=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
</configuration>
- 编写Mybatis工具类
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
//使用Mybatis第一步：获取sqlSessionFactory
static{
//资源文件
String resource = "mybatis-config.xml";
try {
//用一个流来读取资源文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//给sqlSession工厂对象赋值
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
//SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
2.3、 编写代码
- 实体类
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接口
public interface UserDao {
List<User> getUserlist();
}
- 接口实现类,
由原来的UserDaoImpl转为mybatis的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">
<!--命名空间绑定的是要实现的接口-->
<mapper namespace="com.spring.dao.UserDao">
<!--id绑定的是实现的方法，resultYype则绑定哪个类-->
<select id="getUserlist" resultType="com.spring.pojo.User">
select * from mybatis.user
</select>
</mapper>
2.4、测试
- 注意点：要为每一个mapper.xml配置mapper 和设置bulid
- 测试代码
public class UserMapperTest {
@Test
public void test(){
// 第一步：获得sqlSession
SqlSession sqlSession = MybatisUtils.getSqlSession();
//方式一：通过getMapper
UserDao mapper = sqlSession.getMapper(UserDao.class);
List<User> list=mapper.getUserlist();
//方式二：通过selectlsit
List<User> list1 = sqlSession.selectList("com.spring.dao.UserDao.getUserlist");
for (User user:list1)
System.out.println(user);
sqlSession.close();
}
}
3、CURD
-
1.namespace
绑定的是某个Dao/Mapper接口！ -
2、select
选择查询语句
- id：就是对应的方法名
- resulType:Sql语句执行的返回值！
- paramenterType：参数类型！- 编写接口 User getUserbyId(int id); - 编写sql <select id="getUserlist" resultType="com.spring.pojo.User"> select * from mybatis.user </select> - 编写测试 @Test public void getUserbyId(){ SqlSession sqlSession= MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); User user=mapper.getUserbyId(1); System.out.println(user); sqlSession.close(); } 注意：增加删除修改需要提交事务 -
3、Inset
-
4、update
-
5、delete
-
6、分析错误
- 标签不要错误
- resource绑定mapper，需要使用路径！
- 程序配置文件必须规范
- NullPointerException，没有注册到资源！
- 输出的xml文件中存在中文乱码问题！
- maven资源没有到处问题！
-
7、万能map
假设类的参数很多，并且很多都是非空，假如我们只需要修改某个参数，恰好那个修改的方法要new，这个时候就必须把其他的参数也写进去，如果用map，就只需要将修改的参数和id放进一个map，将这个map作为参数传进去即可，避免了new对象的时候有很多非空的参数必须填写的情况！
//万能Map int add2(Map<String,Object>map);<insert id="add2" parameterType="map"> insert into mybatis.user(id,pwd) value (#{userid},#{userpwd}) </insert>@Test public void add2(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); Map<String,Object> map= new HashMap<String,Object>(); map.put("userid",5); map.put("userpwd","123123"); int number = mapper.add2(map); if (number>0){ System.out.println("添加成功"); sqlSession.commit(); } sqlSession.close(); }Map传递参数，直接在sql中取出key即可！ 【parameterType=“map”】
实体对象传递参数，直接在sql中取出对象的属性即可！【parameterType=“Object”】
只有一个基本类型参数的情况下，可以直接在sql中取到！
多个参数用Map，或者注解！ -
8、模糊查询
//模糊查询 List<User> getUserList1(String value);- 8.1 java代码执行的时候，传递通配符% %
<select id="getUserList1" parameterType="String" resultType="com.spring.pojo.User"> select * from mybatis.user where name like (#{value}) </select>@Test public void test11(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); List<User> list=mapper.getUserList1("%小%"); for (User user : list) { System.out.println(user); } sqlSession.close(); }- 8.2 在xml的sql中使用通配符
<select id="getUserList1" parameterType="String" resultType="com.spring.pojo.User"> select * from mybatis.user where name like "%"#{value}"%" </select>@Test public void test11(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); UserDao mapper = sqlSession.getMapper(UserDao.class); List<User> list=mapper.getUserList1("小"); for (User user : list) { System.out.println(user); } sqlSession.close(); }
4、配置解析
-
4.1 mybatis-config.xml 核心配置文件
-
MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息
- configuration（配置） - properties（属性） - settings（设置） - typeAliases（类型别名） - typeHandlers（类型处理器） - objectFactory（对象工厂） - plugins（插件） - environments（环境配置） - environment（环境变量） - transactionManager（事务管理器） - dataSource（数据源） - databaseIdProvider（数据库厂商标识） - mappers（映射器） -
4.2 环境配置
Mybatis可以适应多种环境
记住,尽管可以配置多个环境，但是每个SqlSessinoFactory实例只能选择一种环境。
学会使用配置多套运行环境！ 就是根据ID配置
Mybatis默认的事务管理器是JDBC，连接池：POOLED -
4.3 属性(properties)
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。
你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。关于数据库资源文件的玩法：
-
可以直接在mybatis-config.xml中全写入
<dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> -
也可以在resources里面另起一个db.properties文件，然后去mybatis-config.xml中引入
driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8 username=root password=root注意：在xml中&才需要加amp; 在properties中不需要
<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中也可以写一些字段，然后db.properties不写，但是如果两个都写了相同的字段，优先引用外部配置的db.properties文件中的字段。同时，在外部文件中的字段如果values值是错的化，就算xml中properties中的字段values值是对的也会报错！！！
-
-
4.4 别名
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写，注意按照顺序写在第三位。<typeAliases> <typeAlias alias="User" type="com.spring.pojo.User"></typeAlias> </typeAliases>或者写成一个包，然后在那个包的所有的实体类用注解@Alias给别名
@Alias("User") public class User {<typeAliases> <package name="com.spring.pojo"/> </typeAliases>接口实现类里面的ResultType就可以这样写
<select id="getUserlist" resultType="User"> select * from mybatis.user </select> -
4.5 设置
这是Mybatis中极为重要的调整设置，会改变Mybatis的运行- cacheEnabled ：全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。
- lazyLoadingEnabled： 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。
- logImpl： 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。
-
4.6 映射器 （mappers）
MapperRegistry：注册绑定我们的Mapper文件：
方式一：使用相对于类路径的资源引用:<mappers> <mapper resource="com/spring/dao/UserMapper.xml"></mapper> </mappers>方式二：使用class文件绑定注册
<mappers> <mapper class="com.spring.dao.UserMapper"></mapper> </mappers>注意：使用第二种，接口和实现类必须放在同一个包下，且前缀要同名！！
方式三：使用扫描包
<mappers> <package name="com.spring.dao"/> </mappers>注意点跟第二种方式一样！！！
-
4.7 生命周期和作用域
生命周期、作用域都是至关重要的，一位内错误的使用会导致非常严重的并发问题！SqlSessionFactoryBuilder：
- 一旦创建了SqlSessionFactoryBuilder，就不再需要它了！
- 局部变量
SqlSessionFactory：
- 其实就可以想象是JDBC中的数据库连接池
- 一旦创建了就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例，不然会造成资源的浪费
- 因此SqlSessinoFactory的最佳作用域应该是应用作用域
- 最简单的就是使用单例模式或者静态单例模式
SqlSession：
-
可以比喻成连接到连接池的一个请求
-
SqlSession的实例线程不安全，所以不能被共享，作用域应该放在请求或者某个方法里面
-
请求完之后需要关闭！
每个Mapper就是一个业务
5、解决属性名和字段名不一致的问题
@Alias("User")
public class User {
private int id;
private String name;
private String password;
}
- 测试问题：
User{id=1, name='sss', password='null'}
解决方法：
- 1、起别名：
<select id="getUserbyId" resultType="User" parameterType="int">
select id,name,pwd as password from mybatis.user where id = #{id}
</select>
- 2、resultMap
结果集映射，通过在接口实现类xml中设置resultMap，将数据库中与dao中实体类不一样的字段映射
<!--命名空间绑定的是要实现的接口-->
<mapper namespace="com.spring.dao.UserMapper">
<!--id绑定的是实现的方法，resultYype则绑定哪个类-->
<!-- type对应要映射的哪个类-->
<resultMap id="Usermap" type="User">
<result column="pwd" property="password"></result>
</resultMap>
<select id="getUserbyId" resultMap="Usermap">
select * from mybatis.user where id = #{id}
</select>
</mapper>
6 日志工厂
- SLF4J
- LOG4J 掌握
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING 掌握
- NO_LOGGING
在Mybatis具体使用哪一个日志实现，在核心配置文件中设定！
STDOUT_LOGGING标准日志输出
Created connection 1168420930.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@45a4b042]
==> Preparing: select * from mybatis.user where id = ?
==> Parameters: 1(Integer)
<== Columns: id, name, pwd
<== Row: 1, sss, 123123
<== Total: 1
User{id=1, name='sss', password='123123'}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@45a4b042]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@45a4b042]
Returned connection 1168420930 to pool.
LOG4J 日志输出
LOG4J 是什么？
-
Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；
-
我们也可以控制每一条日志的输出格式；
-
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
-
可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
1、必须先导入jar包
<dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>2、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=DEBUG3、在核心配置文件设置log4j
<settings> <setting name="logImpl" value="LOG4J"/> </settings>简单使用：
-
1、在使用log4j的类中，导入包import org.apache.log4j.Logger;
-
2、日志对象，参数为当前类的class
static Logger logger= Logger.getLogger(UserMapperTest.class); -
3、日志级别：
logger.info("sdf"); logger.debug("sdfs"); logger.error("ssss");
-
7、分页
7.1 使用limit分页
- 接口：
List<User> limitlist(HashMap<String,Integer>map); - 实现：
<select id="limitlist" resultMap="Usermap" parameterType="map"> select * from mybatis.user limit #{start},#{pagesize}; </select> - 测试：
@Test public void test1(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); UserMapper mapper=sqlSession.getMapper(UserMapper.class); HashMap<String,Integer> map = new HashMap<String,Integer>(); map.put("start",0); map.put("pagesize",2); List<User> list=mapper.limitlist(map); for (User user : list) { System.out.println(user); } sqlSession.close(); }
7.2、RowBounds分页（没有sql快）
直接跳过，需要时再来look
8、使用注解开发
8.1、面向接口编程
-
大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
-
根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的准则，使得开发变得容易，规范性更好！
-
在一个面向对象的系统中，系统的各种功能是有许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；
-
而各个对象之间的协作关系则称为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之处都是着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是按照这种思想来编程的。
关于接口的理解
- 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
- 接口的本身反映了系统设计人员对系统的抽象理解。
- 接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体（abstact class）；
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
- 一个个体有可能有多个抽象面。抽象体和抽象面是有区别的
三个面向区别
- 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性和方法
- 面向过程是指，我们考虑问题时，以流程（事务的过程）为单位，考虑它的实现；
- 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构
8.2、使用注解开发
不再需要接口实现的xml文件，直接使用java的注解，在括号里面写sql语句，然后去核心配置文件里面写一个mapper
public interface UserMapper {
@Select("select * from user")
List<User> getUserlist();
}
注意：无论是使用xml配置还是java注解实现sql语句，都必须配置mapper
<mappers>
<mapper class="com.spring.dao.UserMapper"></mapper>
</mappers>
本质：反射机制！
底层：动态代理！
Mybatis详细的执行流程
8.3 CRUD
我们可以在工具嘞创建的时候实现自动提交事务
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
增删改查大同小异
接口：
//如果有多个参数必须有@Param("id")包起来；
//并且底层在查的时候还是根据@Param("id")里面的值，尽量跟参数写一致
@Select("select * from user")
List<User> getUserlist();
@Select("select * from user where id=#{id}")
User getUser(@Param("id") int id);
@Insert("insert into user(id,name,pwd) values(#{id},#{name},#{pwd})")
int add(User user);
@Delete("delete from user where id=#{id}")
int delete(int id);
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int update(User user);
测试
public class Mytest {
@Test
public void getUserlist()
{
SqlSession sqlSession= MybatisUtils.getSqlSession();
UserMapper mapper=sqlSession.getMapper(UserMapper.class);
List<User> list=mapper.getUserlist();
for (User user : list) {
System.out.println(user);
}
}
@Test
public void getUserbyId()
{
SqlSession sqlSession= MybatisUtils.getSqlSession();
UserMapper mapper=sqlSession.getMapper(UserMapper.class);
User user=mapper.getUser(2);
System.out.println(user);
sqlSession.close();
}
@Test
public void add(){
SqlSession sqlSession= MybatisUtils.getSqlSession();
UserMapper mapper=sqlSession.getMapper(UserMapper.class);
int number=mapper.add(new User(7,"ssss","123123"));
if ((number>0))
System.out.println("增加成功");
sqlSession.close();
}
@Test
public void delete(){
SqlSession sqlSession= MybatisUtils.getSqlSession();
UserMapper mapper=sqlSession.getMapper(UserMapper.class);
int number=mapper.delete(7);
if ((number>0))
System.out.println("删除成功");
sqlSession.close();
}
@Test
public void update(){
SqlSession sqlSession= MybatisUtils.getSqlSession();
UserMapper mapper=sqlSession.getMapper(UserMapper.class);
int number=mapper.update(new User(1,"111","123123"));
if ((number>0))
System.out.println("修改成功");
sqlSession.close();
}
}
简单的SQL语句可以用java注解编写，复杂的还是要用接口实现类xml配置文件实现
关于@Param()注解
- 基本类型的参数或者String类型，需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
- 我们在Sql重引用的就是我们这里的@Param()设定的属性名！
$ 和 #的区别：
#{}
- 预编译处理
- 会替换成?
- 有效的防治SQL注入
${}
- 字符串替换
- 调用PreparedStatement的set方法进行赋值
- 会替换成变量的值 有效的防治SQL注入，提高代码的安全性
9、Lombok
- Project Lombok is a java library that automatically plugs into your
editor and build tools, spicing up your java.
- Never write anothergetter or equals method again, with one annotation
your class has a fully featured builder, Automate your logging
variables, and much more.
- java library
- plugs
- build tools
- with one annotation your class
使用步骤：
- 在IDEA中安装Lombok插件！
- 在项目中导入Lombok的jar包！
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.20</version> </dependency> -
@Data:无参构造，get，set，tostring，hashcode，equals@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
@AllAtgsConstructor 有参构造
@NoArgsConstructor 无参构造
@EqualsAndHashCode@Alias("User") @Data @AllArgsConstructor @NoArgsConstructor public class User { private int id; private String name; private String pwd; }
10、多对一处理
多个学生对一个老师
测试环境搭建
-
1、导入lombok
<dependencies> <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.20</version> </dependency> </dependencies> -
2、新建实体类 Teacher Student
@Alias("Student") @Data @AllArgsConstructor @NoArgsConstructor public class Student { private int id; private String name; private Teacher teacher; } @Alias("Teacher") @Data @AllArgsConstructor @NoArgsConstructor public class Teacher { private int id; private String name; } -
3、Mapper接口
public interface StudentMapper { List<Student> getStudentlist(); List<Student> getStudentlist2(); } -
4、Mapper.xml文件
<!--命名空间绑定的是要实现的接口--> <mapper namespace="com.spring.dao.StudentMapper"> <!--id绑定的是实现的方法，resultYype则绑定哪个类--> <select id="getStudentlist2" 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="Student"> <result property="id" column="sid"></result> <result property="name" column="sname"></result> <association property="teacher" javaType="Teacher"> <result property="id" column="tid"></result> <result property="name" column="tname"></result> </association> </resultMap> <!--=================================================--> <select id="getStudentlist" resultMap="StudentTeacher"> select * from mybatis.student </select> <!--复杂属性是对象的用association，嵌套子查询--> <resultMap id="StudentTeacher" type="Student"> <result property="id" column="id"></result> <result property="name" column="name"></result> <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association> </resultMap> <select id="getTeacher" resultType="Teacher"> select * from mybatis.teacher where id=#{tid} </select> </mapper> -
5、在核心配置文件中注册绑定我们的mapper接口
<mappers> <package name="com.spring.dao"/> </mappers> -
6、测试
- 按照嵌套子查询测试
<!--命名空间绑定的是要实现的接口--> <mapper namespace="com.spring.dao.StudentMapper"> <!--id绑定的是实现的方法，resultYype则绑定哪个类--> <select id="getStudentlist" resultMap="StudentTeacher"> select * from mybatis.student </select> <!--复杂属性是对象的用association，嵌套子查询--> <resultMap id="StudentTeacher" type="Student"> <result property="id" column="id"></result> <result property="name" column="name"></result> <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association> </resultMap> <select id="getTeacher" resultType="Teacher"> select * from mybatis.teacher where id=#{tid} </select> </mapper> 先把一个学生的信息查出来，然后根据嵌套查询的getTeacher将学生对象的teacher属性查出来。 - 按照结果嵌套联表查询
<!--命名空间绑定的是要实现的接口--> <mapper namespace="com.spring.dao.StudentMapper"> <!--id绑定的是实现的方法，resultYype则绑定哪个类--> <select id="getStudentlist2" 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="Student"> <result property="id" column="sid"></result> <result property="name" column="sname"></result> <association property="teacher" javaType="Teacher"> <result property="id" column="tid"></result> <result property="name" column="tname"></result> </association> </resultMap> </mapper> 先根据学生tid和教师id相同的查出一条信息，然后学生的信息id=id，name=name； 但是teacher则要转换成teacher对象，根据查到的结果tid和tname用resultmap的assocaition转换。
- 按照嵌套子查询测试
11、一对多处理
-
环境搭建
-
实体类
@Alias("Student") @Data @AllArgsConstructor @NoArgsConstructor public class Student { private int id; private String name; private int tid; }@Alias("Teacher") @Data @AllArgsConstructor @NoArgsConstructor public class Teacher { private int id; private String name; private List<Student> students; } -
接口类
public interface TeacherMapper { List<Teacher> getTeacherlist(); List<Teacher> getTeacherlist2(); } -
实现类
- 按照结果集查询
<select id="getTeacherlist" resultMap="TeacherStudent"> 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="TeacherStudent" type="Teacher"> <result property="id" column="tid"></result> <result property="name" column="tname"></result> <collection property="students" ofType="Student"> <result property="id" column="sid"></result> <result property="name" column="sname"></result> <result property="tid" column="tid"></result> </collection> </resultMap> - 按照嵌套子查询
<select id="getTeacherlist2" resultMap="TeacherStudent2"> select * from mybatis.teacher; </select> <resultMap id="TeacherStudent2" type="Teacher"> <result property="id" column="id"></result> <result property="name" column="name"></result> <collection property="students" column="id" ofType="Student" select="getStudents"></collection> </resultMap> <select id="getStudents" resultType="Student"> select * from mybatis.student where tid=#{id} </select>
- 按照结果集查询
-
小结：
- 1、关联 assoication（多对一）
- 2、集合 collection（一对多）
- 3、javaType 用来指定实体类中属性是引用类型的
- 4、offType 用来指定实体类中属性是集合的
- 面试高频：Mysql引擎，InnoDB底层原理、索引、索引优化
12、动态Sql
什么叫动态Sql：就是指根据不同的条件生成不同的sql语句
利用动态Sql这一特性可以彻底摆脱这种痛苦
动态Sql元素和JSTL或者基于XML的文本处理器类似。
在Mybatis之前的版中，有很多元素需要花时间了解。
Mybatis3大大精简了元素种类，现在只需要学习原来一半的元素即可。
Mybatis采用功能强大的基于OGNL的表达式来淘汰其他大部分元素。
if
choose（when，otherwise）
trim（where，set）
foreach
-
搭建环境：
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 -
创建一个基础工程
- 导包
- 配置文件
- 实体类
@Alias("Blog") @Data @AllArgsConstructor @NoArgsConstructor public class Blog { private String id; private String title; private String author; private Date createTime; private int views; }- mapper接口和mapper.xml
public interface BlogMapper { int add(Blog blog); List<Blog> queryBolgIf(Map<String,Object> map); List<Blog> queryBolgChoose(Map<String,Object> map); int update(Map<String,Object> map); }mapper.xml
IF<select id="queryBolgIf" parameterType="map" resultType="Blog"> select * from blog <where> <if test="title!=NULL"> title=#{title} </if> <if test="author!=NULL"> and author=#{author} </if> </where> </select>choose
<select id="queryBolgChoose" 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>set
<update id="update" parameterType="map"> update blog <set> <if test="title != null">title=#{title},</if> <if test="author != null">author=#{author},</if> <if test="createTime != null">createTime=#{createTime},</if> <if test="views != null">views=#{views}</if> </set> <!--记住，位置要放好--> where id=#{id} </update>Sql拼接
最好基于单表查询，最好没有Where<sql id="title-author"> <where> <if test="title!=NULL"> title=#{title} </if> <if test="author!=NULL"> and author=#{author} </if> </where> </sql> <select id="queryBolgIf" parameterType="map" resultType="Blog"> select * from blog <include refid="title-author"></include> </select>foreach
<select id="queryBlogForeach" parameterType="map" resultType="Blog"> select * from mybatis.blog where id in <foreach collection="ids" item="id" open="(" separator="," close=")"> #{id} </foreach> </select>**总结：**动态Sql就是在拼接SQL语句。我们只要保证Sql的正确性，按照Sql的格式去排列组合即可。
13、缓存
- 13.1、简介
- 查询：就是将查询到的数据暂存在一个内存中，当我们再次查询相同的数据是，直接走缓存，就不用走数据库了！
- 什么是缓存？
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从硬盘上查询，可以直接从缓存中读取，提高查询效率！
- 减少与数据库的交互次数，降低系统开销，提高系统效率！
- 什么样的数据能使用缓存？
经常查询并且不经常修改的数据
- 13.2、Mybatis缓存
- Mybatis包含一个非常强大的查询缓存特性，它可以非常方便的定制和配置缓存。缓存可以提高查询效率
- Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，只有一级缓存开启。（SqlSession）
- 二级缓存需要手动开启和配置，它是基于namespace级别的缓存
- 为了提高拓展性，Mybatis定义了缓存接口Cache。我们可以通过事先Cache接口来自定义二级缓存
- 13.3、一级缓存
-
一级缓存也叫本地缓存：
-
与数据同义词会话期间查询的数据，直接从缓存中拿，没必要再去数据库查询
-
测试步骤：
- 开启日志；
- 测试在一个SqlSession查询两次记录
- 查看日志输出
@Test public void test1(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); SqlSession sqlSession2=MybatisUtils.getSqlSession(); UserMapper mapper=sqlSession.getMapper(UserMapper.class); User user=mapper.getUser(1); User user1=mapper.getUser(1); System.out.println(user); System.out.println(user1); System.out.println(user==user1); sqlSession.close(); }
-
缓存失效的情况：
- 查询记录不相同
- 增加删除修改可能会修改原来的数据，所以缓存失效
- 手动清除缓存 sqlSeesion.clearCashe(); -
小结：默认开启，只在一次连接对象中有效，关闭时清除缓存
-
- 13.4、二级缓存
-
二级缓存也叫全局缓存，一级缓存的作用域太低了，所以诞生了二级缓存
-
基于namespace级别的缓存，一个命名空间，对应一个二级缓存；
-
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
- 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存的数据被保存到二级缓存中；
- 新的会话查询信息，就可以从二级缓存中获取内容；
- 不同的sqlsession查出的数据会放在自己对应的mapper中；
-
步骤:
-
开启全局缓存
<setting name="cacheEnabled" value="true"/> -
在mapper.xml中开启
<!--命名空间绑定的是要实现的接口--> <mapper namespace="com.spring.dao.UserMapper"> <!--开启二级缓存，先进先出，60秒间隔刷新，存512个，只读--> <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/> <select id="getUser" resultType="User" parameterType="int"> select * from user where id=#{id} </select> </mapper> -
测试
@Test public void test1(){ SqlSession sqlSession=MybatisUtils.getSqlSession(); UserMapper mapper=sqlSession.getMapper(UserMapper.class); User user=mapper.getUser(1); System.out.println(user); sqlSession.close(); SqlSession sqlSession2=MybatisUtils.getSqlSession(); UserMapper mapper2=sqlSession2.getMapper(UserMapper.class); User user2=mapper2.getUser(1); System.out.println(user2); System.out.println(user==user2); sqlSession.close(); }
-
-
问题：如果单纯只用,要将实体类实现Serializable，不然会报错
-
13.6、自定义缓存
-
611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
