前言

大家好，我是未央歌，一个默默无闻的移动开发搬砖者~

本文针对 Android 各种标识符做了统一收集，方便大家比对，以供选择适合大家的唯一标识符。

标识符

IMEI

• 从 Android 6.0 开始获取 IMEI 需要权限，并且从 Android 10+ 开始官方取消了获取 IMEI 的 API，无法获取到 IMEI 了

fun getIMEI(context: Context): String {

    val telephonyManager = context

        .getSystemService(TELEPHONY_SERVICE) as TelephonyManager

    return telephonyManager.deviceId

}

Android ID（SSAID）

• 无需任何权限


• 卸载安装不会改变，除非刷机或重置系统


• Android 8.0 之后签名不同的 APP 获取的 Android ID 是不一样的


• 部分设备由于制造商错误实现，导致多台设备会返回相同的 Android ID


• 可能为空

fun getAndroidID(context: Context): String {

    return Settings.System.getString(context.contentResolver,Settings.Secure.ANDROID_ID)

}

MAC 地址

• 需要申请权限，Android 12 之后 BluetoothAdapter.getDefaultAdapter().getAddress()需要动态申请 android.permission.BLUETOOTH_CONNECT 权限


• MAC 地址具有全局唯一性，无法由用户重置，在恢复出厂设置后也不会变化


• 搭载 Android 10+ 的设备会报告不是设备所有者应用的所有应用的随机化 MAC 地址


• 在 Android 6.0 到 Android 9 中，本地设备 MAC 地址（如 WLAN 和蓝牙）无法通过第三方 API 使用 ， 会返回 02:00:00:00:00:00，且需要 ACCESS_FINE_LOCATION 或 ACCESS_COARSE_LOCATION 权限

Widevine ID

• DRM 数字版权管理 ID ，访问此 ID 无需任何权限


• 对于搭载 Android 8.0 的设备，Widevine 客户端 ID 将为每个应用软件包名称和网络源（对于网络浏览器）返回一个不同的值


• 可能为空

fun getWidevineID(): String {

    try {

        val WIDEVINE_UUID = UUID(-0x121074568629b532L, -0x5c37d8232ae2de13L)

        val mediaDrm = MediaDrm(WIDEVINE_UUID)

        val widevineId = mediaDrm.getPropertyByteArray(MediaDrm.PROPERTY_DEVICE_UNIQUE_ID);

        val sb = StringBuilder();

        for (byte in widevineId) {

            sb.append(String.format("x", byte))

        }

        return sb.toString();

    } catch (e: Exception) {

    } catch (e: Error) {

    }

    return ""

}

AAID

• 无需任何权限


• Google 推出的广告 ID ，可由用户重置的标识符，适用于广告用例


• 系统需要自带 Google Play Services 才支持，且用户可以在系统设置中重置

重置后，在未获得用户明确许可的情况下，新的广告标识符不得与先前的广告标识符或由先前的广告标识符所衍生的数据相关联。

还要注意，Google Play 开发者内容政策要求广告 ID“不得与个人身份信息或任何永久性设备标识符（例如：SSAID、MAC 地址、IMEI 等）相关联。”

在支持多个用户（包括访客用户在内）的 Android 设备上，您的应用可能会在同一设备上获得不同的广告 ID。这些不同的 ID 对应于登录该设备的不同用户。

OAID

• 无需任何权限


• 国内移动安全联盟出台的“拯救”国内移动广告的广告跟踪标识符


• 基本上是国内知名厂商 Android 10+ 才支持，且用户可以在系统设置中重置

UUID

• 生成之后本地持久化保存


• 卸载后重新安装、清除应用缓存 会改变

如何选择

同个开发商需要追踪对比旗下应用各用户的行为

• 可以采用 Android ID（SSAID），并且不同应用需使用同一签名


• 如果获得的 Android ID（SSAID）为空，可以用 UUID 代替【 OAID / AAID 代替也可，但需要引入第三方库】


• 在 Android 8.0+ 中， Android ID（SSAID）提供了一个在由同一开发者签名密钥签名的应用之间通用的标识符

希望限制应用内的免费内容（如文章）

• 可以采用 UUID ，作用域是应用范围，用户要想规避内容限制就必须重新安装应用

用户群体主要是大陆

• 可以采用 OAID ，低版本配合采用 Android ID（SSAID）/ UUID


• 可以采用 Android ID（SSAID），空的时候配合采用 UUID 等

用户群体在海外

• 可以采用 AAID


• 可以采用 Android ID（SSAID），空的时候配合采用 UUID 等

7个Js async/await高级用法

JavaScript的异步编程已经从回调(Callback)演进到Promise，再到如今广泛使用的async/await语法。后者不仅让异步代码更加简洁，而且更贴近同步代码的逻辑与结构，大大增强了代码的可读性与可维护性。在掌握了基础用法之后，下面将介绍一些高级用法，以便充分利用async/await实现更复杂的异步流程控制。

1. async/await与高阶函数

当需要对数组中的元素执行异步操作时，可结合async/await与数组的高阶函数（如map、filter等）。

// 异步过滤函数

async function asyncFilter(array, predicate) {

    const results = await Promise.all(array.map(predicate));



    return array.filter((_value, index) => results[index]);

}



// 示例

async function isOddNumber(n) {

    await delay(100); // 模拟异步操作

    return n % 2 !== 0;

}



async function filterOddNumbers(numbers) {

    return asyncFilter(numbers, isOddNumber);

}



filterOddNumbers([1, 2, 3, 4, 5]).then(console.log); // 输出: [1, 3, 5]

2. 控制并发数

在处理诸如文件上传等场景时，可能需要限制同时进行的异步操作数量以避免系统资源耗尽。

async function asyncPool(poolLimit, array, iteratorFn) {

    const result = [];

    const executing = [];



    for (const item of array) {

        const p = Promise.resolve().then(() => iteratorFn(item, array));

        result.push(p);



        if (poolLimit <= array.length) {

            const e = p.then(() => executing.splice(executing.indexOf(e), 1));

            executing.push(e);

            if (executing.length >= poolLimit) {

                await Promise.race(executing);

            }

        }

    }



    return Promise.all(result);

}



// 示例

async function uploadFile(file) {

    // 文件上传逻辑

}



async function limitedFileUpload(files) {

    return asyncPool(3, files, uploadFile);

}

3. 使用async/await优化递归

递归函数是编程中的一种常用技术，async/await可以很容易地使递归函数进行异步操作。

// 异步递归函数

async function asyncRecursiveSearch(nodes) {

    for (const node of nodes) {

        await asyncProcess(node);

        if (node.children) {

            await asyncRecursiveSearch(node.children);

        }

    }

}



// 示例

async function asyncProcess(node) {

    // 对节点进行异步处理逻辑

}

4. 异步初始化类实例

在JavaScript中，类的构造器（constructor）不能是异步的。但可以通过工厂函数模式来实现类实例的异步初始化。

class Example {

    constructor(data) {

        this.data = data;

    }



    static async create() {

        const data = await fetchData(); // 异步获取数据

        return new Example(data);

    }

}



// 使用方式

Example.create().then((exampleInstance) => {

    // 使用异步初始化的类实例

});

5. 在async函数中使用await链式调用

使用await可以直观地按顺序执行链式调用中的异步操作。

class ApiClient {

    constructor() {

        this.value = null;

    }



    async firstMethod() {

        this.value = await fetch('/first-url').then(r => r.json());

        return this;

    }



    async secondMethod() {

        this.value = await fetch('/second-url').then(r => r.json());

        return this;

    }

}



// 使用方式

const client = new ApiClient();

const result = await client.firstMethod().then(c => c.secondMethod());

6. 结合async/await和事件循环

使用async/await可以更好地控制事件循环，像处理DOM事件或定时器等场合。

// 异步定时器函数

async function asyncSetTimeout(fn, ms) {

    await new Promise(resolve => setTimeout(resolve, ms));

    fn();

}



// 示例

asyncSetTimeout(() => console.log('Timeout after 2 seconds'), 2000);

7. 使用async/await简化错误处理

错误处理是异步编程中的重要部分。通过async/await，可以将错误处理的逻辑更自然地集成到同步代码中。

async function asyncOperation() {

    try {

        const result = await mightFailOperation();

        return result;

    } catch (error) {

        handleAsyncError(error);

    }

}



async function mightFailOperation() {

    // 有可能失败的异步操作

}



function handleAsyncError(error) {

    // 错误处理逻辑

}

通过以上七个async/await的高级用法，开发者可以在JavaScript中以更加声明式和直观的方式处理复杂的异步逻辑，同时保持代码整洁和可维护性。在实践中不断应用和掌握这些用法，能够有效地提升编程效率和项目的质量。

随着信息安全的日益受到重视，加密敏感数据在应用程序中变得越来越重要。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。

20个你不得不知道的Js async/await用法

JavaScript的async和await关键词是现代JavaScript异步编程的核心。它们让异步代码看起来和同步代码几乎一样，使得异步编程变得更加直观和易于管理。本文介绍20个关于async/await的实用技巧，将大大提升编程效率和代码的清晰度。

1. 基础用法

async函数返回一个Promise，而await关键词可以暂停async函数的执行，等待Promise解决。

async function fetchData() {

    let data = await fetch('url');

    data = await data.json();

    return data;

}

2. 错误处理

使用try...catch结构处理async/await中的错误。

async function fetchData() {

    try {

        let response = await fetch('url');

        response = await response.json();

        return response;

    } catch (error) {

        console.error('Fetching data error:', error);

    }

}

3. 并行执行

Promise.all()可以用来并行执行多个await操作。

async function fetchMultipleUrls(urls) {

    const promises = urls.map(url => fetch(url).then(r => r.json()));

    return await Promise.all(promises);

}

4. 条件异步

根据条件执行await。

async function fetchData(condition) {

    if (condition) {

        return await fetch('url');

    }

    return 'No fetch needed';

}

5. 循环中的await

在循环中使用await时，每次迭代都会等待。

async function sequentialStart(urls) {

    for (const url of urls) {

        const response = await fetch(url);

        console.log(await response.json());

    }

}

6. 异步迭代器

对于异步迭代器（例如Node.js中的Streams），可以使用for-await-of循环。

async function processStream(stream) {

    for await (const chunk of stream) {

        console.log(chunk);

    }

}

7. await之后立即解构

直接在await表达式后使用解构。

async function getUser() {

    const { data: user } = await fetch('user-url').then(r => r.json());

    return user;

}

8. 使用默认参数避免无效的await

如果await可能是不必要的，可以使用默认参数避免等待。

async function fetchData(url = 'default-url') {

    const response = await fetch(url);

    return response.json();

}

9. await在类的方法中

在类的方法中使用async/await。

class DataFetcher {

    async getData() {

        const data = await fetch('url').then(r => r.json());

        return data;

    }

}

10. 立刻执行的async箭头函数

可以立即执行的async箭头函数。

(async () => {

    const data = await fetch('url').then(r => r.json());

    console.log(data);

})();

11. 使用async/await进行延时

利用async/await实现延时。

function delay(ms) {

    return new Promise(resolve => setTimeout(resolve, ms));

}



async function delayedLog(item) {

    await delay(1000);

    console.log(item);

}

12. 使用async/await处理事件监听器

在事件处理函数中使用async/await。

document.getElementById('button').addEventListener('click', async (event) => {

    event.preventDefault();

    const data = await fetch('url').then(r => r.json());

    console.log(data);

});

13. 以顺序方式处理数组

使用async/await以确定的顺序处理数组。

async function processArray(array) {

    for (const item of array) {

        await delayedLog(item);

    }

    console.log('Done!');

}

14. 组合async/await与destructuring以及spread运算符

结合使用async/await，解构和展开操作符。

async function getConfig() {

    const { data, ...rest } = await fetch('config-url').then(r => r.json());

    return { config: data, ...rest };

}

15. 在对象方法中使用async/await

将async方法作为对象的属性。

const dataRetriever = {

    async fetchData() {

        return await fetch('url').then(r => r.json());

    }

};

16. 异步生成器函数

使用async生成器函数结合yield。

async function* asyncGenerator(array) {

    for (const item of array) {

        yield await processItem(item);

    }

}

17. 使用顶级await

在模块顶层使用await（需要特定的JavaScript环境支持）。

// ECMAScript 2020引入顶级await特性, 部署时注意兼容性

const config = await fetch('config-url').then(r => r.json());

18. async/await与IIFE结合

将async函数与立即执行函数表达式（IIFE）结合。

(async function() {

    const data = await fetch('url').then(r => r.json());

    console.log(data);

})();

19. 使用async/await优化递归调用

优化递归函数。

async function asyncRecursiveFunction(items) {

    if (items.length === 0) return 'done';

    const currentItem = items.shift();

    await delay(1000);

    console.log(currentItem);

    return asyncRecursiveFunction(items);

}

20. 在switch语句中使用await

在switch语句的每个case中使用await。

async function fetchDataBasedOnType(type) {

    switch (type) {

        case 'user':

            return await fetch('user-url').then(r => r.json());

        case 'post':

            return await fetch('post-url').then(r => r.json());

        default:

            throw new Error('Unknown type');

    }

}

〇、往事

起初

我11年网络技术专科毕业，直到15年春节后打算开始程序员生涯，那年我25岁。那时候我只会很浅的语言基础，C、java、C#、php 都会一些，由于没有开发经验，在苏州15天，后辗转来到上海，又是5天。当初懵懵懂懂，并没有什么理想和目标，只是知道程序员会有一份不错的收入，仅此而已，我和众多小白一样对使用什么语言难以抉择，我跑招聘会、也投简历，无论是什么公司、什么语言，只要有人要我，我就去。

我的第一份工作

辗转来到上海的第5天，我获得了第一份开发工作，这份工作的面试，现在回想起来还是觉得不可思议，一位不知道是什么职位的A让我把页面上的一个按钮调整位置、颜色？我记不清了，只记得我好像没有弄成功，已经不记得是怎么获得的工作了。我只记得入职的第二天，公司就让我去了另外一个办公地点工作，开始打杂，都算不上搬砖，因为我能力有限……

直到很久以后，我才知道，我做的工作叫外包，我算是被卖了，起初的半年都是不缴社保的，付现金，我拿6k，公司拿9k，公司净赚3k。好吧，我没有怨天尤人，因为那时候在老家我只能拿2k，而且就凭我快半年才知道自己 “被卖” 这个事实，说明我是多笨，也许我也只配做外包，补充一句，我们做的是 .NET, asp.net。又过了半年，我稍微有些入门了，似乎也聪明一点了，知道不能再混下去，于是辞职找下家……

后来听说，这个我参与的外包项目黄了……
在后来不知道多久，曾经的公司倒闭了……
几年后我还接到银行的电话，问我这个公司的一个负责人我是否有联系，或许是追债的吧，和我又有什么关系呢？

一份不错的工作

真的不推荐新人去外包公司，因为没有人引路，都是自己摸索，如果可以的话，去个有人带的公司，或大或小，或多或少都是会有帮助的。

又是一个春节后，我开始寻找我的第二份工作，老家说七不出八不归，于是我初六就出门了，和前一年一样……
没过几天，我寻找到的第二份工作，并且还是一份甲方工作，从事汽车检测行业，IT部开发的主要是自用的产品，也是一份 .NET 开发工作。这份工作给我提供了不错的工作环境、好的同事或者也算不错的老板。2年时间，我慢慢学习，逐渐进步，可能从这之后我才算是一个合格一点的程序员。年初3月，老板找全体IT部门谈话：公司需要的产品都已经齐全，现在IT部门，软件方面也只需要一些小的功能调整，愿意留在公司的就留下来但是工资不会涨，不愿意留下来的你们就去找工作，找到下家你们随时可以离开。

你们看，我是不是说的没错，算是不错的老板吧。而且这份工作包午餐，加班有加班调休呢！

这两年我是逐渐成熟的两年，除了同事间的活动、聚餐外，我偶尔会去逛逛花鸟市场，我记得很多的日子我都是学习到10点多，对着我的笔记本，我已经不记得当初学的什么，怎么学习的，应该是没有系统的学习路线，也没人指引，这是我现在回头看的，这也导致了我现在的技术面广但是颇为杂乱，我的技术能力没有重心、飘飘的……

新入行的弟弟们，选好方向很重要，现在网上很多资源的，不能盲目学习不关联的技术栈，系统性的学习很重要，最好先有计划，按照计划路线学习。

三战

第三份工作，也就是我现在的工作，18年到现在5年半多了，其实原先没有准备在这份工作上停留这么久的，恰逢19年底-23年初的疫情，23年初我手头上又有一个不太能放下的项目，所以一直拖到现在。

找工作很难擦亮自己的眼睛，招聘的同事说的天花乱坠，可能与实际不符。进入公司后才发现，缴税是按最低的来，没有奖金，没有福利，公司不推荐、不鼓励加班（所以加班没有调休、没有加班费，工作做不完是你自己的问题），公司项目技术栈陈旧，面试说“造大炮”，进公司才发现是“做鞭炮”，而且刚进公司都算是大佬级别了，可见公司人员技术凋零，我很难想象这么些同事是怎么进入公司的。

我为什么这么说，因为现在的公司，我投过一次简历，来面试过一次没有通过，后来不小心又投了一次简历，人事应该没有注意，我又来了一次，到门口发现是这家，于是打电话，接电话的人说：既然来了就再聊聊。换了一个面试的经理，也是这样，我在 “二面” 后成功入职。

那时候我自认为我的能力介于.NET初级开发和中级开发之间，然后发现这样的水平能胜过公司的9成……，是的，我一点都不谦虚，因为项目质量太差。

5年，我有多次要离开的意图，先是疫情和大环境的原因束缚着我，我妈也劝我过了疫情再说。23年初，我负责了一个比较大的项目，也是一个大的客户，我觉得在做项目上这是一个成长，虽然现在我也不知道到底有没有长长那么1cm。我却因此放弃了一份即将拿到手的外企offer，说不后悔是假的。

快35岁了，我现在税前薪资 20k，作为一个快9年的老程序员了，这着实太低了。怪我这份工作入职工资就低，怪公司这些年涨幅太少，怪疫情耽误了我的跳槽和发展，怪自己年龄大了没有太多学习成长的精力。曾经风华正茂，怀着一个在上海发展，凭借一己之力留在上海的梦想，近乎破灭了。

如果一份工作配不上你的成长脚步，不要犹豫，换掉它。（如果薪资足够动人，当我没说）

番外

这些年里：

一、迷茫

一鼓作气，再而衰，三而截吗？

从成为程序员开始，我学过很多有关无关的技能，工作中一直算是半个全栈开发，最近两年前端稳定为了 vue，后端 .net/.net core。而.NET 在我国发展不太行，恰逢2024年春节前夕，笔者准备换工作，却难求一份前端、后端或 vue+.net 全栈开发、项目经理工作。

• 前端我不专业，稍微欠缺了火候，我能行吗？


• 有人说熟悉 C# 可以转游戏开发，可是我深知道语言仅仅是游戏开发以及其他开发的基础，对游戏开发一无所知的我转游戏开发稍显有些晚了。


• 全栈开发，在上海，前端 VUE，后端 .NET 的工作屈指可数，又怎么有机会呢。


• .NET 也少到快灭绝

下面是我从某照片网站关键词职位截图：

C#/.NET的职位真的有那么少吗？再排除名企和低薪工作，这不是快绝技（绝迹，爵迹）吗？
我没法和掘金大佬们相比，名企的职位我看都不带看的，看我多潇洒，可惜内心灰暗无比，我只是有自知之明！

我学过 Node.js、Python、java 几乎没有运用到实际项目中，我现在转 java、python 好像有些迟了吧？我相信一定会有人要的，但是薪资比 20k 低了多少我说不准，而且现在我是期望涨薪，低了能过得了自己心里的门槛吗？

如果是再整整 Node.js 开源项目，直接找 VUE+Node.js 会不会更好呢？毕竟都是 js 栈的东西，没什么门槛，深入学一个 Express.js 是不是能给自己机会呢？

我没有能力，没啥人脉，找不到私活做，我也没有 Plan B，有的都是迷茫和无奈。

二、抉择

我要如何抉择？

呵呵，废物如我，活该碌碌无为，已近半生……

年龄到了，这可能也是我最后一次换工作了，或许我应该去学个 “水电工证书” 呢！

前言

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

系统中收集到用户的核心数据，为了安全性，我们一般会存储到数据库，比如：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存储引擎没啥好说的。

主要有以下原因：

因此，建议我们在定义字段时，能定义成NOT NULL，就定义成NOT NULL。

但如果某个字段直接定义成NOT NULL，万一有些地方忘了给该字段写值，就会insert不了数据。

这也算合理的情况。

但有一种情况是，系统有新功能上线，新增了字段。上线时一般会先执行sql脚本，再部署代码。

由于老代码中，不会给新字段赋值，则insert数据时，也会报错。

由此，非常有必要给NOT NULL的字段设置默认值，特别是后面新增的字段。

例如：

alter table product_sku add column  brand_id int(10) not null default 0;

8.外键

在mysql中，是存在外键的。

外键存在的主要作用是：保证数据的一致性和完整性。

例如：

create table class (

  id int(10) primary key auto_increment,

  cname varchar(15)

);

有个班级表class。

然后有个student表：

create table student(

  id int(10) primary key auto_increment,

  name varchar(15) not null,

  gender varchar(10) not null,

  cid int,

  foreign key(cid) references class(id)

);

其中student表中的cid字段，保存的class表的id，这时通过foreign key增加了一个外键。

这时，如果你直接通过student表的id删除数据，会报异常：

a foreign key constraint fails

必须要先删除class表对于的cid那条数据，再删除student表的数据才行，这样能够保证数据的一致性和完整性。

顺便说一句：只有存储引擎是innodb时，才能使用外键。

如果只有两张表的关联还好，但如果有十几张表都建了外键关联，每删除一次主表，都需要同步删除十几张子表，很显然性能会非常差。

因此，互联网系统中，一般建议不使用外键。因为这类系统更多的是为了性能考虑，宁可牺牲一点数据一致性和完整性。

除了外键之外，存储过程和触发器也不太建议使用，他们都会影响性能。

9. 索引

在建表时，除了指定主键索引之外，还需要创建一些普通索引。

例如：

create table product_sku(

  id int(10) primary key auto_increment,

  spu_id int(10) not null,

  brand_id int(10) not null,

  name varchar(15) not null

);

在创建商品表时，使用spu_id（商品组表）和brand_id（品牌表）的id。

像这类保存其他表id的情况，可以增加普通索引：

create table product_sku (

  id int(10) primary key auto_increment,

  spu_id int(10) not null,

  brand_id int(10) not null,

  name varchar(15) not null,

  KEY `ix_spu_id` (`spu_id`) USING BTREE,

  KEY `ix_brand_id` (`brand_id`) USING BTREE

);

后面查表的时候，效率更高。

但索引字段也不能建的太多，可能会影响保存数据的效率，因为索引需要额外的存储空间。

建议单表的索引个数不要超过：5个。

如果在建表时，发现索引个数超过5个了，可以删除部分普通索引，改成联合索引。

顺便说一句：在创建联合索引的时候，需要使用注意最左匹配原则，不然，建的联合索引效率可能不高。

对于数据重复率非常高的字段，比如：状态，不建议单独创建普通索引。因为即使加了索引，如果mysql发现全表扫描效率更高，可能会导致索引失效。

如果你对索引失效问题比较感兴趣，可以看看我的另一篇文章《聊聊索引失效的10种场景，太坑了》，里面有非常详细的介绍。

10.时间字段

时间字段的类型，我们可以选择的范围还是比较多的，目前mysql支持：date、datetime、timestamp、varchar等。

varchar类型可能是为了跟接口保持一致，接口中的时间类型是String。

但如果哪天我们要通过时间范围查询数据，效率会非常低，因为这种情况没法走索引。

date类型主要是为了保存日期，比如：2020-08-20，不适合保存日期和时间，比如：2020-08-20 12:12:20。

而datetime和timestamp类型更适合我们保存日期和时间。

但它们有略微区别。

• timestamp：用4个字节来保存数据，它的取值范围为1970-01-01 00:00:01 UTC ~ 2038-01-19 03:14:07。此外，它还跟时区有关。


• datetime：用8个字节来保存数据，它的取值范围为1000-01-01 00:00:00 ~ 9999-12-31 23:59:59。它跟时区无关。

优先推荐使用datetime类型保存日期和时间，可以保存的时间范围更大一些。

温馨提醒一下，在给时间字段设置默认值是，建议不要设置成：0000-00-00 00:00:00，不然查询表时可能会因为转换不了，而直接报错。

11.金额字段

mysql中有多个字段可以表示浮点数：float、double、decimal等。

而float和double可能会丢失精度，因此推荐大家使用decimal类型保存金额。

一般我们是这样定义浮点数的：decimal(m,n)。

其中n是指小数的长度，而m是指整数加小数的总长度。

假如我们定义的金额类型是这样的：decimal(10,2)，则表示整数长度是8位，并且保留2位小数。

12. json字段

我们在设计表结构时，经常会遇到某个字段保存的数据值不固定的需求。

举个例子，比如：做异步excel导出功能时，需要在异步任务表中加一个字段，保存用户通过前端页面选择的查询条件，每个用户的查询条件可能都不一样。

这种业务场景，使用传统的数据库字段，不太好实现。

这时候就可以使用MySQL的json字段类型了，可以保存json格式的结构化数据。

保存和查询数据都是非常方便的。

MySQL还支持按字段名称或者字段值，查询json中的数据。

13.唯一索引

唯一索引在我们实际工作中，使用频率相当高。

你可以给单个字段，加唯一索引，比如：组织机构code。

也可以给多个字段，加一个联合的唯一索引，比如：分类编号、单位、规格等。

单个的唯一索引还好，但如果是联合的唯一索引，字段值出现null时，则唯一性约束可能会失效。

关于唯一索引失效的问题，感兴趣的小伙伴可以看看我的另一篇文章《明明加了唯一索引，为什么还是产生重复数据？》。

创建唯一索引时，相关字段一定不能包含null值，否则唯一性会失效。

14.字符集

mysql中支持的字符集有很多，常用的有：latin1、utf-8、utf8mb4、GBK等。

这4种字符集情况如下：

latin1容易出现乱码问题，在实际项目中使用比较少。

而GBK支持中文，但不支持国际通用字符，在实际项目中使用也不多。

从目前来看，mysql的字符集使用最多的还是：utf-8和utf8mb4。

其中utf-8占用3个字节，比utf8mb4的4个字节，占用更小的存储空间。

但utf-8有个问题：即无法存储emoji表情，因为emoji表情一般需要4个字节。

由此，使用utf-8字符集，保存emoji表情时，数据库会直接报错。

所以，建议在建表时字符集设置成：utf8mb4，会省去很多不必要的麻烦。

15. 排序规则

不知道，你关注过没，在mysql中创建表时，有个COLLATE参数可以设置。

例如：

CREATE TABLE `order` (

  `id` bigint NOT NULL AUTO_INCREMENT,

  `code` varchar(20) COLLATE utf8mb4_bin NOT NULL,

  `name` varchar(30) COLLATE utf8mb4_bin NOT NULL,

  PRIMARY KEY (`id`),

  UNIQUE KEY `un_code` (`code`),

  KEY `un_code_name` (`code`,`name`) USING BTREE,

  KEY `idx_name` (`name`)

) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

它是用来设置排序规则的。

字符排序规则跟字符集有关，比如：字符集如果是utf8mb4，则字符排序规则也是以：utf8mb4_开头的，常用的有：utf8mb4_general_ci、utf8mb4_bin等。

其中utf8mb4_general_ci排序规则，对字母的大小写不敏感。说得更直白一点，就是不区分大小写。

而utf8mb4_bin排序规则，对字符大小写敏感，也就是区分大小写。

说实话，这一点还是非常重要的。

假如order表中现在有一条记录，name的值是大写的YOYO，但我们用小写的yoyo去查，例如：

select * from order where name='yoyo';

如果字符排序规则是utf8mb4_general_ci，则可以查出大写的YOYO的那条数据。

如果字符排序规则是utf8mb4_bin，则查不出来。

由此，字符排序规则一定要根据实际的业务场景选择，否则容易出现问题。

最近就业形式比较困难，为了感谢各位小伙伴对苏三一直以来的支持，我特地创建了一些工作内推群， 看看能不能帮助到大家。

你可以在群里发布招聘信息，也可以内推工作，也可以在群里投递简历找工作，也可以在群里交流面试或者工作的话题。

进群方式

添加苏三的私人微信：su_san_java，备注：掘金+所在城市，即可加入。

16.大字段

我们在创建表时，对一些特殊字段，要额外关注，比如：大字段，即占用较多存储空间的字段。

比如：用户的评论，这就属于一个大字段，但这个字段可长可短。

但一般会对评论的总长度做限制，比如：最多允许输入500个字符。

如果直接定义成text类型，可能会浪费存储空间，所以建议将这类字段定义成varchar类型的存储效率更高。

当然，我还见过更大的字段，即该字段直接保存合同数据。

一个合同可能会占几Mb。

在mysql中保存这种数据，从系统设计的角度来说，本身就不太合理。

像合同这种非常大的数据，可以保存到mongodb中，然后在mysql的业务表中，保存mongodb表的id。

17.冗余字段

我们在设计表的时候，为了性能考虑，提升查询速度，有时可以冗余一些字段。

举个例子，比如：订单表中一般会有userId字段，用来记录用户的唯一标识。

但很多订单的查询页面，或者订单的明细页面，除了需要显示订单信息之外，还需要显示用户ID和用户名称。

如果订单表和用户表的数据量不多，我们可以直接用userId，将这两张表join起来，查询出用户名称。

但如果订单表和用户表的数据量都非常多，这样join是比较消耗查询性能的。

这时候我们可以通过冗余字段的方案，来解决性能问题。

我们可以在订单表中，可以再加一个userName字段，在系统创建订单时，将userId和userName同时写值。

当然订单表中历史数据的userName是空的，可以刷一下历史数据。

这样调整之后，后面只需要查询订单表，即可查询出我们所需要的数据。

不过冗余字段的方案，有利也有弊。

对查询性能有利。

但需要额外的存储空间，还可能会有数据不一致的情况，比如用户名称修改了。

我们在实际业务场景中，需要综合评估，冗余字段方案不适用于所有业务场景。

18.注释

我们在做表设计的时候，一定要把表和相关字段的注释加好。

例如下面这样的：

CREATE TABLE `sys_dept` (

  `id` bigint NOT NULL AUTO_INCREMENT COMMENT 'ID',

  `name` varchar(30) NOT NULL COMMENT '名称',

  `pid` bigint NOT NULL COMMENT '上级部门',

  `valid_status` tinyint(1) NOT NULL DEFAULT 1 COMMENT '有效状态 1:有效 0:无效',

  `create_user_id` bigint NOT NULL COMMENT '创建人ID',

  `create_user_name` varchar(30) NOT NULL COMMENT '创建人名称',

  `create_time` datetime(3) DEFAULT NULL COMMENT '创建日期',

  `update_user_id` bigint DEFAULT NULL COMMENT '修改人ID',

  `update_user_name` varchar(30)  DEFAULT NULL COMMENT '修改人名称',

  `update_time` datetime(3) DEFAULT NULL COMMENT '修改时间',

  `is_del` tinyint(1) DEFAULT '0' COMMENT '是否删除 1：已删除 0：未删除',

  PRIMARY KEY (`id`) USING BTREE,

  KEY `index_pid` (`pid`) USING BTREE

) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='部门';

表和字段的注释，都列举的非常详细。

特别是有些状态类型的字段，比如：valid_status字段，该字段表示有效状态， 1:有效 0:无效。

让人可以一目了然，表和字段是干什么用的，字段的值可能有哪些。

最怕的情况是，你在表中创建了很多status字段，每个字段都有1、2、3、4、5、6、7、8、9等多个值。

没有写什么注释。

谁都不知道1代表什么含义，2代表什么含义，3代表什么含义。

可能刚开始你还记得。

但系统上线使用一年半载之后，可能连你自己也忘记了这些status字段，每个值的具体含义了，埋下了一个巨坑。

由此，我们在做表设计时，一定要写好相关的注释，并且经常需要更新这些注释。