项目知识点

项目知识点：

1.核心框架：Spring Boot 2.1

​ Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。传统的spring项目中需要用到大量的xml配置，以及复杂的bean依赖关系，随着spring3.0的发布spring团队开始大量使用约定大于配置的思想来简化配置。

优点：

（1）依赖简化：Spring Boot自有的starter中提供了一些可以快捷使用的依赖，让整合或集成一些常用的功能更便捷。

（2）配置简化：在配置方法中，如果没有特殊情况，Spring Boot为我们提供了一些默认的配置，比如端口号默认为8080等。

（3）部署简化：正如前面介绍的可执行JAR部署，与传统服务的Web模式部署（打WAR包部署）相比，连安装Web容器的时间都节省了，不只是开发者，对运维人员也是福音。

（4）监控简化：可以通过引用Spring Boot依赖的方式快捷提供监控端点，无代码侵入，十分便捷。

1.1springboot常用注解

@SpringBootApplication：启动
SpringBoot的核心注解，主要目的是开启自动配置。它也是一个组合注解，主要组合了@Configuration，@EnableAutoConfiguration（核心）和@ComponentScan。可以通过@SpringBootApplication(exclude={想要关闭的自动配置的类名.class})来关闭特定的自动配置，其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。

@EnableAutoConfiguration:自动配置
此注释自动载入应用程序所需的所有Bean——这依赖于Spring Boot在类路径中的查找。该注解组合了@Import注解，@Import注解导入了EnableAutoCofigurationImportSelector类，它使用SpringFactoriesLoader.loaderFactoryNames方法来扫描具有META-INF/spring.factories文件的jar包。而spring.factories里声明了有哪些自动配置.

@Configuration：配置文件
等同于spring的XML配置文件；使用Java代码可以检查类型安全。

@ComponentScan：自动扫描
表示将该类自动发现扫描组件。个人理解相当于，如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。

1.2AOP常用注解

@Aspect：切面
声明一个切面

@After：后置建言
后置建言（advice），在原方法前执行

@Before：前置建言
前置建言（advice），在原方法后执行。

@Around：环绕
环绕建言（advice），在原方法执行前执行，在原方法执行后再执行（@Around可以实现其他两种advice）。

@PointCut：切点
声明切点，即定义拦截规则，确定有哪些方法会被切入

1.3其他常用注解

@Transactional：事务声明
声明事务（一般默认配置即可满足要求，当然也可以自定义）

@Cacheable：缓存
声明数据缓存

@PropertySource：文件引入
指定文件地址。提供了一种方便的、声明性的机制，用于向Spring的环境添加PropertySource。与@configuration类一起使用。

@Async：多线程异步方法
注解在方法上标示这是一个异步方法，在类上标示这个类所有的方法都是异步方法。

@EnableAsync：多线程
开启异步任务支持。注解在配置类上。

@EnableScheduling：开启计划任务
注解在配置类上，开启对计划任务的支持。

@Scheduled：计划任务
注解在方法上，声明该方法是计划任务。支持多种类型的计划任务：cron,fixDelay,fixRate。

在项目需要周期性发送或者产生数据情况下使用@Scheduled在方法上声明定时任务吗，在启动类使用@EnableScheduling开启定时任务

不使用lombok插件：

@Getter / @Setter

可以作用在类上和属性上，放在类上，会对所有的非静态(non-static)属性生成Getter/Setter方法，放在属性上，会对该属性生成Getter/Setter方法。并可以指定Getter/Setter方法的访问级别。

@EqualsAndHashCode

默认情况下，会使用所有非瞬态(non-transient)和非静态(non-static)字段来生成equals和hascode方法，也可以指定具体使用哪些属性。

@ToString

生成toString方法，默认情况下，会输出类名、所有属性，属性会按照顺序输出，以逗号分割。

@NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor

无参构造器、部分参数构造器、全参构造器，当我们需要重载多个构造器的时候，Lombok就无能为力了。

使用lombok插件：

@Data

@ToString, @EqualsAndHashCode, 所有属性的@Getter, 所有non-final属性的@Setter和@RequiredArgsConstructor的组合，通常情况下，我们使用这个注解就足够了。

2.安全框架：Apache Shiro 1.4

Apache Shiro是Java的一个安全框架。功能强大，使用简单的Java安全框架，它为开发人员提供一个直观而全面的认证，授权，加密及会话管理的解决方案。

验证用户身份
● 用户访问控制，比如用户是否被赋予了某个角色；是否允许访问某些资源
● 在任何环境都可以使用Session API，即使不是WEB项目或没有EJB容器
● 事件响应(在身份验证，访问控制期间，或是session生命周期中)
● 集成多种用户信息数据源
● SSO-单点登陆
● Remember Me，记住我
● Shiro尝试在任何应用环境下实现这些功能，而不依赖其他框架、容器或应用服务器。

四大基石----身份验证，授权，会话管理，加密

1.Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

2.Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

3.Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；

4.Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；、

3.视图框架：Spring MVC 5.0

Spring Web MVC是基于Servlet API构建的原始Web框架

组成部分

DispatcherServlet（前端控制器）：是SpringMVC的核心部分，是一种前端控制器，由框架所提供

作用：统一处理请求和响应。除此之外也是整个控制流程的中心，由DispatcherServlet来调用其他组件，对用户的请求进行处理

HandlerMapping：处理器映射器，由框架所提供。

作用：根据请求的url、method等信息来查找具体的Handler（通俗讲——通常来说就是Controller）

Handler（通常就是Controller） ：处理器，注意——这个就是软件开发人员自己开发设计的部分

作用：在DispatcherServlet的控制下，Handler对用户的请求进行处理

HandlerAdapter ：处理器适配器，由框架所提供

作用：根据HandlerMapping所提供的Handler信息，会按照特定的规则去执行相关的处理器Handler

小结

• Handler——是用来干活的工具
• HandlerMapping——是根据需要干的活找到对应的工具
• HandlerAdapter——是具体用工具干活的那个人

ViewResolver：视图解析器——由框架提供

作用：ViewResolver负责将处理结果生成View视图。ViewResolver首先会根据逻辑视图名解析成物理图名，即具体的页面地址，再生成View视图对象，最后将View进行渲染之后将页面呈现给用户

View ：视图——软件开发人员自己设计

作用：View接口的职责就是接收model对象、Request对象、Response对象，最后渲染输出结果返回给Response对象

工作流程

1、用户将请求发送，由前端控制器DispatcherServlet来拦截并接收请求

2、前端控制器DispatcherServlet收到请求之后调用处理器映射器（HanlderMapping），去查找与请求对应的Handler

3、处理器映射器（HanlderMapping）找到具体的处理器（根据xml配置、注解等方式进行查找），返回一个处理器执行链（是一个包含处理器对象和拦截器（Interceptor）的对象【如果有拦截器的话】）

4、然后前端控制器DispatcherServlet调用了处理器适配器HandlerAdapter

5、处理器适配器会找到具体Handler的具体方法，并将获取到的参数执行完成之后将结果继续返回给DispatcherServlet（结果通常是ModelAndView）

6、然后前端控制器（DispatcherServlet）会调用视图解析器，并将ModelAndView传给它（ViewResolver）

7、视图解析器（ViewResolver）将获得的参数从逻辑视图转换为物理视图对象（View）返回给前端控制器（DispatcherServlet）

8、前端控制器（DispatcherServlet）调用物理视图进行渲染并返回。

9、前端控制器（DispatcherServlet）将渲染完毕的页面响应给用户

Spring MVC 与数据库交互的工作流程

1. 用户请求：用户在浏览器中发起 HTTP 请求。
2. DispatcherServlet 接收请求：Spring MVC 的前端控制器 DispatcherServlet 接收请求并将其分发给相应的处理器（Controller）。
3. Controller 处理请求：Controller 处理请求，调用 Service 层进行业务逻辑处理。
4. Service 调用 Repository：Service 层调用 Repository 层（通常使用 Spring Data JPA 或 JDBC）与数据库进行交互。
5. 数据库操作：Repository 层执行数据库操作（如查询、插入、更新、删除）并返回结果。
6. Service 返回结果：Service 层接收 Repository 层返回的结果并进行业务处理。
7. Controller 返回视图：Controller 将处理后的数据放入 Model，并返回视图名。
9. View 渲染：视图解析器将逻辑视图名解析为实际视图，视图渲染数据并生成 HTML 响应。
10. 响应返回客户端：生成的 HTML 响应通过 DispatcherServlet 返回给客户端浏览器。

4.持久层框架：MyBatis 3.3、mybatis-plus

4.1mybatis

优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

优点：

1、与JDBC相比，减少了50%的代码量

2、 最简单的持久化框架，简单易学

3、SQL代码从程序代码中彻底分离出来，可以重用

4、提供XML标签，支持编写动态SQL

5、提供映射标签，支持对象与数据库的ORM字段关系映射

缺点：

1、SQL语句编写工作量大，熟练度要高

2、数据库移植性比较差，如果需要切换数据库的话，SQL语句会有很大的差异

4.2Mybatis-plus

优点

1、无侵入：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的 Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性

2、依赖少：仅仅依赖 Mybatis 以及 Mybatis-Spring

3、损耗小：启动即会自动注入基本CRUD，性能基本无损耗，直接面向对象操作

4、通用CRUD操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求

5、多种主键策略：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题

6、支持ActiveRecord：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可实现基本 CRUD 操作

7、支持代码生成：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（P.S. 比 Mybatis 官方的 Generator 更加强大！）
支持自定义全局通用操作：支持全局通用方法注入( Write once, use anywhere )

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

9、内置性能分析插件：可输出Sql语句以及其执行时间，建议开发测试时启用该功能，能有效解决慢查询

10、内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，预防误操作

常用注解

1.数据库名不同，在类上增加@TableName(“mp_user”)
2.主键ID的驼峰一般无法识别，在主键属性上增加@TableId
3.属性与字段名不相同,在属性上增加@TableField(“name”)

@TableName（“数据库表名”）：

使用场景实体类名称和数据表名不一致时，通过它指定表名，此时就可以使用mp的单表操作。

@TableId（“主键名”）：

使用场景实体类属性名称和数据表主键不是id时，通过它声明该属性为主键，就可以采用雪花算法生成主键值操作。

@TableField（“字段名”）：

使用场景实体类属性名称和数据表字段名不一致时，通过它指定数据表字段名称，就可以和实体类属性对应。

3、排除非表字段的三种方式
使用场景： 实体类中的某个属性不对应表中的任何字段，只是用于保存临时数据，或者临时组装的数据。

使用方式

1、 transient修饰实体类属性（修饰的属性不会被序列化）。

缺陷：有些需求需要序列化该字段。

2、 static修饰属性（前提手动实现get、set方法，Lombok对静态属性不会提供get、set方法）。

缺陷：每个对象的属性值一致。

3、 @TableField(exist=false)，这个注解用来表示数据表中不存在该字段，默认是true。

5.数据库连接池：Druid 1.0

5.1应用场景：

点击流分析
服务器指标存储
供应链分析
数字营销/广告分析

5.2使用范围：

插入率很高，但更新很少
大多数查询都是聚合查询
查询等待时间为100ms到几秒
数据具有时间成分
有多个表，但每个查询仅仅只命中一个大的分布式表
具有高基数数据列（例入uid），并且需要对其进行快速计数和排名
数据来源为kafka，HDFS，之类的对象存储

5.3功能特性：

列式存储格式
可扩展的分布式系统
大规模并行处理
实时或批量摄取
自我修复，自我平衡，易于操作
云原生的容错架构，不会丢失数据
用于快速过滤的索引
基于时间的分区
近似算法（性能高，有误差）

5.4特点：

Druid实时的数据消费，真正做到数据摄入实时，查询结果实时
Druid支持PB级数据，千亿级事件快速处理，支持每秒数千查询并发
Druid的核心是时间序列，把数据按照时间序列分批存储，十分适合用于对按照时间进行统计分析的场景
Druid把数据分为三类：时间戳，纬度列，指标列
Druid不支持多表链接
Druid中的数据一般是使用其他计算框架（Spark等）预计算好的低层次统计数据
Druid不适合用户处理透视纬度复杂多变的场景
Druid擅长的查询类型比较单一，一些常用的SQL（group by等）语句在Druid里运行速度一般

6.easyexcel

EasyExcel 是一个用于在 Java 中读取和写入 Excel 文件的快速简便的库。它是 Apache POI 和 JXL 的替代方案，设计为轻量级且用户友好，特别适用于高效处理大型 Excel 文件。

1.主要功能

1. 易于使用：简化的 API，便于读取和写入操作。
2. 性能优化：优化以最小的内存使用处理大文件。
3. 基于注解：支持使用注解将 Java 对象映射到 Excel 行和列。
4. 流式处理：支持以流式处理方式读取和写入大文件，避免内存问题。

2.基本用法

读取 Excel 文件

读取 Excel 文件的示例代码如下：

import com.alibaba.excel.EasyExcel;

public class ReadExcel {
    public static void main(String[] args) {
        String fileName = "example.xlsx";
        EasyExcel.read(fileName, YourDataClass.class, new YourDataListener()).sheet().doRead();
    }
}

写入 Excel 文件

写入 Excel 文件的示例代码如下：

import com.alibaba.excel.EasyExcel;

public class WriteExcel {
    public static void main(String[] args) {
        String fileName = "example.xlsx";
        List<YourDataClass> data = // 获取数据
        EasyExcel.write(fileName, YourDataClass.class).sheet("Sheet1").doWrite(data);
    }
}

3.使用注解进行映射

可以使用注解将 Excel 列映射到 Java 对象字段：

public class YourDataClass {
    @ExcelProperty("Column1")
    private String column1;

    @ExcelProperty("Column2")
    private Integer column2;

    // Getter 和 Setter 方法
}

4.自定义读取逻辑的监听器

实现自定义监听器以获得对读取过程的更多控制：

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;

public class YourDataListener extends AnalysisEventListener<YourDataClass> {
    @Override
    public void invoke(YourDataClass data, AnalysisContext context) {
        // 每行数据的自定义处理逻辑
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 所有行读取完毕后的后续处理
    }
}

5.依赖项

要使用 EasyExcel，请在 pom.xml 中添加以下依赖项：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>easyexcel</artifactId>
    <version>2.2.7</version>
</dependency>

6.结论

EasyExcel 通过提供易于使用的 API、对大文件的良好性能支持以及注解映射和自定义监听器等特性，简化了在 Java 中处理 Excel 文件的工作。

7.日志管理：SLF4J 1.7、Log4j

在 Java 应用程序中，日志管理是非常重要的部分。SLF4J（Simple Logging Facade for Java）和 Log4j 是两种常见的日志框架。以下是它们的介绍及用法。

1.SLF4J

SLF4J 是一个为各种日志系统提供简单统一接口的框架。它本身并不实现日志记录功能，而是与具体的日志实现（如 Log4j、Logback）绑定在一起。

依赖配置

在 pom.xml 中添加 SLF4J 和 Log4j 的依赖：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.32</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.32</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

.示例代码

使用 SLF4J 记录日志的示例代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyApp {
    private static final Logger logger = LoggerFactory.getLogger(MyApp.class);

    public static void main(String[] args) {
        logger.info("This is an info message");
        logger.warn("This is a warning message");
        logger.error("This is an error message");
    }
}

2.Log4j

Log4j 是一个功能强大的日志记录框架，支持多种日志输出方式和灵活的配置。

配置文件

在 src/main/resources 目录下创建 log4j.properties 配置文件：

log4j.rootLogger=DEBUG, stdout, file

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=logs/app.log
log4j.appender.file.MaxFileSize=5MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

8页面交互：Vue2.x

8.1Vue 实例的创建和基本使用方法：

• 使用 new Vue() 创建一个 Vue 实例。
• 传入一个包含选项的对象，如 data、methods、computed、watch 等。
• 使用 el 选项来指定 Vue 实例挂载的元素。

8.2数据绑定：

• 双向数据绑定：使用 v-model 指令实现表单元素与数据的双向绑定。
• 单向数据绑定：使用 v-bind 或简写语法 : 将属性绑定到 Vue 实例的数据。

8.3指令：

• v-if、v-else-if、v-else：条件渲染。
• v-for：循环渲染列表。
• v-on、@：绑定事件监听器。
• v-show：根据条件显示元素。
• v-bind、:：动态地绑定一个或多个属性。

8.4计算属性（Computed Properties）：

• 基于 Vue 实例的响应式依赖进行缓存。
• 在模板中以普通属性的方式使用。
• 适合处理复杂的逻辑或需要缓存的计算结果。

8.5监听属性（Watchers）：

• 监听 Vue 实例中的数据变化。
• 当数据变化时执行特定的函数。

8.6组件：

• 使用 Vue.component() 全局注册组件。
• 在 Vue 实例的 components 选项中注册局部组件。
• 组件之间可以相互通信。

8.7生命周期钩子函数：

• created、mounted、updated、destroyed 等生命周期函数。
• 可以在不同的生命周期阶段执行相应的操作，如数据初始化、DOM 渲染、销毁等。

8.8模板语法：

• 使用双大括号插值表达式 {{ }} 显示数据。
• 使用指令（Directives）操作 DOM。
• 使用事件处理器绑定事件。

8.9过渡动画：

• 使用 transition、transition-group 包裹元素来实现过渡效果。
• 使用 CSS 过渡类名或 JavaScript 钩子函数来控制动画效果。

8.10Vue Router：

• Vue.js 官方的路由管理器。
• 使用路由配置来定义路由规则。
• 使用 router-link 和 router-view 组件来导航和渲染视图。

8.11Vuex：

• Vue.js 官方的状态管理库。
• 包含状态（State）、突变（Mutation）、动作（Action）、模块（Module）等概念。
• 用于管理应用的全局状态。

8.12服务端渲染：

• 使用 Vue SSR 来实现服务端渲染。
• 通过服务器生成 HTML，在客户端进行激活，提高首次加载性能和 SEO。

8.13插件：

• Vue 插件是一个具有 install 方法的 JavaScript 对象。
• 可以扩展 Vue 的功能。

8.14mixin：

• 允许在多个组件之间共享代码。
• 将一组选项合并到组件中。

8.15过滤器（Filters）：

• 用于数据格式化。
• 通过管道符 | 将数据传递给过滤器。

8.16自定义指令：

• 允许开发者注册全局或局部的自定义指令。
• 可以用于操作 DOM。

8.17事件修饰符（Event Modifiers）：

• 用于简化事件处理程序的操作。
• 包括 .stop、.prevent、.capture、.self 等修饰符。

8.18表单输入绑定：

• 使用 v-model 实现表单元素与数据的双向绑定。

8.19组件通信：

• 父子组件通信：通过 props 和事件来实现。
• 兄弟组件通信：通过共享状态或使用事件总线等方式。
• 跨级组件通信：使用 provide/inject 或 Vuex。

8.20动态组件：

• 根据当前组件的状态动态地切换显示不同的组件。

8.21异步组件：

• 使用 import() 或 require.ensure() 动态地加载组件。
• 用于优化应用的性能，延迟加载组件。

8.22插槽（Slots）：

• 用于在组件中扩展内容的机制。
• 具有具名插槽和作用域插槽等不同类型。

8.23动态组件和静态组件：

• 静态组件：在模板中直接引用的组件。
• 动态组件：通过动态绑定组件名来实现动态渲染。

8.24路由导航守卫：

• beforeEach、beforeResolve、afterEach 等导航守卫钩子。
• 用于在路由跳转前、跳转解析完毕后、跳转完成后执行特定逻辑。

8.25事件总线：

• 用于跨组件通信的简单实现方式。
• 创建一个空的 Vue 实例作为事件中心，通过 $emit 和 $on 来发送和监听事件。

8.26混入（Mixins）：

• Vue.js 中一种非常强大的功能，用于在组件之间共享可重用的功能。它允许你将一个对象的所有属性混合到另一个对象中去。
• 定义 Mixin：在 Vue 中，可以通过创建一个普通的 JavaScript 对象来定义 Mixin。这个对象可以包含各种选项，如数据、计算属性、方法等。
• 全局 Mixin：通过 Vue.mixin() 方法全局注册一个 Mixin，它将影响每个 Vue 实例。
• 局部 Mixin：在组件的选项中使用 mixins 属性来指定要混合的 Mixin。这使得 Mixin 可以针对特

9.JWT

JWT（JSON Web Token）是一种用于在各方之间作为 JSON 对象安全地传输信息的紧凑且 URL 安全的令牌。它广泛用于身份验证和信息交换。以下是关于 JWT 的一些基本概念、结构和使用方法的详细介绍。

基本概念

JWT 通常用于身份验证和授权。它由三部分组成：Header、Payload 和 Signature。

1. Header（头部）：包含令牌类型（即 JWT）和所使用的签名算法（如 HMAC SHA256 或 RSA）。
2. Payload（负载）：包含声明（claims），声明是有关实体（通常是用户）和其他数据的声明。常见的声明包括用户 ID、过期时间等。
3. Signature（签名）：用于验证消息在传输过程中是否被篡改。它由编码后的 Header、编码后的 Payload 以及一个秘密或私钥通过指定的算法生成。

JWT 结构

一个典型的 JWT 令牌看起来像这样：

xxxxx.yyyyy.zzzzz

• xxxxx 是编码后的 Header
• yyyyy 是编码后的 Payload
• zzzzz 是签名

Header

Header 通常包含两个部分：令牌类型（JWT）和签名算法（如 HMAC SHA256 或 RSA）。

{
  "alg": "HS256",
  "typ": "JWT"
}

然后将这个 JSON 对象使用 Base64Url 编码，形成 JWT 的第一部分。

Payload

Payload 部分包含声明。声明有三种类型：registered、public 和 private。

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

同样，将这个 JSON 对象使用 Base64Url 编码，形成 JWT 的第二部分。

Signature

要创建签名部分，您需要将编码后的 Header、编码后的 Payload 和一个密钥一起使用签名算法进行签名。

例如，如果使用 HMAC SHA256 算法，签名的生成方式如下：

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret)

使用 JWT

生成 JWT

以下是一个在 Java 中使用 io.jsonwebtoken 库生成 JWT 的示例：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtExample {
    public static void main(String[] args) {
        String secretKey = "mySecretKey";

        String jwt = Jwts.builder()
                .setSubject("user1")
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 hour expiration
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();

        System.out.println("Generated JWT: " + jwt);
    }
}

验证 JWT

以下是一个在 Java 中使用 io.jsonwebtoken 库验证 JWT 的示例：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;

public class JwtExample {
    public static void main(String[] args) {
        String secretKey = "mySecretKey";
        String token = "your_jwt_token_here";

        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(secretKey)
                    .parseClaimsJws(token)
                    .getBody();

            System.out.println("Subject: " + claims.getSubject());
            System.out.println("Expiration: " + claims.getExpiration());
        } catch (Exception e) {
            System.out.println("Invalid JWT token");
        }
    }
}

结论

JWT 是一种强大且灵活的工具，用于在各方之间安全地传输信息。它的紧凑性和 URL 安全性使其特别适用于身份验证和授权。通过正确的实现和使用，可以在确保安全性的同时，简化应用程序的身份验证过程。

10.maven

Maven 是一个用于管理和构建 Java 项目的工具。它提供了一套标准化的项目结构、一个依赖管理系统以及一系列用于构建、测试和发布项目的插件。Maven 项目的核心是 pom.xml 文件，它定义了项目的配置、依赖和构建指令。

基本概念

1. POM（Project Object Model）：POM 文件是 Maven 项目的核心。它是一个 XML 文件，包含了项目的基本信息、依赖、插件配置等。
2. 依赖管理：Maven 自动管理项目的依赖，包括下载、更新和解决依赖冲突。
3. 生命周期：Maven 定义了一套标准的生命周期，包含清理、编译、测试、打包、部署等阶段。
4. 仓库：Maven 使用中央仓库和本地仓库来存储依赖库。本地仓库位于用户的本地文件系统中，而中央仓库位于互联网上。

安装 Maven

1. 下载并解压 Apache Maven：

   • 访问 Maven 官方网站 并下载最新版本的二进制压缩包。
   • 解压缩下载的文件到一个目录。

2. 配置环境变量：

   • 添加 MAVEN_HOME 环境变量，指向 Maven 的安装目录。
   • 将 Maven 的 bin 目录添加到 PATH 环境变量中。

3. 验证安装：

   • 打开命令行，输入 mvn -v，如果安装成功，将显示 Maven 的版本信息。

创建一个 Maven 项目

使用 Maven 的 archetype:generate 命令创建一个新项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

这将创建一个标准的 Maven 项目结构：

my-app
│   pom.xml
└───src
    └───main
    │   └───java
    └───test
        └───java

POM 文件

一个简单的 pom.xml 文件示例如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

常用命令

• mvn clean: 清理项目，删除生成的文件。
• mvn compile: 编译源代码。
• mvn test: 运行测试。
• mvn package: 打包项目，生成 JAR 或 WAR 文件。
• mvn install: 将打包好的文件安装到本地仓库。
• mvn deploy: 部署项目到远程仓库。

依赖管理

Maven 使依赖管理变得非常简单。只需在 pom.xml 文件中添加依赖项，Maven 将自动下载并包含这些依赖。

例如，添加 Google Guava 库作为依赖：

<dependencies>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>30.1.1-jre</version>
    </dependency>
</dependencies>

插件

Maven 提供了丰富的插件来扩展其功能。例如，使用 Maven Compiler 插件指定 Java 版本：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

多模块项目

Maven 支持多模块项目，通过一个父 POM 文件管理多个子模块：

<modules>
    <module>module-a</module>
    <module>module-b</module>
</modules>

结论

Maven 是一个强大的构建和项目管理工具，通过标准化的项目结构、依赖管理和插件系统，大大简化了 Java 项目的构建和管理过程。掌握 Maven 的基本用法和配置，可以有效提高开发效率。

11.redis

Redis 的基本概念

1. 键值对存储：Redis 是一个键值对存储系统。每个键都可以存储多种类型的值。
2. 内存存储：Redis 将所有数据存储在内存中，提供非常高的性能。
3. 持久化：虽然主要在内存中工作，Redis 也支持将数据持久化到磁盘。
4. 丰富的数据类型：Redis 支持多种数据类型，包括字符串、哈希、列表、集合、有序集合等。
5. 高可用性和分布式：Redis 支持主从复制和哨兵模式，能够实现高可用性。也可以通过分片实现分布式存储。

安装 Redis

在 Linux 上安装 Redis

1. 下载并解压 Redis 源码：

wget http://download.redis.io/redis-stable.tar.gz
tar xvzf redis-stable.tar.gz
cd redis-stable

2. 编译 Redis：

make

3. 启动 Redis 服务器：

src/redis-server

4. 启动 Redis 客户端：

src/redis-cli

在 Windows 上安装 Redis

可以使用第三方提供的 Windows 版本的 Redis，例如 Memurai 或 Redis for Windows。

基本使用

启动 Redis 服务器

默认情况下，Redis 服务器会监听 6379 端口。可以通过以下命令启动：

redis-server

使用 Redis 客户端

启动 Redis 客户端：

redis-cli

在客户端中，可以执行各种 Redis 命令，例如：

SET key "value"
GET key

Redis 基本命令

1. 字符串操作：

SET key "value"   # 设置键值对
GET key           # 获取键的值
DEL key           # 删除键

2. 哈希操作：

HSET myhash field1 "value1"  # 设置哈希字段
HGET myhash field1           # 获取哈希字段的值
HDEL myhash field1           # 删除哈希字段

3. 列表操作：

LPUSH mylist "value"  # 在列表头部插入值
RPUSH mylist "value"  # 在列表尾部插入值
LPOP mylist           # 移除并返回列表头部的值
RPOP mylist           # 移除并返回列表尾部的值

4. 集合操作：

SADD myset "value"  # 向集合添加值
SMEMBERS myset      # 返回集合中的所有成员
SREM myset "value"  # 从集合中移除值

5. 有序集合操作：

ZADD myzset 1 "value1"  # 向有序集合添加值
ZRANGE myzset 0 -1      # 返回有序集合中的所有值
ZREM myzset "value1"    # 从有序集合中移除值

配置文件

Redis 的默认配置文件是 redis.conf，可以通过编辑这个文件来调整 Redis 的行为，例如端口号、持久化策略、内存限制等。

持久化

Redis 提供两种持久化方式：

1. RDB（Redis Database File）：定期生成的数据快照。
2. AOF（Append Only File）：记录每个写操作，重启时重新执行这些操作以重建数据。

可以在 redis.conf 文件中配置持久化策略。

高可用性

Redis 通过主从复制和哨兵（Sentinel）实现高可用性：

1. 主从复制：将数据从主服务器复制到一个或多个从服务器。
2. 哨兵：监控主从服务器，自动执行故障转移。

结论

Redis 是一个功能强大的内存数据存储系统，适用于需要高性能、高可用性的数据存储和缓存解决方案。通过掌握基本概念和命令，可以有效地使用 Redis 提高应用程序的性能和可靠性。