写在前面

经常看到别人提交的代码记录里面包含一些feat、fix、chore等等，而我在提交时也不会区分什么，直接写下提交信息，今天就来看一下怎么个事，就拿 element-plus/ant-design 来看一下。

其实这么写是一种代码提交规范，当然不是为了炫技，主要目的是为了提高提交记录的可读性和自动化处理能力。

当然如果团队没有要求，不这么写也可以。

git 提交规范

commit message = subject + ：+ 空格 + message 主体

例如： feat：增加用户注册功能

常见的 subject 种类以及含义如下：

总结

使用规范的提交消息可以让项目更加模块化、易于维护和理解，同时也便于自动化工具（如发布工具或 Changelog 生成器）解析和处理提交记录。

通过编写符合规范的提交消息，可以让团队和协作者更好地理解项目的变更历史和版本控制，从而提高代码维护效率和质量。

1.魔法值和硬编码

在代码编写的场景中，会遇到提示避免去使用 魔法值（magic numbers）和硬编码（hardcoding）。

• 魔法值就是在代码中直接使用的，没有提供任何注释或解释说明其用途和含义的常数值。


• 硬编码指的是在程序中直接使用特定的值或信息，而不是通过变量、常量或其他可配置的方式来表示。这些值通常是字面量字符串、数字或其他原始数据类型，在代码中写死了，无法修改。

缺点：

不便于维护：如果需要修改值，必须手动在代码中查找并替换，会增加代码修改的复杂度和风险。

可读性差：硬编码的值缺乏描述和注释，不易于理解和解释。在工作中，协作开发，其他开发人员在阅读代码时可能无法理解这些值的含义和作用。

维护困难：当需要修改值的时候，需要在代码中找到所有使用该值的地方进行手动修改。这样容易出错，而且增加了代码维护的复杂性。

2.定义常量

场景：设π取小数点后五位数(即3.14159)计算圆的面积

Java常量定义是指在Java程序中定义一个不可修改的值，Java常量的定义使用关键字final，一般与static关键字一起使用。

此时可以通过定义一个常量作为π

public class MyClass {  

    //圆周率π

    public static final double PI = 3.14159;  

}

上面这个定义在类中的常量称为 类常量，可以通过类名访问。

通过定义常量，就避免在代码中直接使用没有明确含义的硬编码数字。取而代之，将这些数字赋值给具有描述性名称的常量。

3.if - else if - else if - else if.....else

在项目中看过这面这段代码，通过判断天气给出建议

public void handleWeather(String weather) {  

    if (weather.equals("晴天")) {  

        System.out.println("做好防晒");  

    } else if (weather.equals("阴天")) {  

        System.out.println("户外活动");  

    } else if (weather.equals("小雨")) {  

        System.out.println("带雨伞");  

    } else if (weather.equals("雷雨")) {  

        System.out.println("避免户外活动");  

    } else {  

        System.out.println("未知天气");  

    }  

}

这段代码的判断条件 "晴天"、"阴天"、"小雨"等，这些条件在项目不止使用到了一次，比如在另外一个方法中也有一个判断，但是判断执行的方法体不同，如下

public void handleWeather(String weather) {  

    if (weather.equals("晴天")) {  

        System.out.println("出太阳");  

    } else if (weather.equals("阴天")) {  

        System.out.println("有乌云");  

    }

    ....

}

现在如果需要 把 晴天 这个天气情况修改为 高温天，那么就需要修改两处地方，在实际项目中可能更多。

所以这里必须要定义枚举提高代码的可维护性

4.定义枚举

定义枚举类如下

public enum WeatherType {  

    SUNNY("晴天"),  

    CLOUDY("阴天"),  

    LIGHT_RAIN("小雨"),  

    THUNDERSTORM("雷雨"),  

    UNKNOWN("未知天气");  

  

    private final String message;  

  

    WeatherType(String message) {  

        this.message = message;  

    }  

  

    public String getMessage() {  

        return message;  

    }  

}

将代码用枚举结合switch case来替换

public void handleWeather(String weather) {  

    WeatherType weatherType = WeatherType.valueOf(weather);  

    switch (weatherType) {  

        case SUNNY:  

            System.out.println("做好防晒");  

            break;  

        case CLOUDY:  

            System.out.println("户外活动");    

            break;  

        case LIGHT_RAIN:  

            System.out.println("带雨伞");    

            break;  

        case THUNDERSTORM:  

            System.out.println("避免户外活动");   

            break;  

        case UNKNOWN:  

            System.out.println("未知天气");

						break; 

    }  

}

5.结语

在日常工作中，会有很多状态类型的字段，比如淘宝订单，状态可以为：待付款、待发货、已发货、已签收、交易成功等，真实场景状态可能更多。

而状态也会被很多代码给使用到，所以必须通过集中统一的方式来定义。

通过常量、枚举，可以很好的解决问题，一旦状态有新增、修改、删除都只需要修改一处地方，其它代码直接引用就行。

运营：别再让你的页面一直loading 了

第一轮 battle

Q： 我想下载一个大文件，界面一直转圈，很耽误时间，我想在下载的时候还做点其他事情

A：一直转圈就一直等呗，反正还能摸会（奈何小姐姐太想做牛马了）

第二轮 battle

Q： 不行，为什么别人的浏览器，下载软件/文件 就能操作界面，你这就一直转圈，什么都做不了

A： 我们js 是单线程，一个时间只能做一件事，你不能在下载文件的时候，还操作界面吧...逐渐语无伦次，行，我给你试着优化优化..

最终效果

可以看到，下载文件 页面不再转圈，并且可以在界面操作，但是在点击操作1，2，到3的时候，会卡顿一下，下面会说为什么会卡这一下

开始分析

but： 是不转圈了，下载的时候，依然操作不了界面

2. js 是一个单线程，一个时间只能做一件事，密集的cpu 计算，导致网站反应迟钝，就像卡了一样

前言

MP 从出现就一直有争议 感觉一直 都存在两种声音

like：

很方便啊 通过函数自动拼接 Sql 不需要去 XML 再去使用标签 之前一分钟写好的 Sql 现在一秒钟就能写好 简直不要太方便

dislike：

侵入 Service 层 不好维护 可读性差 代码耦合 效率不行 sql 优化比较难

之前也有前辈说少用 MP 理由就是不好维护 但是这个东西真的是方便 只要不是强制不让用 就还是会去使用 存在集合里 最近也确实有一些体会 就从两个角度去看一下 MP

优点

操作简洁

就从我们编码中最常用的增删改查去说

按照我们之前去使用 Mybatis 的喜欢我们就要去建立一个 XML 文件 去编写 Sql 语句 算是半自动 我们可以直接去操控 Sql 语句 但是会比较麻烦 很多简单的数据查询我们都要去写一个标签 感觉这种没有意义的操作还是比较烦的 那么 MP 里面怎么实现

第一种： 最简单我们就是直接去使用提供的方法 我们非常简单就能做到这些操作 但是这个就有一个问题

nodeMapper.selectById(1);

nodeMapper.deleteById(2);

nodeMapper.updateById(new Node());

nodeMapper.insert(new Node());

维护性差 以查询为例 这个默认提供的方法都是查询所有字段我们都知道在编写 Sql 的时候第一条优化准则就是不要使用 Select * 因为这种写法是很 Low

这个就是上面selectById执行的结果

SELECT Id,name,pid FROM node WHERE Id=?

这种 Sql 肯定是不好的所以我们在使用 MP 的时候尽量不要去使用自带的快捷查询 我们可以去使用它里面的构造器

nodeMapper.selectOne(new QueryWrapper().eq("id",1).select("id"));

这汇总写法 我们可以通过后面的 select（） 去指定我们需要查询的字段 算是解决上面那个问题吗 但是这个就完事了吗？ 这还有一个问题

我们在开发中经常会说一个叫魔法值的东西

//这个就是魔法值 

if ("变成派大星".equals(node.getName())){

    System.out.println("魔法值");

}

之所以不要多用魔法值就是为了后期维护 我们建议使用枚举 或者建一个常量类 通过 Static final 修饰

上面那段代码是不是也有同样问题 "id"算不算魔法值呢 这种构造器产生的问题就是 不好维护

假设 我们的这Node类是高度使用的 我们到处都在写

nodeMapper.selectOne(new QueryWrapper().eq("id",1).select("id"));

刚开始没事 我们乐呵呵的 但是一旦我去修改 Id 的字段名怎么办

我修改成 test（数据库同步修改） 现在这个实体类中没有这个字段 我们再去看我们的代码

没有什么反应 没有给我提示报错 我这个时候去运行怎么办 我要一个个去找这个错误吗 这明显很费时间

这个确实是一个问题 但是也是可以解决的

Node node = nodeMapper.selectOne(new LambdaQueryWrapper().eq(Node::getId, 1).select(Node::getId));

上面这种代码就可以去解决这个问题 我们在使用的时候可以多用这个东西

一旦修改字段就会立马报错

但是 这就万事大吉了吗 NO No NO 我们要是处理稍微复杂的语句怎么办？ 比如如我们字段求和 这个 LambdaQueryWrapper 还是存在限制的

如果我们想实现这种 怎么去做呢

select SUM(price_count) from  bla_order_data LIMIT 100

首先这种写法肯定是不太行的 编译不通过

除非去使用QueryWrapper

还有就是分页查询

// 条件查询

LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();

queryWrapper.eq(UserInfo::getAge, 20);

// 分页对象

Page queryPage = new Page<>(page, limit);

// 分页查询

IPage iPage = userInfoMapper.selectPage(queryPage , queryWrapper);

// 数据总数

Long total = iPage.getTotal();

// 集合数据

List list = iPage.getRecords();

这个还是非常简单的

简单总结

MP 在做一些简单的单表查询可以去使用但是对于一些复杂的 SQl 操作还是不要用

1、SQL 侵入 Service 的问题我们可以仿照 Mybatis 建一个专门存放 MP 查询的包

2、关于维护性 我们可以尽量去使用 LambdaQueryWrapper 去构造

3、MP 是有内置的主键生成策略

4、内置分页插件：基于 Mybatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询。

缺点

我就说一个最大的缺点就是对于复杂 Sql 的操作性很不舒服 比如我们去多表查询 你怎么去写呢

看一个例子

就是通过

@Select 注解

 

 将Mp的查询条件嵌入进去

 ${ew.customSqlSegment}

咱就是一整个大问号 联表老老实实去写 XML 吧 这种真的不要去用 太丑了

总结

没有过多的东西 基本都是最近看到的东西

1、复杂语句不推荐使用 MP 能用最好也别用 可读性差 难维护 使用刚开始没感觉 后期业务扩充 真的恶心的

2、可以使用 MP 中的分页 比较舒服 逐渐生成策略也舒服

3、尽量不要去使用 MP 中自带的selectById 等全表查询的方法

4、尽量使用LambdaQueryWrapper的书写形式 至少比较好维护

5、简单重复 Sql 可以用 MP。复杂 SQL 不要用

前言

你可能调第三方接口喜欢启动application，修改，再启动，再修改，顺便还有个不喜欢写JUnitTest的习惯。

你可能有一天想要在SpringBoot启动后，立马想要干一些事情，现在没有可能是你还没遇到。

那么SpringBoot本身提供了一个小技巧，很多人估计没用过。

正文

1、效果

废话不多说，先写个service和controller展示个效果最实在。

来个简单的service

@Service

public class TestService {



   public String test() {



      System.err.println("Hello，Java Body ~");

      return "Hello，Java Body ~";

   }

}

再来个简单的controller

@RestController

@RequestMapping("/api")

@AllArgsConstructor

public class TestController {



   private final TestService testService;



   @GetMapping("/test")

   public ResponseEntity test() {

      return ResponseEntity.ok().body(testService.test());

   }

}

接下来是不是以为要启动调接口了，No，在SpringBoot的启动类中加这么个玩意儿

@SpringBootApplication

public class JavaAboutApplication {



    public static void main(String[] args) {

        SpringApplication.run(JavaAboutApplication.class, args);

    }



   @Bean

   CommandLineRunner lookupTestService(TestService testService) {

      return args -> {



         // 1、test接口

         testService.test();



      };

   }



}

启动看下效果

可以发现，SpringBoot启动后，自动加载了service的执行程序。

这个小案例是想说明什么呢，其实就是CommandLineRunner这么个东西。

2、它是什么

CommandLineRunner是一个接口，用于在Spring Boot应用程序启动后执行一些特定的任务或代码块。当应用程序启动完成后，Spring Boot会查找并执行实现了CommandLineRunner接口的Bean。

说白了，就是SpringBoot启动后，我立马想干的事，都可以往里写。

3、我用它做过什么

我的话，和很多厂家对接过接口，在前期不会直接开始写业务，而是先调通接口，再接入业务中。

比如webservice这种，我曾经使用CommandLineRunner直接调对方接口来测试，还挺舒适，也节省了IDEA资源，但要注意调试完成后注释掉，本地测试的时候再打开就行。

4、它还有哪些用途

除了可以拿来调试第三方接口，它还有什么用途吗？

其实开头已经说过，它就是SpringBoot启动后，你立马想干的事，都可以在里面写，所以你完全可以发挥想象去用。

我这里，提供几个思路作为参考。

1）、数据库初始化

你可以使用CommandLineRunner来执行应用程序启动时的数据库初始化操作，例如创建表格、插入初始数据等。

2）、缓存预热

CommandLineRunner在应用程序启动后预热缓存，加载常用的数据到缓存中，提高应用程序的响应速度。

3）、加载外部资源

加载一些外部资源，例如配置文件、静态文件或其他资源。CommandLineRunner可以帮助你在启动时读取这些资源并进行相应的处理。

4）、任务初始化

使用CommandLineRunner来初始化和配置某些定时任务，确保它们在应用程序启动后立即开始运行。

5）、日志记录

SpringBoot启动后记录一些必要的日志信息，如应用程序版本、环境配置、甚至启动时间等等，这个看具体需求。

6）、组件初始化

你可能需要按照特定的顺序初始化一些组件，CommandLineRunner可以帮助你控制初始化顺序，只需要将它们添加到不同的CommandLineRunner实现类中，并使用@Order注解指定它们的执行顺序即可。

总结

其实，能用的地方挺多，我最后再举个例子，netty启动时，往往是绑定了端口并以同步形式启动。

但如果要和SpringBoot整合，我们不可能还那么做，而是交给SpringBoot来控制netty的启动和关闭，当SpringBoot启动后，netty启动，当SpringBoot关闭时，netty自然也关闭了，这样才比较优雅。

那么，我们完全可以将netty的启动执行程序放到CommandLineRunner中，这样就可以达到目的了。

没用过的xdm，今天学会一个新知识点了不，可以自己下去试试哦。

我们在开发过程中经常需要接收前端传来的文件，通常需要处理MultipartFile格式的文件。今天来介绍一下MultipartFile和File怎么进行优雅的互转。

前言

首先来区别一下MultipartFile和File:

• MultipartFile是 Spring 框架的一部分，File是 Java 标准库的一部分。


• MultipartFile主要用于接收上传的文件，File主要用于操作系统文件。

MultipartFile转换为File

使用 transferTo

这是一种最简单的方法，使用MultipartFile自带的transferTo 方法将MultipartFile转换为File，这里通过上传表单文件，将MultipartFile转换为File格式，然后输出到特定的路径，具体写法如下。

使用 FileOutputStream

这是最常用的一种方法，使用 FileOutputStream 可以将字节写入文件。具体写法如下。

使用 Java NIO

Java NIO 提供了文件复制的方法。具体写法如下。

File装换为MultipartFile

从File转换为MultipartFile 通常在测试或模拟场景中使用，生产环境一般不这么用，这里只介绍一种最常用的方法。

使用 MockMultipartFile

在转换之前先确保引入了spring-test 依赖（以Maven举例）

<dependency>

    <groupId>org.springframeworkgroupId>

    <artifactId>spring-testartifactId>

    <version>versionversion>

    <scope>testscope>

dependency>

通过获得File文件的名称、mime类型以及内容将其转换为MultipartFile格式。具体写法如下。

相信很多人选择当程序员除了这个行业起步阶段薪资比其他行业高一些之外，还有一个很大的因素是觉得做研发类的工作只要代码写的好，跟电脑这个“直男”打交道就可以了。

但是还没走出校门呢，毕业这一关就得边做毕业设计边写毕业论文。写毕业论文可不是直接把自己的实现代码从IDE粘贴到Word里，但凡代码多一点就会被老师要求修改，老师会告诉你要把你做的毕业设计的功能、设计思路、关键部分的实现细节用绘图结合文字表达清楚。

这时很多同学就犯难了，匆匆拿出大三的教材《软件程序设计》看看上面的那些的图都怎么画的，再找找网上的例子，模仿着能画出个类似下面的流程图。

上面这个图乍一看还可以，但是网上关于流程图的语法好几个版本，每个人画出来都不一样，而且用这种形式表达大一些的流程，就完全感觉眼花缭乱。

画图的底层逻辑是沟通

其实走到工作岗位上之后我们仍然面临着这样的问题，除了专心写代码外，我们的工作构成中还有大量的需求评审、需求分析、技术评审、系统方案设计这样的需要人和人进行沟通的环节，讲逻辑、讲实现方案、讲设计思路的沟通环节。究其原因就是因为IT行业分工明细，它像其他行业的工作流水线一样涉及大量工种的合作，但又因为交付的软件并不像工业流水线一样是标准件，所以上面列举的每个环节都需要良好的沟通，让各职能人员之间建立共识、建立统一语言后才能完成高效协作交付产品。

既然需要良好的沟通建立统一语言，那么我们在需求分析、技术评审、系统方案设计文档上就不能使用太主观的语言，也不能把实现代码直接往文档上粘，那样的话且不说有的岗位不写代码，即使同岗位的其他同事也没有那个精力一行一行的仔细看完你的代码、理解你的思路。

所以这就需要我们能够简洁、高效地用人们都能看懂的专业图形描述出软件开发这些环节中需要重点沟通的需求逻辑和技术的关键细节。

我们都知道从事理工专业的人，可能对构图、色彩这些不太擅长，那么有没有一种图形不需要美术基础就能掌握，足够专业让图形能突出我们想表达的技术细节，同时还足够简洁即使是不太懂技术的人也能完全看懂呢？在IT领域还真有，那就是UML。

比如同样是表达需求的业务流程，用流程图表达的就是上面图-1的那个样子，但是用表达力更强，更注重语法的UML活动图表达流程的话就是下面这个样子。

关于怎么用活动图分析表达流程，后面会有专门的章节去给大家讲解。

程序员画图难的成因

说到UML，无论是大学里还是市面上讲解UML的书籍中对UML的讲解都太过枯燥了，它们通常都是以技术和软件设计的角度来讲述UML的，通常上来会先讲解一大堆图，哪些是结构建模，哪些是行为建模，紧接着就是各种图的一堆语法（画法），或者是给出的示例太过于技术化，完全脱离日常生活让人无法理解。

这就给我们这样一开始不太懂的人一种UML太过专业太过复杂，不好用的印象。想的那么清楚画出图来，代码早写好了。典型的例子就是如果画类图把类的各个属性和方法都想好画出来也太费时间了，况且需求多变还要经常改，还有就是那些类图表示的类的关系一会儿是箭头、一会儿是虚线、不明白他们都什么区别，看多了就头疼。

其实上面这个现象完全就是误区，UML完全不是必须那么复杂--把所有细节都表示出来才算完事，我们完全可以从需求分析阶段开始就开始使用，在分析的过程中构思业务的结构并画出来它大概的样貌。

后面随着对需求的进一步了解再去补全或者调整其中的内容。写技术文档常用的UML图除了能像上面这样使用类图分析业务的结构，还有活动图、顺序图、状态机图从不同角度分析业务的行为，而且是循序渐进的使用，不是上来把这些都用上。

早期对业务知晓不够透彻时UML图可以画的粗略些，流程分析也只先分析明白大流程即可，随着使用UML分析业务的过程对业务逐渐了解后再逐渐细化以及使用不同的图形从不同角度描述业务。 UML家族里提供的各种图，也不局限于只能用于技术分析，甚至需求用例、系统架构、IT架构方面的需求也能够使用UML进行描述。

掌握UML让自己有更多可能

无论是一线研发，还是已经转型项目经理、产品经理或者团队管理的人员或者是想要上车入行的萌新程序员，本课程都能让你收益颇多，让你掌握产品经理写需求的一些基本技能，也让你轻松应对项目经理参与竞标和项目管理时的文案编写工作。

同时还能让你管理项目质量时找到“抓手”，通过在项目团队建立技术评审、方案设计等相关机制--融合团队成员对UML的使用，让团队成员的思维性创造更容易被周知也让这些内容更容易被Review，从而达到项目开发期间高效的沟通和良好的质量保证。

职场上的“汇报困境”

除了上面讲的这些我们工作中干活需要用到的各种图形外，在职场上班和在学校上学有一个重要的区别就是我们时不时的就要被拿出来评比、通晒、述职，这些场合都会要求我们做汇报。

针对这个程序员在职场中的普遍痛点，推荐一下我用大半年的时间沉淀，汇集了我多年职场经验的画图课，解决程序员普遍只愿意埋头写代码，不会做需求分析、不会做技术评审、不会画架构图、述职汇报做不好，等等这些需要画图和表达能力的事情的时候就犯难的问题，帮助大家摆脱代码的单一维度，从多维度提升自己，建立自信，让你在工作中更游刃有余

课程最后一部分还会扩展一些互联网开发人员在职场中应对各种汇报的策略，讲述一些写汇报PPT的主旨思路，侧重点和注意事项。同时也讲一些使用堆砖块画法（我自己总结的）给汇报PPT进行配图的思路，怎么通过这些图快速抓住听众的眼球建立共识，以及怎么使用一些配图讲解规划给上级“画饼”来获得他们的支持从而进一步获得他们后续在资源上的支持，更好地开展工作，这些技巧我们在课程最后一部分都会讲到。

相关推荐

现有有两种订阅方式

方式1微信专栏：程序员的全能画图课

方式2小报童专栏：程序员的全能画图课

为什么很多人不推荐你用JWT?

如果你经常看一些网上的带你做项目的教程，你就会发现 有很多的项目都用到了JWT。那么他到底安全吗？为什么那么多人不推荐你去使用。这个文章将会从全方面的带你了解JWT 以及他的优缺点。

什么是JWT?

这个是他的官网JSON Web Tokens - jwt.io

这个就是JWT

JWT 全称JSON Web Token

如果你还不熟悉JWT，不要惊慌！它们并不那么复杂！

你可以把JWT想象成一些JSON数据，你可以验证这些数据是来自你认识的人。

当然如何实现我们在这里不讲，有兴趣的可以去自己了解。

下面我们来说一下他的流程：

为什么说JWT很烂？

首先我们用JWT应该就是去做这些事情：

• 用户注册网站


• 用户登录网站


• 用户点击并执行操作


• 本网站使用用户信息进行创建、更新和删除 信息

这些事情对于数据库的操作经常是这些方面的

• 记录用户正在执行的操作


• 将用户的一些数据添加到数据库中


• 检查用户的权限，看看他们是否可以执行某些操作

之后我们来逐步说出他的一些缺点

大小

这个方面毋庸置疑。

比如我们需要存储一个用户ID 为xiaou

如果存储到cookie里面，我们的总大小只有5个字节。

如果我们将 ID 存储在 一个 JWT 里。他的大小就会增加大概51倍

这无疑就增大了我们的宽带负担。

冗余签名

JWT的主要卖点之一就是其加密签名。因为JWT被加密签名，接收方可以验证JWT是否有效且可信。

但是，在过去20年里几乎每一个网络框架都可以在使用普通的会话cookie时获得加密签名的好处。

事实上，大多数网络框架会自动为你加密签名（甚至加密！）你的cookie。这意味着你可以获得与使用JWT签名相同的好处，而无需使用JWT本身。

实际上，在大多数网络身份验证情况下，JWT数据都是存储在会话cookie中的，这意味着现在有两个级别的签名。一个在cookie本身上，一个在JWT上。

令牌撤销问题

由于令牌在到期之前一直有效，服务器没有简单的方法来撤销它。

以下是一些可能导致这种情况危险的用例。

注销并不能真正使你注销！

想象一下你在推特上发送推文后注销了登录。你可能会认为自己已经从服务器注销了，但事实并非如此。因为JWT是自包含的，将在到期之前一直有效。这可能是5分钟、30分钟或任何作为令牌一部分设置的持续时间。因此，如果有人在此期间获取了该令牌，他们可以继续访问直到它过期。

可能存在陈旧数据

想象一下用户是管理员，被降级为权限较低的普通用户。同样，这不会立即生效，用户将继续保持管理员身份，直到令牌过期。

JWT通常不加密

因此任何能够执行中间人攻击并嗅探JWT的人都拥有你的身份验证凭据。这变得更容易，因为中间人攻击只需要在服务器和客户端之间的连接上完成

安全问题

对于JWT是否安全。我们可以参考这个文章

JWT （JSON Web Token） （in）security - research.securitum.com

同时我们也可以看到是有专门的如何攻击JWT的教程的

高级漏洞篇之JWT攻击专题 - FreeBuf网络安全行业门户

总结

总的来说，JWT适合作为单次授权令牌，用于在两个实体之间传输声明信息。

但是，JWT不适合作为长期持久数据的存储机制，特别是用于管理用户会话。使用JWT作为会话机制可能会引入一系列严重的安全和实现上的问题，相反，对于长期持久数据的存储，更适合使用传统的会话机制，如会话cookie，以及建立在其上的成熟的实现。

但是写了这么多，我还是想说，如果你作为自己开发学习使用，不考虑安全，不考虑性能的情况下，用JWT是完全没有问题的，但是一旦用到生产环境中，我们就需要避免这些可能存在的问题。

我们有一段业务，类似一个报表，就是获取用户的订单汇总，邮费汇总，各种手续费汇总，然后拿时间噶一卡，显示在页面。

但是呢，这几个业务没啥实际关系，数据也是分开的，一个一个获取会有点慢，我开始就是这样写的，老板嫌页面太慢，让我改，可是页面反应慢，关我后端程序什么事，哥哥别打了，错了错了，我改，我改。那么最好的方案就是多线程分别获取然后汇总到一起返回。

在Java中获取异步线程的结果通常可以使用Future和Callable、CompletableFuture、FutureTask等类来实现。这些类可以用来提交任务到线程池，并在任务完成后获取结果。这就是我们想要的结果，那么这里来深入研究分析一下这三个方案。

使用Future和Callable

package com.luke.designpatterns.demo;



import java.util.concurrent.*;



public class demo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService executor = Executors.newSingleThreadExecutor();

        Future<Integer> future = executor.submit(new Callable<Integer>() {

            public Integer call() throws Exception {

                // 获取各种汇总的代码，返回结果

                return 42;

            }

        });

        // 获取异步任务的结果

        Integer result = future.get();

        System.out.println("异步任务的结果是" + result);

        executor.shutdown();

    }

}

它们的原理是通过将任务提交到线程池执行，同时返回一个Future对象，该对象可以在未来的某个时刻获取任务的执行结果。

Callable 接口本身并不直接启动线程，它只是定义了一个可以返回结果的任务。要启动一个 Callable 实例的任务，通常需要将其提交给 ExecutorService 线程池来执行。

在 ExecutorService 中，可以使用 submit(Callable<T> task) 方法提交 Callable 任务。这个方法会返回一个 Future 对象，它可以用来获取任务的执行结果。

启动 Callable 任务的原理可以概括为以下几个步骤：

总的来说，Callable 启动线程的原理是将任务提交给 ExecutorService 线程池，线程池会负责管理线程的执行，执行任务的过程是在独立的线程中进行的，从而实现了异步执行的效果。

使用CompletableFuture

import java.util.concurrent.CompletableFuture;



public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {

            // 获取各种汇总的代码，返回结果

            return 43;

        });



        // 获取异步任务的结果

        Integer result = future.get();



        System.out.println("异步任务的结果：" + result);

    }

}

CompletableFuture 是 Java 8 引入的一个类，用于实现异步编程和异步任务的组合。它的原理是基于"Completable"（可以完成的）和"Future"（未来的结果）的概念，提供了一种方便的方式来处理异步任务的执行和结果处理。

CompletableFuture 的原理可以简单概括为以下几点：

总的来说，CompletableFuture 的原理是基于回调和异步执行的机制，提供了一种方便的方式来处理异步任务的执行和结果处理，同时支持任务的组合和异常处理。

使用FutureTask

import java.util.concurrent.*;



public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        FutureTask<Integer> futureTask = new FutureTask<>(() -> {

            // 获取各种汇总的代码，返回结果

            return 44;

        });



        Thread thread = new Thread(futureTask);

        thread.start();



        // 获取异步任务的结果

        Integer result = futureTask.get();

        System.out.println("异步任务的结果：" + result);

    }

}

FutureTask 是 Java 中实现 Future 接口的一个基本实现类，同时也实现了 Runnable 接口，因此可以被用作一个可运行的任务。FutureTask 的原理是将一个可调用的任务（Callable 或 Runnable）封装成一个异步的、可取消的任务，它提供了一个机制来获取任务的执行结果。

FutureTask 的原理可以简要概括如下：

总的来说，FutureTask 的原理是将一个可调用的任务封装成一个异步的、可取消的任务，并通过 Future 接口来提供获取任务执行结果和取消任务的机制。

这些方法中，get()方法会阻塞当前线程，直到异步任务完成并返回结果。如果任务抛出异常，get()方法会将异常重新抛出。

我们平时常用的方法就是这四种，都能实现我的需求，随便找一个哐哐干上去就好啦。

随着信息安全的日益受到重视，加密敏感数据在应用程序中变得越来越重要。Jasypt（Java Simplified Encryption）作为一个简化Java应用程序中数据加密的工具，为开发者提供了一种便捷而灵活的加密解决方案。本文将深入解析Jasypt的工作原理，以及如何在Spring Boot项目中集成和使用Jasypt来保护敏感信息。

springboot-jasypt.jpg

Jasypt简介

Jasypt（Java Simplified Encryption）是一个专注于简化Java加密操作的工具。它提供了一种简单而强大的方式来处理数据的加密和解密，使开发者能够轻松地保护应用程序中的敏感信息，如数据库密码、API密钥等。

Jasypt的设计理念是简化加密操作，使其对开发者更加友好。它采用密码学强度的加密算法，支持多种加密算法，从而平衡了性能和安全性。其中，Jasypt的核心思想之一是基于密码的加密（Password Based Encryption，PBE），通过用户提供的密码生成加密密钥，然后使用该密钥对数据进行加密和解密。

该工具还引入了盐（Salt）的概念，通过添加随机生成的盐值，提高了加密的安全性，防止相同的原始数据在不同的加密过程中产生相同的结果，有效抵御彩虹表攻击。

Jasypt与Spring Boot天然契合，可以轻松集成到Spring Boot项目中，为开发者提供了更便捷的数据安全解决方案。通过Jasypt，开发者可以在不深入了解底层加密算法的情况下，轻松实现数据的安全保护，使得应用程序更加可靠和安全。

官网地址： http://www.jasypt.org/

github地址： github.com/ulisesbocch…

Spring Boot 3 集成 Jasypt

添加依赖

在pom文件中添加一下依赖

<dependency>

  <groupId>com.github.ulisesbocchio</groupId>

  <artifactId>jasypt-spring-boot</artifactId>

  <version>3.0.5</version>

</dependency>

添加配置文件

未指定前后缀的话默认格式ENC()括号里面是加密后的密文 然后实现自动解密

spring:

  # 数据源配置

  datasource:

    type: com.alibaba.druid.pool.DruidDataSource

    driver-class-name: com.mysql.cj.jdbc.Driver

    url: jdbc:mysql://192.168.10.106:3306/xj_doc?characterEncoding=utf8&serverTimezone=Asia/Shanghai

    username: root

    password: ENC(BLC3UQBxshlcA9tnMyJL7w==)



# 加密配置

jasypt:

  encryptor:

    # 指定加密密钥，生产环境请放到启动参数里面

    password: 0f7b0a5d-46bc-40fd-b8ed-3181d21d644f

    # 指定解密算法，需要和加密时使用的算法一致

    algorithm: PBEWithMD5AndDES

    

    iv-generator-classname: org.jasypt.iv.NoIvGenerator



#    property:

#      # 算法识别的前后缀，默认ENC()，包含在前后缀的加密信息，会使用指定算法解密

#      prefix: ENC@[

#      suffix: ]

启动类添加注解

在启动类上添加注解@EnableEncryptableProperties注解来开启自动解密

@SpringBootApplication

@MapperScan("cn.xj.xjdoc.**.mapper")

@EnableEncryptableProperties  //开启自动解密功能

public class XjdocApplication {

 public static void main(String[] args) {

  SpringApplication.run(XjdocApplication.class, args);

 }

}

测试类

public class JasyptUtil {



    public static void main(String[] args){

        StandardPBEStringEncryptor standardPBEStringEncryptor =new StandardPBEStringEncryptor();

        /*配置文件中配置如下的算法*/

        standardPBEStringEncryptor.setAlgorithm("PBEWithMD5AndDES");

        /*配置文件中配置的password*/

        standardPBEStringEncryptor.setPassword("0f7b0a5d-46bc-40fd-b8ed-3181d21d644f");

        //加密

        String jasyptPasswordEN =standardPBEStringEncryptor.encrypt("xj2022");

        //解密

        String jasyptPasswordDE =standardPBEStringEncryptor.decrypt(jasyptPasswordEN);

        System.out.println("加密后密码："+jasyptPasswordEN);

        System.out.println("解密后密码："+jasyptPasswordDE);

    }

}

生产环境安全处理

jasypt的password值放在配置文件中在生产环境中是不安全的，我们可以将password值放到启动命令中，删除配置文件中password 的配置行，启动命令如下所示：

java -Djasypt.encryptor.password=password -jar jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar

或者

java -jar jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password

总结

Jasypt作为一个简单而强大的加密工具，为Java应用程序提供了便捷的数据保护方案。通过与Spring Boot的集成，开发者可以在应用程序中轻松地加密和解密敏感信息。在实际项目中，选择合适的加密方式、安全存储密码以及与Spring Security等安全框架的集成，都是保障应用程序安全的关键步骤。希望本文能够帮助读者更深入地了解Jasypt，并在实际项目中合理地运用加密技术。

Springboot3 + SpringSecurity + JWT + OpenApi3 实现双token

目前全网最新的 Spring Security + JWT 实现双 Token 的案例！收藏就对了，欢迎各位看友学习参考。此项目由作者个人创作，可以供大家学习和项目实战使用，创作不易，转载请注明出处！

该项目使用目前最新的 Sprin Boot3 版本，采用目前市面上最主流的 JWT 认证方式，实现双token刷新。

温馨提示：SpringBoot3 版本必须要使用 JDK11 或 JDK19

SpringBoot3 新特性

Spring Boot3 是一个非常重要的版本，将会面临一个新的发展征程！Sprin Boot 3.0 包含了 12 个月以来，151 个人的 5700+ 次 commit 的贡献。这是自 4 年半前发布的 2.0 版本以来的第一次重大修订，这也是第一个支持 Spring Framework 6.0 和 GraaIVM 的 Spring Boot GA 版本。

Spring Boot 3.0 新版本的主要亮点：

为什么采用双 Token刷新？

**场景假设：**星期四小金上班的时候摸鱼，准备在某APP 上面追剧，已经深深的陷入了角色中无法自拔，此时如果 Token 过期了 ，小金就不得不重新返回登录界面，重新进行登录，那么这样小金的一次完整的追剧体验就被打断了，这种设计带给小金的体验并不好，于是就需要使用双 Token 来解决。

**如何使用：**在小金首次登陆 APP 时，APP 会返回两个 Token 给小金，一个 accessToken，一个 refreshToken，其中 accessToken 的过期时间比较短，refreshToken 的时间比较长。当 accessToken 失效后，会通过 refreshToken 去重新获取 accessToken，这样一来就可以在不被察觉的情况下仍然使小金保持登录状态，让小金误以为自己一直是登录的状态。并且每次使用refreshToken 后会刷新，每一次刷新后的 refreshToken 都是不相同的。

**优势说明：**小金能够有一次完整的追剧体验，除非摸鱼时被老板发现了。accessToken 的存在，保证了登录的正常验证，因为 accessToken 的过期时间比较短，所以也可以保证账号的安全性。refreshToken 的存在，保证了小金无需在短时间内反复的登录来保持 Token 的有效性，同时也保证了活跃用户的登录状态可以一直延续而不需要重新登录，反复刷新也防止了某些不怀好意的人获取 refreshToken 后对用户账号进行不良操作。

一图胜千言:

项目准备

项目采用 Spring Boot 3 + Spring Security + JWT + MyBatis-Plus + Lombok 进行搭建。

创建数据库

user 表

token 表

在实际中应该把 token 信息保存到 redis

创建 Spring Boot 项目

创建一个 Spring Boot 3 项目，一定要选择 Java 17 或者 Java 19

引入依赖

<dependency>

    <groupId>org.springframework.bootgroupId>

    <artifactId>spring-boot-starter-securityartifactId>

    <version>3.0.4version>

dependency>



<dependency>

    <groupId>io.jsonwebtokengroupId>

    <artifactId>jjwt-apiartifactId>

    <version>0.11.5version>

dependency>

<dependency>

    <groupId>io.jsonwebtokengroupId>

    <artifactId>jjwt-implartifactId>

    <version>0.11.5version>

dependency>

<dependency>

    <groupId>io.jsonwebtokengroupId>

    <artifactId>jjwt-jacksonartifactId>

    <version>0.11.5version>

dependency>

编写配置文件

server:

    port: 8417

spring:

    application:

      name: Spring Boot 3 + Spring Security + JWT + OpenAPI3

    datasource:

        url: jdbc:mysql://localhost:3306/w_admin

        username: root

        password: jcjl417

mybatis-plus:

    configuration:

      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

    global-config:

        db-config:

            table-prefix: t_

            id-type: auto

    type-aliases-package: com.record.security.entity

    mapper-locations: classpath:mapper/*.xml

application:

    security:

        jwt:

            secret-key: VUhJT0pJT0hVWUlHRFVGVFdPSVJISVVHWUZHVkRVR0RISVVIREJZI1VJSEZTVUdZR0ZTVVk=

            expiration: 86400000 # 1天

            refresh-token:

                expiration: 604800000 # 7 天

springdoc:

    swagger-ui:

        path: /docs.html

        tags-sorter: alpha

        operations-sorter: alpha

    api-docs:

        path: /v3/api-docs

项目实现

准备项目所需要的一系列代码，如 entity、controller 、service、mapper 等

系统角色 Role

定义一个角色（Role）枚举，详细代码参考文章结尾处的项目源码

public enum Role {



  // 用户

  USER(Collections.emptySet()),

  // 一线人员

  CHASER( ... ),

  // 部门主管

  SUPERVISOR( ... ),

  // 系统管理员

  ADMIN( ... ),

  ;



  @Getter

  private final Set permissions;



  public List getAuthorities() {

    var authorities = getPermissions()

            .stream()

            .map(permission -> new SimpleGrantedAuthority(permission.getPermission()))

            .collect(Collectors.toList());

    authorities.add(new SimpleGrantedAuthority("ROLE_" + this.name()));

    return authorities;

  }

}

User 实现 UserDetails

温馨提示：

由于 Spring Security 源码设计的时候 ，将用户名和密码属性定义为 username 和 password，所以我们看到的大部分教程都会遵循源码中的方式，习惯性的将用户名定义为 username，密码定义为 password。

其实我们大可不必遵守这个规则，在我的系统中使用邮箱登录，也即是将邮箱（email）作为 Security 中的用户名（username），那么我必须要将用户输入的 email 作为 username 来存放，这会使我感到非常的不适，因为我的系统中正真的 username 将会 用另外一个单词来命名。

如何避免登录时的字段必须设置为 username 和 password 呢？

重写 getter方法， 只有你的系统中登录的用户名和密码属性不是 username 和 password 的情况下 ，你进行重写才会看到下面红色框中的提示。

重写 username 和 password 的 getter方法

@Override

public String getUsername() {

    return email;

}



@Override

public String getPassword() {

    return password;

}

Security 配置文件

需要注意的是 WebSecurityConfigurerAdapter 在 Spring Security 中已经被弃用和移除了

下面将采用新的配置文件

@Configuration

@EnableWebSecurity

@RequiredArgsConstructor

@EnableMethodSecurity

public class SecurityConfiguration {



  private final JwtAuthenticationFilter jwtAuthFilter;

  private final AuthenticationProvider authenticationProvider;

  private final LogoutHandler logoutHandler;

  private final RestAuthorizationEntryPoint restAuthorizationEntryPoint;

  private final RestfulAccessDeniedHandler restfulAccessDeniedHandler;



  @Bean

  public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

    http.csrf()

            .disable()

            .authorizeHttpRequests()

            .requestMatchers(

                "/api/v1/auth/**",

                "/api/v1/test/**",

                "/v2/api-docs",

                "/v3/api-docs",

                "/v3/api-docs/**",

                "/swagger-resources",

                "/swagger-resources/**",

                "/configuration/ui",

                "/configuration/security",

                "/swagger-ui/**",

                "/doc.html",

                "/webjars/**",

                "/swagger-ui.html",

                "/favicon.ico"

            ).permitAll()

            .requestMatchers("/api/v1/supervisor/**").hasAnyRole(SUPERVISOR.name(), ADMIN.name())



            .requestMatchers(GET, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_READ.name(), ADMIN_READ.name())

            .requestMatchers(POST, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_CREATE.name(), ADMIN_CREATE.name())

            .requestMatchers(PUT, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_UPDATE.name(), ADMIN_UPDATE.name())

            .requestMatchers(DELETE, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_DELETE.name(), ADMIN_DELETE.name())



            .requestMatchers("/api/v1/chaser/**").hasRole(CHASER.name())



            .requestMatchers(GET, "/api/v1/chaser/**").hasAuthority(CHASER_READ.name())

            .requestMatchers(POST, "/api/v1/chaser/**").hasAuthority(CHASER_CREATE.name())

            .requestMatchers(PUT, "/api/v1/chaser/**").hasAuthority(CHASER_UPDATE.name())

            .requestMatchers(DELETE, "/api/v1/chaser/**").hasAuthority(CHASER_DELETE.name())



            .anyRequest()

            .authenticated()

            .and()

            .sessionManagement()

            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

            .and()

            .authenticationProvider(authenticationProvider)

            //添加jwt 登录授权过滤器

            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)

            .logout()

            .logoutUrl("/api/v1/auth/logout")

            .addLogoutHandler(logoutHandler)

            .logoutSuccessHandler((request, response, authentication) -> SecurityContextHolder.clearContext())



    ;

    //添加自定义未授权和未登录结果返回

    http.exceptionHandling()

            .accessDeniedHandler(restfulAccessDeniedHandler)

            .authenticationEntryPoint(restAuthorizationEntryPoint);



    return http.build();

  }

}

OpenApi 配置文件

OpenApi 依赖

<dependency>

    <groupId>org.springdocgroupId>

    <artifactId>springdoc-openapi-starter-webmvc-uiartifactId>

    <version>2.1.0version>

dependency>

OpenApiConfig 配置

OpenApi3 生成接口文档，主要配置如下

• Api Gr0up（分组）


• Bearer Authorization（认证）


• Customer（自定义请求头等）

@Configuration

public class OpenApiConfig {



    @Bean

    public OpenAPI customOpenAPI(){

        return new OpenAPI()

                .info(info())

                .externalDocs(externalDocs())

                .components(components())

                .addSecurityItem(securityRequirement())

                ;

    }



    private Info info(){

        return new Info()

                .title("京茶吉鹿的 Demo")

                .version("v0.0.1")

                .description("Spring Boot 3 + Spring Security + JWT + OpenAPI3")

                .license(new License()

                        .name("Apache 2.0") // The Apache License, Version 2.0

                        .url("https://www.apache.org/licenses/LICENSE-2.0.html"))

                .contact(new Contact()

                        .name("京茶吉鹿")

                        .url("http://localost:8417")

                        .email("jc.top@qq.com"))

                .termsOfService("http://localhost:8417")

                ;

    }



    private ExternalDocumentation externalDocs() {

        return new ExternalDocumentation()

                .description("京茶吉鹿的开放文档")

                .url("http://localhost:8417/docs");

    }



    private Components components(){

        return new Components()

                .addSecuritySchemes("Bearer Authorization",

                        new SecurityScheme()

                                .name("Bearer 认证")

                                .type(SecurityScheme.Type.HTTP)

                                .scheme("bearer")

                                .bearerFormat("JWT")

                                .in(SecurityScheme.In.HEADER)

                )

                .addSecuritySchemes("Basic Authorization",

                        new SecurityScheme()

                                .name("Basic 认证")

                                .type(SecurityScheme.Type.HTTP)

                                .scheme("basic")

                )

                ;



    }



    private SecurityRequirement securityRequirement() {

        return new SecurityRequirement()

                .addList("Bearer Authorization");

    }



    private List security(Components components) {

        return components.getSecuritySchemes()

                .keySet()

                .stream()

                .map(k -> new SecurityRequirement().addList(k))

                .collect(Collectors.toList());

    }





    /**

     * 通用接口

     * @return

     */

    @Bean

    public Gr0upedOpenApi publicApi(){

        return Gr0upedOpenApi.builder()

                .group("身份认证")

                .pathsToMatch("/api/v1/auth/**")

                // 为指定组设置请求头

                // .addOperationCustomizer(operationCustomizer())

                .build();

    }

    

    /**

     * 一线人员

     * @return

     */

    @Bean

    public Gr0upedOpenApi chaserApi(){

        return Gr0upedOpenApi.builder()

                .group("一线人员")

                .pathsToMatch("/api/v1/chaser/**",

                        "/api/v1/experience/search/**",

                        "/api/v1/log/**",

                        "/api/v1/contact/**",

                        "/api/v1/admin/user/update")

                .pathsToExclude("/api/v1/experience/search/id")

                .build();

    }



    /**

     * 部门主管

     * @return

     */

    @Bean

    public Gr0upedOpenApi supervisorApi(){

        return Gr0upedOpenApi.builder()

                .group("部门主管")

                .pathsToMatch("/api/v1/supervisor/**",

                        "/api/v1/experience/**",

                        "/api/v1/schedule/**",

                        "/api/v1/contact/**",

                        "/api/v1/admin/user/update")

                .build();

    }



    /**

     * 系统管理员

     * @return

     */

    @Bean

    public Gr0upedOpenApi adminApi(){

        return Gr0upedOpenApi.builder()

                .group("系统管理员")

                .pathsToMatch("/api/v1/admin/**")

                // .addOpenApiCustomiser(openApi -> openApi.info(new Info().title("京茶吉鹿接口—Admin")))

                .build();

    }

}

Security 接口赋权的方式

hasRole及hasAuthority的区别?

hasAuthority能通过的身份必须与字符串一模一样，而hasRole能通过的身前缀必须带有ROLE_，同时可以通过两种字符串，一是带有前缀ROLE_，二是不带前缀ROLE_。

通过配置文件

在配置文件中指明访问路径的权限

.requestMatchers("/api/v1/supervisor/**").hasAnyRole(SUPERVISOR.name(), ADMIN.name())

.requestMatchers(GET, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_READ.name(), ADMIN_READ.name())

.requestMatchers(POST, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_CREATE.name(), ADMIN_CREATE.name())

.requestMatchers(PUT, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_UPDATE.name(), ADMIN_UPDATE.name())

.requestMatchers(DELETE, "/api/v1/supervisor/**").hasAnyAuthority(SUPERVISOR_DELETE.name(), ADMIN_DELETE.name())

.requestMatchers("/api/v1/chaser/**").hasRole(CHASER.name())

.requestMatchers(GET, "/api/v1/chaser/**").hasAuthority(CHASER_READ.name())

.requestMatchers(POST, "/api/v1/chaser/**").hasAuthority(CHASER_CREATE.name())

.requestMatchers(PUT, "/api/v1/chaser/**").hasAuthority(CHASER_UPDATE.name())

.requestMatchers(DELETE, "/api/v1/chaser/**").hasAuthority(CHASER_DELETE.name())

通过注解

@RestController

@RequestMapping("/api/v1/admin")

@PreAuthorize("hasRole('ADMIN')")

@Tag(name = "系统管理员权限测试")

public class AdminController {



    @GetMapping

    @PreAuthorize("hasAuthority('admin:read')")

    public String get() {

        return "GET |==| AdminController";

    }





    @PostMapping

    @PreAuthorize("hasAuthority('admin:create')")

    public String post() {

        return "POST |==| AdminController";

    }

}

测试

我们登录认证成功后，系统会为我们返回 access_token 和 refresh_token。

前言

对于后端开发同学来说，访问数据库，是代码中必不可少的一个环节。

系统中收集到用户的核心数据，为了安全性，我们一般会存储到数据库，比如：mysql，oracle等。

后端开发的日常工作，需要不断的建库和建表，来满足业务需求。

通常情况下，建库的频率比建表要低很多，所以，我们这篇文章主要讨论建表相关的内容。

如果我们在建表的时候不注意细节，等后面系统上线之后，表的维护成本变得非常高，而且很容易踩坑。

今天就跟大家一起聊聊，数据库建表的18个小技巧。

文章中介绍的很多细节，我在工作中踩过坑，并且实践过的，非常有借鉴意义，希望对你会有所帮助。

1.名字

建表的时候，给表、字段和索引起个好名字，真的太重要了。

1.1 见名知意

名字就像表、字段和索引的一张脸，可以给人留下第一印象。

好的名字，言简意赅，见名知意，让人心情愉悦，能够提高沟通和维护成本。

坏的名字，模拟两可，不知所云。而且显得杂乱无章，看得让人抓狂。

反例：

用户名称字段定义成：yong_hu_ming、用户_name、name、user_name_123456789

你看了可能会一脸懵逼，这是什么骚操作？

正例：

用户名称字段定义成：user_name

温馨提醒一下，名字也不宜过长，尽量控制在30个字符以内。

1.2 大小写

名字尽量都用小写字母，因为从视觉上，小写字母更容易让人读懂。

反例：

字段名：PRODUCT_NAME、PRODUCT_name

全部大写，看起来有点不太直观。而一部分大写，一部分小写，让人看着更不爽。

正例：

字段名：product_name

名字还是使用全小写字母，看着更舒服。

1.3 分隔符

很多时候，名字为了让人好理解，有可能会包含多个单词。

那么，多个单词间的分隔符该用什么呢？

反例：

字段名：productname、productName、product name、product@name

单词间没有分隔，或者单词间用驼峰标识，或者单词间用空格分隔，或者单词间用@分隔，这几种方式都不太建议。

正例：

字段名：product_name

强烈建议大家在单词间用_分隔。

1.4 表名

对于表名，在言简意赅，见名知意的基础之上，建议带上业务前缀。

如果是订单相关的业务表，可以在表名前面加个前缀：order_。

例如：order_pay、order_pay_detail等。

如果是商品相关的业务表，可以在表名前面加个前缀：product_。

例如：product_spu，product_sku等。

这样做的好处是为了方便归类，把相同业务的表，可以非常快速的聚集到一起。

另外，还有有个好处是，如果哪天有非订单的业务，比如：金融业务，也需要建一个名字叫做pay的表，可以取名：finance_pay，就能非常轻松的区分。

这样就不会出现同名表的情况。

1.5 字段名称

字段名称是开发人员发挥空间最大，但也最容易发生混乱的地方。

比如有些表，使用flag表示状态，另外的表用status表示状态。

可以统一一下，使用status表示状态。

如果一个表使用了另一个表的主键，可以在另一张表的名后面，加_id或_sys_no，例如：

在product_sku表中有个字段，是product_spu表的主键，这时候可以取名：product_spu_id或product_spu_sys_no。

还有创建时间，可以统一成：create_time，修改时间统一成：update_time。

删除状态固定为：delete_status。

其实还有很多公共字段，在不同的表之间，可以使用全局统一的命名规则，定义成相同的名称，以便于大家好理解。

1.6 索引名

在数据库中，索引有很多种，包括：主键、普通索引、唯一索引、联合索引等。

每张表的主键只有一个，一般使用：id或者sys_no命名。

普通索引和联合索引，其实是一类。在建立该类索引时，可以加ix_前缀，比如：ix_product_status。

唯一索引，可以加ux_前缀，比如：ux_product_code。

2.字段类型

在设计表时，我们在选择字段类型时，可发挥空间很大。

时间格式的数据有：date、datetime和timestamp等等可以选择。

字符类型的数据有：varchar、char、text等可以选择。

数字类型的数据有：int、bigint、smallint、tinyint等可以选择。

说实话，选择很多，有时候是一件好事，也可能是一件坏事。

如何选择一个合适的字段类型，变成了我们不得不面对的问题。

如果字段类型选大了，比如：原本只有1-10之间的10个数字，结果选了bigint，它占8个字节。

其实，1-10之间的10个数字，每个数字1个字节就能保存，选择tinyint更为合适。

这样会白白浪费7个字节的空间。

如果字段类型择小了，比如：一个18位的id字段，选择了int类型，最终数据会保存失败。

所以选择一个合适的字段类型，还是非常重要的一件事情。

以下原则可以参考一下：

3.字段长度

前面我们已经定义好了字段名称，选择了合适的字段类型，接下来，需要重点关注的是字段长度了。

比如：varchar(20)，biginit(20)等。

那么问题来了，varchar代表的是字节长度，还是字符长度呢？

答：在mysql中除了varchar和char是代表字符长度之外，其余的类型都是代表字节长度。

biginit(n) 这个n表示什么意思呢？

假如我们定义的字段类型和长度是：bigint(4)，bigint实际长度是8个字节。

现在有个数据a=1，a显示4个字节，所以在不满4个字节时前面填充0（前提是该字段设置了zerofill属性），比如：0001。

当满了4个字节时，比如现在数据是a=123456，它会按照实际的长度显示，比如：123456。

但需要注意的是，有些mysql客户端即使满了4个字节，也可能只显示4个字节的内容，比如会显示成：1234。

所以bigint(4)，这里的4表示显示的长度为4个字节，实际长度还是占8个字节。

4.字段个数

我们在建表的时候，一定要对字段个数做一些限制。

我之前见过有人创建的表，有几十个，甚至上百个字段，表中保存的数据非常大，查询效率很低。

如果真有这种情况，可以将一张大表拆成多张小表，这几张表的主键相同。

建议每表的字段个数，不要超过20个。

5. 主键

在创建表时，一定要创建主键。

因为主键自带了主键索引，相比于其他索引，主键索引的查询效率最高，因为它不需要回表。

此外，主键还是天然的唯一索引，可以根据它来判重。

在单个数据库中，主键可以通过AUTO_INCREMENT，设置成自动增长的。

但在分布式数据库中，特别是做了分库分表的业务库中，主键最好由外部算法(比如：雪花算法）生成，它能够保证生成的id是全局唯一的。

除此之外，主键建议保存跟业务无关的值，减少业务耦合性，方便今后的扩展。

不过我也见过，有些一对一的表关系，比如：用户表和用户扩展表，在保存数据时是一对一的关系。

这样，用户扩展表的主键，可以直接保存用户表的主键。

6.存储引擎

在mysql8以前的版本，默认的存储引擎是myisam，而mysql8以后的版本，默认的存储引擎变成了innodb。

之前我们还在创建表时，还一直纠结要选哪种存储引擎？

myisam的索引和数据分开存储，而有利于查询，但它不支持事务和外键等功能。

而innodb虽说查询性能，稍微弱一点，但它支持事务和外键等，功能更强大一些。

以前的建议是：读多写少的表，用myisam存储引擎。而写多读多的表，用innodb。

但虽说mysql对innodb存储引擎性能的不断优化，现在myisam和innodb查询性能相差已经越来越小。

所以，建议我们在使用mysql8以后的版本时，直接使用默认的innodb存储引擎即可，无需额外修改存储引擎。

7. NOT NULL

在创建字段时，需要选择该字段是否允许为NULL。

我们在定义字段时，应该尽可能明确该字段NOT NULL。

为什么呢？

我们主要以innodb存储引擎为例，myisam存储引擎没啥好说的。

主要有以下原因：