4.基础技术&API网关&JWT-阿里云开发者社区

基础技术

自定义拦截器-HandlerInterceptor

一般情况下，对来自浏览器的请求，在该请求进行业务逻辑处理之前，我们是可以进行拦截处理的，实现的方式有两种，分别是基于Tomcat的Filter，和基于SpringMVC的HandlerInterceptor。

基于Tomcat的Filter实现拦截，可以利用SpringBoot的FilterRegistrationBean实现Filter和Spring 的整合，向Tomcat注册自定义Filter，使Filter可以在Servlet处理请求之前拦截请求。
基于SpringMVC中的拦截器HandlerInterceptor实现拦截器，拦截器可以在Controller中相应的 Action方法处理请求前进行拦截

Filter和Interceptor的区别：
1. Filter直接依赖Servlet容器，而Interceptor不直接依赖于Servlet容器
2. Filter对Http请求起作用，而Interceptor只能对action请求起作用。
3. Interceptor可以访问Action的上下文值栈里的对象，即接收的参数，而Filter不能。
4. 在action的生命周期里，Interceptor可以被多次调用，而Filter针对一个请求只会被调用一次。
5. Filter在过滤是只能对request和response进行操作，而interceptor可以对request、response、handler、 modelAndView、exception进行操作

代码实现

@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行了preHandle");
        return false;
    }
}

@Configuration
public class MyWebMvcConfiure implements WebMvcConfigurer {
    @Autowired
    MyInterceptor myInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry
                .addInterceptor(myInterceptor)
                .addPathPatterns("/**");
    }
}

请求的拦截流程：

TK-Mybatis

官网：https://github.com/abel533/Mapper/wik

TK-Mybatis是在Mybatis的基础之上进行了简化开发，主要针对单表的查询更方便了

使用步骤：

导入依赖

<!--Tk-Mybatis相关-->
<!--Mysql连接-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>
<!--durid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.16</version>
</dependency>
<!--tk-Mybatis-->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
</dependency>

数据源配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/practice?useUnicode=true&characterEncoding=utf8&useOldAliasMetadataBehavior=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

这里在配置的时候一定要注意带上时区的信息，否则会报错

代码

DO类

@Data
@Table(name = "user") //设置该类对应的表名
public class User {
    @Id //标记为主键
    @KeySql(useGeneratedKeys = true) //开启插入返回主键
   public Integer id;
    @Column(name = "username") //当类中的属性名和表中的字段对不上时，使用Column注解来转换
   public String name;
   public String mobile;
}

接口

public interface UserMapper extends Mapper<User> {
}

SpringBoot的启动类

@SpringBootApplication
@MapperScan(basePackages = "com.fh.tkmybatis.tk") //扫描mapper包配置，注意要使用tk-mybatis的
public class TkMybatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(TkMybatisApplication.class, args);
    }
}

使用

@Test
    public void testInsert(){
//        User user = new User();
//        user.setMobile("1234567");
//        user.setName("whwu");
//        userMapper.insert(user);
        User user = new User();
        user.setName("zl");
        userMapper.insertSelective(user);
    }
    @Test
    public void query(){
//        User user = userMapper.selectByPrimaryKey(6);
//        System.out.println(user);
//        User user = new User();
//        user.setId(7);
//        User user1 = userMapper.selectByPrimaryKey(user);
//        System.out.println(user1);  
//        Example example = new Example(User.class);
//
//         example.createCriteria().andEqualTo("name", "zl");
//
//        List<User> users = userMapper.selectByExample(example);
//
//        System.out.println(users);
        Example example = new Example(User.class);
        example.createCriteria().andLike("name","%z%");
        List<User> users = userMapper.selectByExample(example);
        System.out.println(users);
    }
    @Test
    public void  testUpdate(){
        User user = new User();
        user.setName("景天");
        Example example = new Example(User.class);
        example.createCriteria().andEqualTo("mobile","1234");
        userMapper.updateByExampleSelective(user,example);
    }
    @Test
    public void testDelete(){
        Example example = new Example(User.class);
        example.createCriteria().andEqualTo("name","景天");
        userMapper.deleteByExample(example);
    }

MapStruct

在一个成熟的工程中，尤其是现在的分布式系统中，应用与应用之间，还有单独的应用细分模块之后， DO一般不会让外部依赖，这时候需要在提供对外接口的模块里放 DTO用于对象传输，也即是 DO对象对内，DTO对象对外，DTO 可以根据业务需要变更，并不需要映射 DO 的全部属性。

DTO : Data Transport Object (数据传输对象)

VO: View Object （视图解析对象）

导入依赖

<!--mapstruct-->
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-jdk8</artifactId>
    <version>1.3.0.Final</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.3.0.Final</version>
</dependency>

定义转换器接口

@Mapper(componentModel = "spring")
public interface UserConverter {
    @Mappings({
            @Mapping(source = "name",target = "username")
    })
    UserDTO usertoUserDTO(User user);
    List<UserDTO> usersToUserDTOList(List<User> users);
}

同样的，如果这里出现了DO类和DTO类的属性名称对不上，那么是可以使用@Mappings注解来进行转换的，如果定义了单个对象的转换的方法上加上了注解，那在List的方法上就不需要加上注解了

@Data
public class UserDTO {
    public Integer id;
    public String username;
}

使用定义好的转换器

@Test
public void testMapStruct(){
    Example example = new Example(User.class);
    example.createCriteria().andLike("name","%h%");
    List<User> users = userMapper.selectByExample(example);
    System.out.println(users);
    List<UserDTO> userDTOS = userConverter.usersToUserDTOList(users);
    System.out.println(userDTOS);
}

SPI

SPI 全称为 (Service Provider Interface) ,是JDK内置的一种服务提供发现机制。目前有不少框架用它来做接口实现类的扩展发现(Dubbo、JDBC等），简单来说，它就是一种动态替换发现的机制，举个例子来说，有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。

Java SPI的机制的约定

当服务的提供者提供了服务接口的一种实现之后，在jar包的META-INF/services/目录中同时创建一个以服务接口命名的文件。
该文件里就是实现该服务接口的具体实现类。
而当程序运行时，使用这个接口的实现类的时，就能通过该jar包META-INF/Services/的配置文件找到具体的实现类名。
并加载该实现类(可能有多个)并实例化基于这样的一个约定就能很好的找到服务接口的实现类，而不需要在代码里指定。

具体的代码实现：

首先定义接口

public interface Pay {
    void payAccount(Double money);
}

定义接口实现类

public class AliPay implements Pay {
    @Override
    public void payAccount(Double money) {
        System.out.println("支付宝支付"+money+"元");
    }
}

public class WechatPay implements Pay {
    @Override
    public void payAccount(Double money) {
        System.out.println("微信支付"+money+"元");
    }
}

配置文件的名字需要和接口的全限定类名一致，里面的内容填写接口的实现类的全限定类名即可

com.fh.tkmybatis.spi.WechatPay
com.fh.tkmybatis.spi.AliPay

使用过程

public class Test {
    public static void main(String[] args) {
        ServiceLoader<Pay> load = ServiceLoader.load(Pay.class);
        Iterator<Pay> iterator = load.iterator();
        while (iterator.hasNext()){
            Pay next = iterator.next();
            next.payAccount(200.0);
        }
    }
}

Gateway&JWT

API网关

概述

API是Application Programming Interface缩写，翻译成中文就是应用程序接口。在实际微服务中可以理解一个个功能方法。就比如你一个用户服务的微服务，可以对外提供 API 接口为，查找用户，创建用户等。

网关：

在计算机网络中，网关（英语：Gateway）是转发其他服务器通信数据的服务器，接收从客户端发送来的请求时，它就像自己拥有资源的源服务器一样对请求进行处理

如果没有网关，难道不行吗？功能上是可以的，我们直接调用提供的接口就可以了。那为什么还需要网关？

因为网关的作用不仅仅是转发请求而已。我们可以试想一下，如果需要做一个请求认证功能，我们可以接入到 API 服务中。但是倘若后续又有服务需要接入，我们又需要重复接入。这样我们不仅代码要重复编写，而且后期也不利于维护。

由于接入网关后，网关将转发请求。所以在这一层做请求认证，天然合适。这样这需要编写一次代码，在这一层过滤完毕，再转发给下面的 API。所以 API 网关的通常作用是完成一些通用的功能，如请求认证，请求记录，请求限流，黑白名单判断等。

API网关是一个服务器，是系统的唯一入口。

API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。通常，网关也是提供REST/HTTP的访问API。

架构图

JWT

简介

JWT全称 Json·Web·Token，是一个开放标准（RFC·7519），它定义了一种紧凑的，自包含的方式，用于作为JSON对象在各方之间安全的传输信息。该信息可以被验证和信任，因为它是数字签名的。

JWT是目前最流行的跨域身份解决方案。

使用场景

下列场景中使用JWT是很有用的：

Information Exchange（信息交换）：对于安全的在各方之间传输信息而言，Json·Web·Token 无疑是一种很好的方式。因为JWT可以被签名，我们还可以验证内容有没有被篡改。
正因为数据可以基于JWT进行安全的传输，所以基于JWT，我们可以实现单点登录功能

单点登录：Single Sign On，简称为 SSO，是比较流行的企业业务整合的解决方案之一。SSO的定义是在
多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。

单点登录问题及解决方案

方案1：Nginx负载均衡做iphash，同一个用户的请求永远只给到同一个后台服务器。

不足之处：

一个服务有若干个用户，有的用户活跃，向后端发起请求的次数比较频繁，而有的用户不活跃，那么基于这种iphash的解决方案的话就势必会造成负载不均衡，也就是说有的tomcat服务服务器压力大，而有的tomcat服务器压力不大，造成资源分配不均的情况。
其次就是假如有一个tomcat服务挂了，那么对于有一些用户来说，这个系统就挂了，失去了集群的意义。

方案2：基于tomcat广播的session复制

不足之处：

每一个tomcat都需要维护一个大的session，会造成内存资源紧张。
大量复制session占用服务器带宽

方案3：将session数据，以能够共享的方式存储，比如存储到Mysql，或者Redis数据库中

存储session数据时，还要多访问一次数据库，或涉及到网络，或IO过程

解决方案：使用JWT能够完美的解决上述问题

基于Token的身份认证，大概流程如下：

1.客户端使用用户名、密码登陆

2.服务器接收到请求后去验证用户名和密码

3.验证成功之后服务端会签发一个token，并且将这个token发送给客户端

4.客户端接收到了token之后将他存储起来

5.客户端每次向服务器发起请求的时候都需要带着服务器签发的token

6.服务端接收到请求，然后去验证客户端中的token，如果验证成功，就返回请求数据，否则不返回

Token VS Session

在看JWT如何解决上述问题之前，我们先来看看基于Token的身份认证与基于session的身份认证。

基于session的身份认证。

Sessions：每次用户认证通过以后，服务器需要创建一条记录来保存用户信息，通常是在内存中。那么随着认证通过的用户越来越多，服务器在这里的开销就会越来越大。
Scalability：由于session是在内存中的，这就带来一些扩展性的问题。
CSRF：用户很容易受到CSRF的攻击

CSRF:跨站请求伪造(早期的攻击方式)
假设一个网站用户Bob可能正在浏览聊天论坛，而同时另一个用户Alice也在此论坛中，并且后者
刚发布了一个具有Bob银行链接的图片信息。正常情况下，Bob点击图片链接访问银行，银行会让
Bob登录
假如Bob在此之前刚好登录过了银行，浏览器中还有cookie，那么此时银行可能认为点击这个图片访问银行是Bob发出的，所以会正常给出响应。假如这个链接是一个Alice伪造的转账的请求，那么就会产生经济损失

对比

而JWT是把用户信息保存在客户端，基于token的方式将用户状态分散到了各个客户端中，可以减轻服务端的内存压力。
session的状态存储在服务端，客户端只有sessionId，而token的状态是存储在客户端，这就使得服务器端并未存储用户登录状态，是无状态的，因为是无状态的，所以便于集群的扩容。每次在扩容的时候就不需要关心session的复制等问题
安全

Token不是cookie。每次请求的时候token都会被发送，可以作为请求参数发送，可以放在请求头里面发送，也可以放在cookie里面被发送
即使在你的实现中将token存储到客户端的cookie中，这个cookie也只是一种存储机制，而非身份认证机制。没有基于会话的信息可以操作，因为我们没有会话

JWT token的基本格式

JSON·Web·Token由三部分组成，他们之间用圆点（·）连接，这三部分分别是

Header
Payload
Signature

Header由两部分的信息组成：

type：声明类型，这里的是jwt
alg：声明加密的算法通常直接使用 HMAC SHA256

Payload就是存放有效信息的地方（不强制）

iss: jwt签发者

sub: jwt所面向的用户

aud: 接收jwt的一方

exp: jwt的过期时间，这个过期时间必须要大于签发时间

nbf: 定义在什么时间之前，该jwt都是不可用的

iat: jwt的签发时间

jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击

claim：jwt存放信息的地方

Signature：签名信息

因此，一个典型的JWT看起来是这个样子的： xxxxxxxx·yyyyyyyyyy·zzzzzzzzzzz

例如：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ3bGd6cyIsImV4cCI6MTU4Nzk3MzY1NywidXNlciI6Ijk2MkYxODkwNTVFMzRFNzVERjVGMzQ0QTgxODNCODdGIn0.APehq9dxRiilgTOGyuz9qtZxvPDIJ5QIIVUCLYeX1QE

项目中如何使用

项目已经整合好了JWT，并且给我们提供了现有的工具类进行操作

com.mall.user.utils.JwtTokenUtils

如何使用现有的工具创建JWT呢？

String token = JwtTokenUtils.builder().msg("xxx").build().creatJwtToken();

如何解析JWT呢？

String msg = JwtTokenUtils.builder().token(token).build().freeJwt();

JWT的具体的执行流程

首先在登陆的时候进行用户名密码验证，如果通过了那就通过加密算法存储信息后将token给客户端
客户端之后访问网站的时候只需要携带token即可，然后服务器通过预存的解密算法进行解密，如果能正常的解密出来，那就说明是正确的token，即放行请求，否则不通过
即使是多台服务器，只需要进行相同的方法解密就行了

TOGyuz9qtZxvPDIJ5QIIVUCLYeX1QE

### 项目中如何使用
项目已经整合好了JWT，并且给我们提供了现有的工具类进行操作

com.mall.user.utils.JwtTokenUtils

如何使用现有的工具创建JWT呢？
```java
String token = JwtTokenUtils.builder().msg("xxx").build().creatJwtToken();

如何解析JWT呢？

String msg = JwtTokenUtils.builder().token(token).build().freeJwt();

JWT的具体的执行流程

首先在登陆的时候进行用户名密码验证，如果通过了那就通过加密算法存储信息后将token给客户端
客户端之后访问网站的时候只需要携带token即可，然后服务器通过预存的解密算法进行解密，如果能正常的解密出来，那就说明是正确的token，即放行请求，否则不通过
即使是多台服务器，只需要进行相同的方法解密就行了

4.基础技术&API网关&JWT

基础技术

自定义拦截器-HandlerInterceptor

TK-Mybatis

MapStruct

SPI

Gateway&JWT

API网关

概述

架构图

JWT

简介

使用场景

单点登录问题及解决方案

Token VS Session

JWT token的基本格式

项目中如何使用

JWT的具体的执行流程

JWT的具体的执行流程

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

4.基础技术&API网关&JWT

基础技术

自定义拦截器-HandlerInterceptor

TK-Mybatis

MapStruct

SPI

Gateway&JWT

API网关

概述

架构图

JWT

简介

使用场景

单点登录问题及解决方案

Token VS Session

JWT token的基本格式

项目中如何使用

JWT的具体的执行流程

JWT的具体的执行流程

热门文章

最新文章

相关课程

相关电子书

相关实验场景