Thu Feb 18

Java

MyBatis-Plus（偷懒神器）

MyBatis-Plus

0.官网

MyBatis-Plus官网

1.MyBatis-Plus简介

好处：MyBatisPlus可以节省我们大量工作时间，所有的CRUD代码它都可以自动化完成

简介：MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

2.快速入门

使用SpringBoot快速入门

2.1.创建数据表

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
	id BIGINT(20) NOT NULL COMMENT '主键ID',
	name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
	age INT(11) NULL DEFAULT NULL COMMENT '年龄',
	email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (id)
);

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

2.2.导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2.3.配置application.properties

#mybatisplus 数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatisplus
spring.datasource.username=root
spring.datasource.password=XXXXXXXXX

2.4.Mapper和实体类

@Repository
public interface UserMapper extends BaseMapper<User> {

}

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

@SpringBootApplication
@MapperScan("com.hznu.ch.springinaction.dao.mybatisplus")//添加注解使启动类可以扫描到我们定义的Mapper
public class SpringInActionApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringInActionApplication.class, args);
    }
}

2.5.测试

@SpringBootTest(classes = SpringInActionApplication.class)
public class SampleTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

3.配置日志

在application.properties文件中配置如下代码，即可控制台输出日志

#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4.雪花算法

4.1.插入测试

首先测试一下插入

@Test
public void testInsert() {
    User user = new User();
    user.setName("ch");
    user.setEmail("abcdefg@qq.com");
    user.setAge(22);

    userMapper.insert(user);
}

我们可以看到Mybatis-Plus自动填充了主键，插入的默认值是全局唯一的id

4.2.主键生成策略

Mybatis-Plus中默认使用雪花算法生成唯一id

4.2.1.Twitter的snowflake算法（雪花算法）

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter/snowflake。

4.2.2.自增策略

数据库的id字段设置为自增
实体类的id属性添加注解@TableId(type = IdType.AUTO)

4.2.3.其余策略

值	描述
AUTO	数据库ID自增
NONE	无状态,该类型为未设置主键类型(==注解里等于跟随全局==,全局里约等于 INPUT)
INPUT	insert前自行set主键值
ASSIGN_ID	分配ID(主键类型为Number(Long和Integer)或String)(since 3.3.0),使用接口`IdentifierGenerator`的方法`nextId`(默认实现类为`DefaultIdentifierGenerator`雪花算法)
ASSIGN_UUID	分配UUID,主键类型为String(since 3.3.0),使用接口`IdentifierGenerator`的方法`nextUUID`(默认default方法)

这里就不是很明白了，IdTyep默认是NONE，且跟随全局，官方文档说全局约等于INPUT，但我测试下来发现即使是NONE的话，插入到数据库的id也是根据ASSIGN_ID（雪花算法）来的，那是不是说明全局配置主键生成策略是ASSIGN_ID或者说全局是INPUT，但在插入之前Mybatis-Plus对id做了一定程度（比如使用ASSIGN_ID生成）的修改？？？（不懂，留坑）

==2021-2-18填坑日记==

public enum IdType {
    AUTO(0),			
    NONE(1),			
    INPUT(2),			
    ASSIGN_ID(3),	
    ASSIGN_UUID(4),
    /** @deprecated */
    @Deprecated
    ID_WORKER(3),
    /** @deprecated */
    @Deprecated
    ID_WORKER_STR(3),
    /** @deprecated */
    @Deprecated
    UUID(4);

    private final int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

5.自动填充

5.1.更新测试

@Test
public void testUpdate() {
    User user = new User();
    user.setId(5L);
    user.setName("cd");
    userMapper.updateById(user);
}

所有的sql都是动态拼接而成

5.2.自动填充

对于数据表的创建时间和修改时间一般都是自动化完成的

5.2.1.数据库级别

首先添加gmt_create，gmt_update这个两个字段，type选择datatime，默认值选择CURRENT_TIMESTAMP，gmt_update字段勾选更新时间戳即可（感谢某位老板的勘误）
实体类同步

@Data
public class User {
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    private LocalDateTime gmtCreate;
    private LocalDateTime gmtUpdate;
}

5.2.2.代码级别

删除原先的默认值

2.实体类的属性添加注解

@TableField(fill = FieldFill.INSERT)
private LocalDateTime gmtCreate;

@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime gmtUpdate;

编写处理器

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.strictInsertFill(metaObject, "gmtCreate", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
        this.strictInsertFill(metaObject, "gmtUpdate", LocalDateTime.class, LocalDateTime.now());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.strictUpdateFill(metaObject, "gmtUpdate", LocalDateTime.class, LocalDateTime.now());
    }
}

测试插入和更新

@Test
public void testInsert() {
    User user = new User();
    user.setName("ch");
    user.setEmail("abcdefg@qq.com");
    user.setAge(22);

    userMapper.insert(user);

}

@Test
public void testUpdate() {
    User user = new User();
    user.setId(4L);
    user.setName("cd");
    userMapper.updateById(user);
}

6.乐观锁

乐观锁：无论干什么都不去上锁（那怎么避免脏读呢？可以使用version字段判断是否可以操作）

悲观锁：无论干什么都上锁

6.1.实现流程

取出记录，获取当前version
更新时，带上这个version
执行更新时，set version=newVersion where version=oldVersion
如果version版本不对，就更新失败

6.2.乐观锁插件

数据表添加version字段（这里是为了填充之前的数据，其实不需要默认值，我们在insertFill时再添加一个version字段即可）

@Override
public void insertFill(MetaObject metaObject) {
    log.info("start insert fill ....");
    this.strictInsertFill(metaObject, "gmtCreate", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
    this.strictInsertFill(metaObject, "gmtUpdate", LocalDateTime.class, LocalDateTime.now());
    this.strictInsertFill(metaObject, "version", Integer.class, 1);
}

实体类中添加version属性

@Version
private Integer version;

编写乐观锁插件配置类（最新版这么配置）

@Configuration
@EnableTransactionManagement
@MapperScan("com.hznu.ch.springinaction.dao.mybatisplus")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

正例测试

测试bug1

如下的测试会导致gmt_update自动填充失败，具体原因参考mybatis plus坑之 - updateById写法导致自动填充不生效

在updateById方法中所传的实体参数，针对自动填充的字段：
如果字段值非空，则按照所传的值更新；
如果字段值为空，则按照自动填充的规则更新。

所以，所传的实体最好不要select出来，而是新new一个实体，赋值id值和变动值（见上一个代码段），updateById方法会根据所传id更新变动值+自动填充字段。
注意：@Version注解说明：更新时，实体对象的version属性必须有值，才会更新对应字段，所以new实体的方法，会使@version失效

@Test
public void testOptimisticLocker() {
    User user = userMapper.selectById(1L);//查询出来的gmtUpdate非空，所以无法自动填充
    user.setName("zs");
    user.setEmail("111111@qq.com");
    userMapper.updateById(user);
}

从源码里扒出来的，strictFillStrategy只有非空才能自动填充

default MetaObjectHandler strictFillStrategy(MetaObject metaObject, String fieldName, Supplier<?> fieldVal) {
    if (metaObject.getValue(fieldName) == null) {
        Object obj = fieldVal.get();
        if (Objects.nonNull(obj)) {
            metaObject.setValue(fieldName, obj);
        }
    }

    return this;
}

如果我们使用setFieldValByName的话，不需要判断该属性是否为空，直接覆盖

default MetaObjectHandler setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject) {
    if (Objects.nonNull(fieldVal) && metaObject.hasSetter(fieldName)) {
        metaObject.setValue(fieldName, fieldVal);
    }

    return this;
}

由此我们有如下两种解决策略

策略1：使用strictUpdateFill，new新对象

@Test
public void testOptimisticLocker() {
    User tmpUser = userMapper.selectById(1L);
    User user = new User();
    user.setId(1L);
    user.setName("zzs");
    user.setEmail("111111@qq.com");
  	user.setVersion(tmpUser.getVersion());//这是实现乐观锁的关键，这个字段为null则不会实现乐观锁
    userMapper.updateById(user);
}

策略2：使用setFieldValByName，原先对象上操作

@Override
public void updateFill(MetaObject metaObject) {
    log.info("start update fill ....");
    //this.strictUpdateFill(metaObject, "gmtUpdate", LocalDateTime.class, LocalDateTime.now());
    this.setFieldValByName("gmtUpdate", LocalDateTime.now(), metaObject);
}

@Test
public void testOptimisticLocker2() {
    User user = userMapper.selectById(1L);
    user.setName("zs");
    user.setEmail("111111@qq.com");
    userMapper.updateById(user);
}

反例测试

@Test
public void testOptimisticLocker3() {
    User user = userMapper.selectById(1L);
    user.setName("zs");
    user.setEmail("111111@qq.com");

    //模拟多线程抢占资源，插队
    User user1 = userMapper.selectById(1L);
    user1.setName("dg");
    user1.setEmail("222222@qq.com");
    userMapper.updateById(user1);

    //如果乐观锁生效，则这句代码应该失效，数据库中id=1的用户email为222222@qq.com
    userMapper.updateById(user);
}

7.查询操作

@Test
public void testSelectById() {
    //查询id
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

@Test
public void testSelectByBatchId() {
    //批量查询id
 		//SELECT id,name,age,email,gmt_create,gmt_update,version FROM user WHERE id IN ( ? , ? , ? )
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}

@Test
public void testSelectByMap() {
    //map查询
  	//SELECT id,name,age,email,gmt_create,gmt_update,version FROM user WHERE age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("age", 22);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

8.分页查询

配置分页插件

@Configuration
@EnableTransactionManagement
@MapperScan("com.hznu.ch.springinaction.dao.mybatisplus")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        
        //乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

        //分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

测试

@Test
public void testPage() {
    //当前页数1 当前页大小
    Page<User> page = new Page<>(1, 3);
    userMapper.selectPage(page, null);
    List<User> records = page.getRecords();
    records.forEach(System.out::println);
}

从日志输出我们可以知道，MybatisPlus对于分页先统计出总数，再使用limit分页，每次查询分页都要访问一次数据库，由此我有个想法，我们是不是可以使用缓存做分页查询，搜了一下，还真有解决方案，用Redis的Zset做缓存即可

range(key,start,limit)按照分页条件获取缓存，命中则直接返回
缓存未命中，查询（没有分页条件）数据库或是调用（没有分页）底层接口
add(key,valueScoreMap<value,score>)写入缓存，expire设置缓存时间
当需要清理缓存时，直接删除key，如果是因为数据新增和删除，可以add(key,value,score)或remove(key,value)

Redis分页查询缓存方案

9.逻辑删除

对于有些信息，即使删除了，管理员仍然可以查看，这就涉及软删除（逻辑删除），类似于我们的回收站。

注意一点，我现在使用的是MybatisPlus 3.4.2，无需进行逻辑删除Bean的配置，直接使用注解和配置文件即可。

添加deleted字段（这里是为了填充之前的数据，其实不需要默认值，我们在insertFill时再添加一个deleted字段即可）

@Override
public void insertFill(MetaObject metaObject) {
    log.info("start insert fill ....");
    this.strictInsertFill(metaObject, "gmtCreate", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
    this.strictInsertFill(metaObject, "gmtUpdate", LocalDateTime.class, LocalDateTime.now());
    this.strictInsertFill(metaObject, "version", Integer.class, 1);
    this.strictInsertFill(metaObject, "deleted", Integer.class, 1);
}

实体类添加属性

@TableLogic
private Integer deleted;

配置配置文件

#配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-field=deleted
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

测试

逻辑删除执行的是更新操作，更新deleted字段

@Test
public void testLogicDelete() {
    userMapper.deleteById(1362010267878551554L);
}

10.执行SQL分析打印

导入依赖

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.1</version>
</dependency>

修改application.properties文件

#mybatisplus 数据库配置
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatisplus
spring.datasource.username=root
spring.datasource.password=XXXXXXXXX

添加spy.properties文件

文件配置来源于官方文档

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,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

测试

@Test
public void testPage() {
    //当前页数1 当前页大小
    Page<User> page = new Page<>(2, 3);
    userMapper.selectPage(page, null);
    List<User> records = page.getRecords();
    records.forEach(System.out::println);
}

日志输出中比之前多了SQL执行的时间花销

11.条件构造器

11.1.条件测试

以下仅为个人测试内容，更多更加详细的请参考官方文档

allEq

allEq(Map<R, V> params)						//不带过滤器的
allEq(BiPredicate<R, V> filter, Map<R, V> params)//带过滤器的

@Test
public void testAllEq() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    Map<String, Object> map = new HashMap<>();
    map.put("id", 1);
    map.put("name", "dg");
  	//仅筛选出key中带'a'字符的键值对
    List<User> users = userMapper.selectList(wrapper.allEq((k, v) -> k.indexOf('a') >= 0, map));
    users.forEach(System.out::println);
}

like

like(R column, Object val)

@Test
public void testLike() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.like("name", 'c');
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

select

设置查询字段

select(String... sqlSelect)

@Test
public void testSelect() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
  	// Execute SQL：SELECT name FROM user WHERE deleted=0
    wrapper.select("name");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

11.2.Wrapper自定义SQL

注意事项:

需要mybatis-plus版本 >= 3.0.7 param 参数名要么叫ew,要么加上注解@Param(Constants.WRAPPER) 使用${ew.customSqlSegment} 生成 Wrapper 内的entity不支持的where语句

11.2.1.注解

@Select("select * from mysql_data ${ew.customSqlSegment}")
List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

11.2.2.XML

List<MysqlData> getAll(Wrapper ew);

<select id="getAll" resultType="MysqlData">
	SELECT * FROM mysql_data ${ew.customSqlSegment}
</select>

12.代码生成器

导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>

编写代码生成器

public class CodeBirthday {
    public static void main(String[] args) {
        AutoGenerator mpg = new AutoGenerator();


        //全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("陈恒");
        gc.setOpen(false);
        gc.setFileOverride(false);
        gc.setServiceName("%sService");
        gc.setIdType(IdType.ASSIGN_UUID);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);


        //设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDriverName("com.p6spy.engine.spy.P6SpyDriver");
        dsc.setUrl("jdbc:p6spy:mysql://localhost:3306/mybatisplus");
        dsc.setUsername("root");
        dsc.setPassword("XXXXXXX");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        //包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog");
        pc.setParent("com.ch");
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        //策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//多张表，在这里传入
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
        strategy.setLogicDeleteFieldName("deleted");


        //自动填充策略
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtUpdate = new TableFill("gmt_update", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtUpdate);
        strategy.setTableFillList(tableFills);

        //乐观锁配置
        strategy.setVersionFieldName("version");

        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);

        mpg.execute();
    }
}

测试

13.总结

Mybatis-Plus总的来说，不难，算是把很早之前的一个坑给填上了。

这个代码生成器有点东西的，基本上把项目的框架给搭出来了。

这东西呐给我的感觉除了方便还有一种危机感吧，代码自动化程度越高，对于程序员的技术要求也会更高。

所以共勉吧各位！！！加油加油！！！

# 框架