五、拓展篇
5.1逻辑删除
在电商网站中,我们会上架很多商品,这些商品下架以后,我们如果将这些商品从数据库中删除,那么在年底统计商品的时候,这个商品要统计的,所以这个商品信息我们是不能删除的。
如果商城的商品下架了,这时候我们将商品从数据库删掉,那么到年终总结的时候,我们要总结这一年的销售额,发现少了20000,这肯定是不合理的。所以我们是不能将数据真实删除的。
- 这里我们就采取逻辑删除的方案,逻辑删除的操作就是增加一个字段表示这个数据的状态,如果一条数据需要删除,我们通过改变这条数据的状态来实现,这样既可以表示这条数据是删除的状态,又保留了数据以便以后统计。
1.修改字段
- 在表中增加一列字段status,表示是否删除的状态,这里我们使用的字段类型为int类型,通过1表示该条数据可用,0表示该条数据不可用。
2.修改实体类
- 实体类添加一个字段为Integer,用于对应表中的字段
java
public class User extends Model<User> {
private Long id;
@TableField("username")
private String name;
private Integer age;
private String email;
@TableField("`desc`")
private String desc;
//逻辑删除字段
@TableLogic(value = "1",delval = "0")
private Integer status;
}
3.测试逻辑删除效果
java
@Test
void LogicDelete() {
userMapper.deleteById(7L);
}
4.查询t_user表
java
@Test
void logicSelect() {
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
- 我们还可以通过全局配置来实现逻辑删除的效果
properties
#配置逻辑删除字段
mybatis-plus.global-config.db-config.logic-delete-field=status
#未删除为1
mybatis-plus.global-config.db-config.logic-not-delete-value=1
#删除为0
mybatis-plus.global-config.db-config.logic-delete-value=0
5.2通用枚举
- 当我们想要表示一组信息,这组信息只能从一些固定的值中进行选择,不能随意写,在这种场景下,枚举就非常的合适。
- 假如我们想要表示性别,性别只有两个值,要么是男性,要么是女性,那我们就可以使用枚举来描述性别。
1.添加字段
- 我们先在表中添加一个字段gender,表示性别,这里一般使用int来描述,因为int类型可以通过0和1这两个值来表示两个不同的性别
2.编写枚举类
java
public enum GenderEnum {
MAN(0,"男"),WOMEN(1,"女");
@EnumValue
private Integer gender;
private String genderName;
GenderEnum(Integer gender, String genderName) {
this.gender = gender;
this.genderName = genderName;
}
}
3.实体类添加相关字段
java
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User extends Model<User> {
private Long id;
private String name;
private Integer age;
private String email;
private GenderEnum gender;
private Integer status;
}
4.添加数据
java
@Test
void enumTest() {
User user = new User();
user.setName("王五");
user.setAge(28);
user.setEmail("wangwu@qq.com");
user.setStatus(1);
user.setGender(GenderEnum.WOMEN);
userMapper.insert(user);
}
5.3字段类型处理器
- 在某些场景下,我们在实体类中是使用Map集合作为属性接收前端传递过来的数据的,但是这些数据存储在数据库时,我们使用的是json格式的数据进行存储,json本质是一个字符串,就是varchar类型。那怎么做到实体类的Map类型和数据库的varchar类型的互相转换,这里就需要使用字段类型处理器来完成。
1.在实体类中添加一个字段,Map类型
java
@Data
@NoArgsConstructor
@AllArgsConstructor
//查询时将json字符串封装为Map集合
@TableName(autoResultMap = true)
public class User extends Model<User> {
private Long id;
@TableField("username")
private String name;
private Integer age;
private String email;
@TableField("`desc`")
private String desc;
@TableField(exist = false)
private Integer online;
private Integer status;
private GenderEnum gender;
//指定字段类型处理器
@TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String,String> contact;//联系方式
}
2.在数据库中添加一个字段contact,为varchar类型
3.添加依赖
- 字段类型处理器依赖Fastjson这个Json处理器,所以我们需要引入对应的依赖
xml
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.7</version>
</dependency>
4.测试添加操作
java
@Test
void typeHandler() {
User user = new User();
user.setName("Li");
user.setAge(28);
user.setEmail("li@qq.com");
user.setGender(GenderEnum.MAN);
user.setStatus(1);
HashMap<String, String> map = new HashMap<>();
map.put("tel", "15896637666");
map.put("phone", "0371-60283366");
user.setContact(map);
userMapper.insert(user);
}
5.测试查询操作
java
@Test
void typeHandlerSelect() {
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
5.4自动填充功能
- 在项目中有一些属性,如果我们不希望每次都填充的话,我们可以设置为自动填充,比如常见的时间。
1.在数据库的表中添加两个字段
- 注意设置驼峰命名
2.添加字段
- 在实体类中,添加对应字段,并为需要自动填充的属性指定填充时机
java
//插入时自动填充createTime字段
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//插入或更新时自动填充updateTime字段
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
3.编写自动填充处理器,指定填充策略
java
@Component
public class MyMetaHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
setFieldValByName("createTime",new Date(),metaObject);
setFieldValByName("updateTime",new Date(),metaObject);
}
@Override
public void updateFill(MetaObject metaObject) {
setFieldValByName("updateTime",new Date(),metaObject);
}
}
4.测试插入操作
java
@Test
void testFillInsert(){
User user = new User();
user.setName("wang");
user.setAge(35);
user.setEmail("wang@powernode.com");
user.setGender(GenderEnum.MAN);
user.setStatus(1);
HashMap<String, String> contact = new HashMap<>();
contact.put("phone","010-1234567");
contact.put("tel","13388889999");
user.setContact(contact);
userMapper.insert(user);
}
5.测试更新操作
java
@Test
void testFillUpdate(){
User user = new User();
user.setId(18L);
user.setName("wangwu");
user.setAge(39);
user.setEmail("wang@powernode.com");
user.setGender(GenderEnum.MAN);
user.setStatus(1);
HashMap<String, String> contact = new HashMap<>();
contact.put("phone","010-1234567");
contact.put("tel","13388889999");
userMapper.updateById(user);
}
5.5防全表更新与删除插件
- 在实际开发中,全表更新和删除是非常危险的操作,在MybatisPlus中,提供了插件和防止这种危险操作的发生。
1.注入MybatisPlusInterceptor类,并配置BlockAttackInnerInterceptor拦截器
java
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//防止全表更新
interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
return interceptor;
}
}
2.测试全表更新
java
@Test
public void updateAll(){
User user = new User();
user.setGender(GenderEnum.MAN);
userService.saveOrUpdate(user,null);
}
5.6MybatisX快速开发插件
- MybatisX是一款IDEA提供的插件,目的是为了我们简化Mybatis以及MybatisPlus框架而生。
5.6.1安装
5.6.2功能
1.点击小鸟,Mapper接口和映射文件可以互相跳转
2.逆向工程
- 逆向工程就是通过数据库表结构,逆向产生Java工程的结构
- 包括以下几点:
- 实体类
- Mapper接口
- Mapper映射文件
- Service接口
- Service实现类
1.引入依赖,编写对应的配置文件信息
xml
<dependencies>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
properties
#配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=030522
2.使用IDEA连接mysql
3.使用逆向工程
4.编写逆向工程配置信息和生成信息
5.在Mapper接口上添加@Mapper注解
java
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
6.测试
java
@SpringBootTest
class Mp03ApplicationTests {
@Autowired
private UserMapper userMapper;
@Resource
private UserService userService;
@Test
void testUserMapper() {
List<User> users = userMapper.selectList(null);
users.forEach(user -> System.out.println(user));
}
@Test
void testUserService() {
User byId = userService.getById(10L);
System.out.println(byId);
}
}
3.常见需求代码生成
- 虽然Mapper接口中提供了一些常见方法,我们可以直接使用这些方法来完成sql操作,但是对于实际场景中各种复杂的操作需求来说,依然是不够用的,所以MybatisX提供了更多的方法,以及可以根据这些方法直接生成对应的sql语句,这样使得开发变得更加简单。
5.7乐观锁
- 首先我们先要了解开发中的一个常见场景,叫做并发请求。并发请求就是在同一时刻有多个请求同时请求服务器资源,如果是获取信息,没什么问题,但是如果是对于信息做修改操作就会出现问题。
比如目前商品的库存只剩余1件了,这个时候有多个用户都想要购买这件商品,都发起了购买商品的请求,不能让多个用户都购买到,因为多个用户都买到了这件商品,那么就会出现超卖问题,库存不够是没法发货的。所以在开发中就要解决这种超卖的问题。
- 这类场景的核心问题就是,一个请求在执行的过程中,其他请求不能改变数据,如果是一次完整的请求,在该请求的过程中其他请求没有对于这个数据产生修改操作,那么这个请求是能够正常修改数据的。如果该请求在改变数据的过程中,已经有其他请求改变了数据,那该请求就不能改变这条数据了。
- 想要解决这类问题,最常见的就是加锁的思想,锁可以用验证在请求的执行过程中,是否有数据发生改变。
- 常见的数据库锁类型有两种:悲观锁、乐观锁。
- 一次完成的修改操作是:先查询数据,然后修改数据。
- 悲观锁:悲观锁是在查询的时候就锁定数据,在这次请求未完成之前,不会释放锁,等到这次请求完毕之后再释放锁,释放了锁之后,其他请求才可以对于这条数据完成读写。例子:华为商店抢手机,排队中...
- 这样做的操作能够保证读取到的信息就是当前的信息,保证了信息的正确性,但是并发效率很低,在实际开发中使用悲观锁的场景很少,因为在并发时我们是要保证效率的。
- 乐观锁:乐观锁是通过表字段完成设计的,他的核心思想是,在读取的时候不加锁,其他请求依然可以读取到这个数据,在修改的时候判断一个数据是否有被修改过,如果有被修改过那么本次请求的修改操作失效。例子:大麦抢票
具体的SQL语句
Update 表 set 字段 = 新值,version = version + 1 where version = 1
- 这样做的操作是不会对于数据读取产生影响的,并发效率高,但是可能眼前看到的数据并不是真实信息数据,是被修改之前的,在很多场景下是可以容忍的,并不是产生很大影响,例如很多时候我们看到的是有库存或者都加入到购物车了,但是点进去以后库存没有了。
乐观锁的使用
1.在数据库表中添加一个字段version,表示版本,默认值是1
2.找到实体类,添加对应的属性,并使用@Version标注为这是一个乐观锁字段信息
java
@Version
private Integer version;
3.配置拦截器
- 因为要对每条修改语句完成语句的增强,这里我们通过拦截器的配置,让每条修改的sql语句在执行的时候,都加上版本控制的功能。
java
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//实现乐观锁的控制
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return interceptor;
}
}
4.测试效果
- 先模拟查询,再修改
java
@Test
void updateTest() {
User user = userMapper.selectById(18L);
System.out.println(user);
user.setName("赵六");
userMapper.updateById(user);
}
- 当我们完成修改时,会自动将版本号+1
5.模拟多个修改请求
- 乐观锁的效果是,一个请求在修改的过程中,是允许另一个请求查询的,但是修改时会通过版本号是否改变来决定是否修改,如果版本号变了,证明已经有请求修改过数据了,那这次修改不生效,如果版本号没有发生变化,那就完成修改。
java
@Test
void updateTest2() {
//模拟操作1的查询操作
User user1 = userMapper.selectById(18L);
System.out.println(user1);
//模拟操作2的查询操作
User user2 = userMapper.selectById(18L);
System.out.println(user2);
user2.setName("zhao");
userMapper.updateById(user2);
user1.setName("liu");
userMapper.updateById(user1);
}
- 这段代码其实是两次操作,只不过操作1在执行的过程中,有操作2完成了对于数据的修改,这时操作1就无法再次进行修改了。
5.8代码生成器
- 代码生成器和逆向工程的区别在于,代码生成器可以生成更多的结构,更多的内容,允许我们能够配置生成的选项更多。
1.引入依赖
xml
<!--代码生成器依赖-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.3</version>
</dependency>
<!--freemarker模板依赖-->
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.31</version>
</dependency>
2.编写代码生成器代码
java
@SpringBootTest
public class GeneratorApplicationTests {
public static void main(String[] args) {
FastAutoGenerator.create("jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false", "root", "030522")
.globalConfig(builder -> {
builder.author("hhb") // 设置作者
//.enableSwagger() // 开启 swagger 模式
.fileOverride() // 覆盖已生成文件
.outputDir("D://"); // 指定输出目录
})
.packageConfig(builder -> {
builder.parent("com.hhb.mp02") // 设置父包名
.moduleName("mybatisplus") // 设置父包模块名
.pathInfo(Collections.singletonMap(OutputFile.xml, "D://")); // 设置mapperXml生成路径
})
.strategyConfig(builder -> {
builder.addInclude("t_user") // 设置需要生成的表名
.addTablePrefix("t"); // 设置过滤表前缀
})
.templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板,默认的是Velocity引擎模板
.execute();
}
}
3.执行,查看生成效果
5.9执行SQL分析打印
- 在我们日常开发工作中,避免不了查看当前程序所执行的SQL语句,以及了解它的执行时间,方便分析是否出现了慢SQL问题。我们可以使用MybatisPlus提供的SQL分析打印的功能,来获取SQL语句执行的时间。
1.引入依赖
xml
<dependency>
<groupId>p6spy</groupId>
<artifactId>p6spy</artifactId>
<version>3.9.1</version>
</dependency>
2.修改application.properties配置文件
properties
#配置数据源
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatisplus?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=030522
3.在resources下,创建spy.properties配置文件
properties
#3.2.1以上使用modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2
4.测试
- 执行查询所有的操作,可以看到sql语句的执行时间。
5.10多数据源
- 当一个项目的数据库的数据十分庞大时,在完成SQL操作的时候,需要检索的数据就会更多,我们会遇到性能问题,会出现SQL执行效率低的问题。
- 针对这个问题,我们的解决方案是,将一个数据库中的数据拆分到多个数据库中,从而减少单个数据库的数据量,从分摊访问请求的压力和减少单个数据库数据量这两个方面,都提升了效率。
数据源切换
1.引入依赖
xml
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
2.创建新的数据库,提供多数据源环境
3.编写配置文件,指定多数据源信息
yml
spring:
datasource:
dynamic:
primary: master
strict: false
datasource:
master:
username: root
password: root
url: jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
driver-class-name: com.mysql.cj.jdbc.Driver
slave_1:
username: root
password: root
url: jdbc:mysql://localhost:3306/mybatisplus2?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
driver-class-name: com.mysql.cj.jdbc.Driver
4.创建多个Service,分别使用@Ds注解描述不同的数据源信息
java
@Service
@DS("master")
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
}
java
@Service
@DS("slave_1")
public class UserServiceImpl2 extends ServiceImpl<UserMapper, User> implements UserService{
}
5.测试service多数据源环境执行结果
java
@SpringBootTest
class Mp03ApplicationTests {
@Autowired
private UserServiceImpl userServiceImpl;
@Autowired
private UserServiceImpl2 userServiceImpl2;
@Test
public void select(){
User user = userServiceImpl.getById(1L);
System.out.println(user);
}
@Test
public void select2(){
User user = userServiceImpl2.getById(1L);
System.out.println(user);
}
}
- 测试发现,结果可以从两个数据源中获取。