在分布式系统当中，传统的登录会失效（原因：各微服务间用的不是同一台tomcat，我们以前登录判断用户状态是通过tomcat session，即把用户信息保存在tomcat session中，现在我们有几台不同的tomcat，在这台登录完会有tomcat session信息，但是跳到另外一个微服务，会没有登录状态，因此登录状态无法共享，因此之前我们学的登录在分布式系统中是无法使用的，不能存到session里去）

1.1 什么是有状态？

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。

例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。

缺点是什么？

服务端若搭建集群，集群间的数据无法共享，于是用户状态无法共享，就不能实现一个跨服务的登录
服务端保存大量数据，增加服务端压力
服务端保存用户状态，无法进行水平扩展
客户端请求依赖服务端，多次请求必须访问同一台服务器

1.2 什么是无状态

识别用户的身份信息是由客户端自己去携带
微服务集群中的每个服务，对外提供的都是Rest风格的接口。而Rest风格的一个最重要的规范就是：服务的无状态性，即：

服务端不保存任何客户端请求者信息
客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

带来的好处是什么呢？

客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务
服务端的集群和状态对客户端透明
服务端可以任意的迁移和伸缩
减小服务端存储压力

1.3 如何实现无状态

无状态登录的流程：

当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
以后每次请求，客户端都携带认证的token
服务的对token进行解密，判断是否有效。

流程图：
在这里插入图片描述
整个登录过程中，最关键的点是：token的安全性

token是识别客户端身份的唯一标示，如果加密不够严密，被人伪造那就完蛋了。

采用何种方式加密才是安全可靠的呢？

我们将采用JWT + RSA非对称加密

1.4 JWT

1.4.1 简介

JWT，全称是Json Web Token，是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io
在这里插入图片描述
GitHub上jwt的java客户端：https://github.com/jwtk/jjwt

1.4.2 数据格式

JWT包含三部分数据：

Header：头部，通常头部有两部分信息：
- 声明类型，这里是JWT
- 加密算法，自定义（我们用的RSA）
  我们会对头部进行base64加密（可解密），得到第一部分数据
Payload：载荷，就是有效数据，一般包含下面信息：
- 用户身份信息（注意，这里因为采用base64加密，可解密，因此不要存放敏感信息）
- 注册声明：如token的签发时间，过期时间，签发人等
  这部分也会采用base64加密，得到第二部分数据
Signature：签名，是整个数据的认证信息。通过base64对头和载荷进行编码，一般根据前两步的数据，再加上服务的的密钥（secret）（不要泄漏，最好周期性更换），通过加密算法生成（RSA算法进行加密，无法进行篡改）。用于验证整个数据完整和可靠性

生成的数据格式：
在这里插入图片描述
可以看到分为3段，每段就是上面的一部分数据

1.4.3 JWT交互流程

流程图：
在这里插入图片描述
步骤翻译：

1、用户登录
2、服务的认证，通过后根据secret生成token
3、将生成的token返回给用户
4、用户每次请求携带token
5、服务端利用公钥解读jwt签名，判断签名有效后，从Payload中获取用户信息
6、处理请求，返回响应结果

因为JWT签发的token中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，完全符合了Rest的无状态规范。

1.4.4 非对称加密

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

对称加密，如AES（通信双方都持有相同秘钥）
- 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
- 优势：算法公开、计算量小、加密速度快、加密效率高
- 缺陷：双方都使用同样密钥，安全性得不到保证
非对称加密，如RSA
- 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
  - 私钥加密，持有私钥或公钥才可以解密
  - 公钥加密，持有私钥才可解密
- 优点：安全，难以破解
- 缺点：算法比较耗时
不可逆加密，如MD5，SHA
- 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

RSA算法历史：

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：RSA

1.5 结合Zuul的鉴权流程

我们逐步演进系统架构设计。需要注意的是：secret是签名的关键，因此一定要保密，我们放到鉴权中心保存，其它任何服务中都不能获取secret。

1.5.1 没有RSA加密时

在微服务架构中，我们可以把服务的鉴权操作放到网关中，将未通过鉴权的请求直接拦截，如图：
在这里插入图片描述

1、用户请求登录
2、Zuul将请求转发到授权中心，请求授权
3、授权中心校验完成，颁发JWT凭证
4、客户端请求其它功能，携带JWT
5、Zuul将jwt交给授权中心校验，通过后放行
6、用户请求到达微服务
7、微服务将jwt交给鉴权中心，鉴权同时解析用户信息
8、鉴权中心返回用户数据给微服务
9、微服务处理请求，返回响应

发现什么问题了？

每次鉴权都需要访问鉴权中心，系统间的网络请求频率过高，效率略差，鉴权中心的压力较大。

1.5.2 结合RSA的鉴权

通过公钥解析jwt获取信息，减少与授权中心之间的请求次数

直接看图：

在这里插入图片描述

我们首先利用RSA生成公钥和私钥。私钥保存在授权中心，公钥保存在Zuul和各个微服务
用户请求登录
授权中心校验，通过后用私钥对JWT进行签名加密
返回jwt给用户
用户携带JWT访问
Zuul直接通过公钥解密JWT，进行验证，验证通过则放行
请求到达微服务，微服务直接用公钥解析JWT，获取用户信息，无需访问授权中心

服务暴露的问题？

避免被暴露

jwt服务间鉴权

2. 授权中心

2.1 搭建项目

授权中心的主要职责：

用户鉴权：
- 接收用户的登录请求，通过用户中心的接口进行校验，通过后生成JWT
- 使用私钥生成JWT并返回
服务鉴权：微服务间的调用不经过Zuul，会有风险,需要鉴权中心进行认证
- 原理与用户鉴权类似，但逻辑稍微复杂一些（此处我们不做实现）

因为生成jwt，解析jwt这样的行为以后在其它微服务中也会用到，因此我们会抽取成工具。我们把鉴权中心进行聚合，一个工具module：ly-auth-common，一个提供服务的module： ly-auth-service。

2.1.1 引入依赖

2.1.1.1 父工程ly-auth

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>leyou</artifactId>
        <groupId>com.leyou.parent</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.service</groupId>
    <artifactId>ly-auth</artifactId>

    <packaging>pom</packaging>
    <modules>
        <module>ly-auth-common</module>
        <module>ly-auth-service</module>
    </modules>
</project>

2.1.1.2 ly-auth-common

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>ly-auth</artifactId>
        <groupId>com.leyou.service</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.service</groupId>
    <artifactId>ly-auth-common</artifactId>

    <dependencies>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

2.1.1.3 ly-auth-service

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>ly-auth</artifactId>
        <groupId>com.leyou.service</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.service</groupId>
    <artifactId>ly-auth-service</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.leyou.service</groupId>
            <artifactId>ly-auth-common</artifactId>
            <version>${leyou.latest.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.leyou.common</groupId>
            <artifactId>ly-common</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.leyou.service</groupId>
            <artifactId>ly-user-interface</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

2.1.2 配置

server:
  port: 8087
spring:
  application:
    name: auth-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
    registry-fetch-interval-seconds: 10
  instance:
    #lease-renewal-interval-in-seconds: 5 # 每隔5秒发送一次心跳
    #lease-expiration-duration-in-seconds: 10 # 10秒不发送就过期
    prefer-ip-address: true
    ip-address: 127.0.0.1
    #instance-id: ${spring.application.name}:${server.port}
ly:
  jwt:
    secret: ly@Login(Auth}*^31)&yun6%f3q2 # 登录校验的密钥
    pubKeyPath: E:/course/JavaProject/javacode/idea/rsa/rsa.pub # 公钥地址
    priKeyPath: E:/course/JavaProject/javacode/idea/rsa/rsa.pri # 私钥地址
    expire: 30 # 过期时间,单位分钟
    cookieName: LY_TOKEN

2.1.3 启动类

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class LyAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(LyAuthApplication.class, args);
    }
}

2.1.4 添加网关路由

在这里插入图片描述

2.2 编写JWT工具

我们在ly-auth-coomon中编写一些通用的工具类：
在这里插入图片描述

2.2.1 RSA工具类

public class RsaUtils {
    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥保存路径，相对于classpath
     * @return 公钥对象
     * @throws Exception
     */
    public static PublicKey getPublicKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPublicKey(bytes);
    }

    /**
     * 从文件中读取密钥
     *
     * @param filename 私钥保存路径，相对于classpath
     * @return 私钥对象
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPrivateKey(bytes);
    }

    /**
     * 获取公钥
     *
     * @param bytes 公钥的字节形式
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(byte[] bytes) throws Exception {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(byte[] bytes) throws Exception {
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(spec);
    }

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     * @throws IOException
     * @throws NoSuchAlgorithmException
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(1024, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        writeFile(privateKeyFilename, privateKeyBytes);
    }

    private static byte[] readFile(String fileName) throws Exception {
        return Files.readAllBytes(new File(fileName).toPath());
    }

    private static void writeFile(String destPath, byte[] bytes) throws IOException {
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        Files.write(dest.toPath(), bytes);
    }
}

2.2.2 常量类

其中定义了jwt中的payload的常用key

public abstract class JwtConstans {
    public static final String JWT_KEY_ID = "id";
    public static final String JWT_KEY_USER_NAME = "username";
}

2.2.3 对象工具类：

从jwt解析得到的数据是Object类型，转换为具体类型可能出现空指针，这个工具类进行了一些转换：

public class ObjectUtils {

    public static String toString(Object obj) {
        if (obj == null) {
            return null;
        }
        return obj.toString();
    }

    public static Long toLong(Object obj) {
        if (obj == null) {
            return 0L;
        }
        if (obj instanceof Double || obj instanceof Float) {
            return Long.valueOf(StringUtils.substringBefore(obj.toString(), "."));
        }
        if (obj instanceof Number) {
            return Long.valueOf(obj.toString());
        }
        if (obj instanceof String) {
            return Long.valueOf(obj.toString());
        } else {
            return 0L;
        }
    }

    public static Integer toInt(Object obj) {
        return toLong(obj).intValue();
    }
}

2.2.4 载荷:UserInfo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo {
    private Long id;
    private String username;
}

2.2.5 JWT工具类

我们需要先在ly-auth-common中引入JWT依赖：

<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

代码：

public class JwtUtils {
    /**
     * 私钥加密token
     *
     * @param userInfo      载荷中的数据
     * @param privateKey    私钥
     * @param expireMinutes 过期时间，单位秒
     * @return
     * @throws Exception
     */
    public static String generateToken(UserInfo userInfo, PrivateKey privateKey, int expireMinutes) throws Exception {
        return Jwts.builder()
                .claim(JwtConstans.JWT_KEY_ID, userInfo.getId())
                .claim(JwtConstans.JWT_KEY_USER_NAME, userInfo.getUsername())
                .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                .signWith(SignatureAlgorithm.RS256, privateKey)
                .compact();
    }

    /**
     * 私钥加密token
     *
     * @param userInfo      载荷中的数据
     * @param privateKey    私钥字节数组
     * @param expireMinutes 过期时间，单位秒
     * @return
     * @throws Exception
     */
    public static String generateToken(UserInfo userInfo, byte[] privateKey, int expireMinutes) throws Exception {
        return Jwts.builder()
                .claim(JwtConstans.JWT_KEY_ID, userInfo.getId())
                .claim(JwtConstans.JWT_KEY_USER_NAME, userInfo.getUsername())
                .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                .signWith(SignatureAlgorithm.RS256, RsaUtils.getPrivateKey(privateKey))
                .compact();
    }

    /**
     * 公钥解析token
     *
     * @param token     用户请求中的token
     * @param publicKey 公钥
     * @return
     * @throws Exception
     */
    private static Jws<Claims> parserToken(String token, PublicKey publicKey) {
        return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
    }

    /**
     * 公钥解析token
     *
     * @param token     用户请求中的token
     * @param publicKey 公钥字节数组
     * @return
     * @throws Exception
     */
    private static Jws<Claims> parserToken(String token, byte[] publicKey) throws Exception {
        return Jwts.parser().setSigningKey(RsaUtils.getPublicKey(publicKey))
                .parseClaimsJws(token);
    }

    /**
     * 获取token中的用户信息
     *
     * @param token     用户请求中的令牌
     * @param publicKey 公钥
     * @return 用户信息
     * @throws Exception
     */
    public static UserInfo getInfoFromToken(String token, PublicKey publicKey) throws Exception {
        Jws<Claims> claimsJws = parserToken(token, publicKey);
        Claims body = claimsJws.getBody();
        return new UserInfo(
                ObjectUtils.toLong(body.get(JwtConstans.JWT_KEY_ID)),
                ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
        );
    }

    /**
     * 获取token中的用户信息
     *
     * @param token     用户请求中的令牌
     * @param publicKey 公钥
     * @return 用户信息
     * @throws Exception
     */
    public static UserInfo getInfoFromToken(String token, byte[] publicKey) throws Exception {
        Jws<Claims> claimsJws = parserToken(token, publicKey);
        Claims body = claimsJws.getBody();
        return new UserInfo(
                ObjectUtils.toLong(body.get(JwtConstans.JWT_KEY_ID)),
                ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
        );
    }
}

2.2.6 测试

我们在ly-auth-common中编写测试类：
在这里插入图片描述

public class JwtTest {

    private static final String pubKeyPath = "D:\\heima\\rsa\\rsa.pub";

    private static final String priKeyPath = "D:\\heima\\rsa\\rsa.pri";

    private PublicKey publicKey;

    private PrivateKey privateKey;

    @Test
    public void testRsa() throws Exception {
        RsaUtils.generateKey(pubKeyPath, priKeyPath, "234");
    }

    //@Before
    public void testGetRsa() throws Exception {
        this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
        this.privateKey = RsaUtils.getPrivateKey(priKeyPath);
    }

    @Test
    public void testGenerateToken() throws Exception {
        // 生成token
        String token = JwtUtils.generateToken(new UserInfo(20L, "jack"), privateKey, 5);
        System.out.println("token = " + token);
    }

    @Test
    public void testParseToken() throws Exception {
        String token = "eyJhbGciOiJSUzI1NiJ9.eyJpZCI6MjAsInVzZXJOYW1lIjoiamFjayIsImV4cCI6MTUyNzMzMDY5NX0.VpGNedy1z0aR262uAp2sM6xB4ljuxa4fzqyyBpZcGTBNLodIfuCNZkOjdlqf-km6TQPoz3epYf8cc_Rf9snsGdz4YPIwpm6X14JKU9jwL74q6zy61J8Nl9q7Zu3YnLibAvcnC_y9omiqKN8-iCi7-MvM-LwVS7y_Cx9eu0aaY8E";

        // 解析token
        UserInfo user = JwtUtils.getInfoFromToken(token, publicKey);
        System.out.println("id: " + user.getId());
        System.out.println("userName: " + user.getUsername());
    }
}

2.2.6.1 测试生成公钥和私钥

我们运行这段代码：
在这里插入图片描述
运行之后，查看目标目录：

公钥和私钥已经生成了！

2.2.6.2 测试生成token

在这里插入图片描述

2.2.6.3 测试解析token

在这里插入图片描述
正常情况：

任意改动token，发现报错了：

2.3 编写登录授权接口

接下来，我们需要在ly-auth-servcice编写一个接口，对外提供登录授权服务。基本流程如下：

客户端携带用户名和密码请求登录
授权中心调用客户中心接口，根据用户名和密码查询用户信息
如果用户名密码正确，能获取用户，否则为空，则登录失败
如果校验成功，则生成JWT并返回

2.3.1 生成公钥和私钥

我们需要在授权中心生成真正的公钥和私钥。我们必须有一个生成公钥和私钥的secret，这个可以配置到application.yml中：

ly:
  jwt:
    secret: ly@Login(Auth}*^31)&yun6%f3q2 # 登录校验的密钥
    pubKeyPath: E:/course/JavaProject/javacode/idea/rsa/rsa.pub # 公钥地址
    priKeyPath: E:/course/JavaProject/javacode/idea/rsa/rsa.pri # 私钥地址
    expire: 30 # 过期时间,单位分钟
    cookieName: LY_TOKEN

然后编写属性类，加载这些数据：

package com.leyou.auth.config;

import com.leyou.auth.utils.RsaUtils;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;

import javax.annotation.PostConstruct;
import java.io.File;
import java.security.PrivateKey;
import java.security.PublicKey;

@Data
@ConfigurationProperties(prefix = "ly.jwt")
public class JwtProperties {

    private String secret; // 密钥
    private String pubKeyPath;// 公钥地址
    private String priKeyPath;// 私钥地址
    private int expire;// token过期时间
    private String cookieName;

    private PublicKey publicKey; // 公钥
    private PrivateKey privateKey; // 私钥

    private static final Logger logger = LoggerFactory.getLogger(JwtProperties.class);

    // 对象一旦实例化后，就应该读取公钥和私钥
    @PostConstruct // 构造函数执行完毕后就执行
    public void init(){
        try {
            //公钥和私钥不存在  要先生成
            File pubKey = new File(pubKeyPath);
            File priKey = new File(priKeyPath);
            if (!pubKey.exists() || !priKey.exists()) {
                // 生成公钥和私钥
                RsaUtils.generateKey(pubKeyPath, priKeyPath, secret);
            }
            // 获取公钥和私钥
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
            this.privateKey = RsaUtils.getPrivateKey(priKeyPath);
        } catch (Exception e) {
            logger.error("初始化公钥和私钥失败！", e);
            throw new RuntimeException();
        }
    }

}

2.3.2 controller

编写授权接口，我们接收用户名和密码，校验成功后，写入cookie中。

请求方式：post
请求路径：/accredit
请求参数：username和password
返回结果：无

代码：

@RestController
@EnableConfigurationProperties(JwtProperties.class)
public class AuthController {

    @Autowired
    private AuthService authService;

    @Autowired
    private JwtProperties prop;

    @Value("${ly.jwt.cookieName}")
    private String cookieName;

    // 登录
    @PostMapping("login")
    public ResponseEntity<Void> login(
            @RequestParam("username") String username,
            @RequestParam("password") String password,
            HttpServletResponse response,
            HttpServletRequest request){

        // 登录功能的实现
        String token = authService.login(username, password);

        CookieUtils.newBuilder(response).httpOnly().request(request).build(cookieName, token);

        return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
    }
}

注：无需给前端浏览器返回token，token只有后端才需要使用，并且将token保存到cookie中

将token写入cookie — 工厂模式
httpOnly()：避免别的js代码来操作你的cookie，是一种安全措施
charset(): 不需要编码因为token中没有中文
maxAge()： cookie的生命周期，默认是-1，代表一次会话，浏览器关闭cookie就失效
response: 将cookie写入 — response中有一个方法 addCookie()
request: cookie中有域的概念 domain，不允许跨域，例如一个cookie只能在www.baidu.com生效，无法在别的域下生效，给cookie绑定一个域，防止别的网站访问你的cookie，也是一种安全措施

2.3.3 CookieUtils

要注意，这里我们使用了一个工具类：CookieUtils，我们把它添加到ly-common中，然后引入servlet相关依赖即可：

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
</dependency>

代码：略

/**
 * Cookie 工具类
 */
@Slf4j
public final class CookieUtils {

	/**
	 * 得到Cookie的值, 不编码
	 *
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName) {
		return getCookieValue(request, cookieName, null);
	}

	/**
	 * 得到Cookie的值,
	 *
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, String charset) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null) {
			return null;
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					if (charset != null && charset.length() > 0) {
						retValue = URLDecoder.decode(cookieList[i].getValue(), charset);
					} else {
						retValue = cookieList[i].getValue();
					}
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			log.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	public static CookieBuilder newBuilder(HttpServletResponse response) {
		return new CookieBuilder(response);
	}

	public static class CookieBuilder {
		private HttpServletRequest request;
		private HttpServletResponse response;
		private Integer maxAge;
		private String charset;
		private boolean httpOnly = false;

		public CookieBuilder(HttpServletResponse response) {
			this.response = response;
		}
		//防跨域访问
		public CookieBuilder request(HttpServletRequest request) {
			this.request = request;
			return this;
		}
		//最大生命周期
		public CookieBuilder maxAge(int maxAge) {
			this.maxAge = maxAge;
			return this;
		}
		//设置格式
		public CookieBuilder charset(String charset) {
			this.charset = charset;
			return this;
		}
		//禁用JS访问
		public CookieBuilder httpOnly() {
			this.httpOnly = true;
			return this;
		}
		//构建
		public void build(String cookieName, String cookieValue) {
			try {
				if (StringUtils.isBlank(charset)) {
					charset = "utf-8";
				}

				if (cookieValue == null) {
					cookieValue = "";
				} else if (StringUtils.isNotBlank(charset)) {
					cookieValue = URLEncoder.encode(cookieValue, charset);
				}
				Cookie cookie = new Cookie(cookieName, cookieValue);
				if (maxAge != null && maxAge > 0)
					cookie.setMaxAge(maxAge);
				if (null != request)// 设置域名的cookie
					//todo
					cookie.setDomain(getDomainName(request));
				cookie.setPath("/");

				cookie.setHttpOnly(httpOnly);
				response.addCookie(cookie);
			} catch (Exception e) {
				log.error("Cookie Encode Error.", e);
			}
		}

		/**
		 * 得到cookie的域名
		 */
		private String getDomainName(HttpServletRequest request) {
			String domainName = null;

			String serverName = request.getRequestURL().toString();
			if (serverName == null || serverName.equals("")) {
				domainName = "";
			} else {
				serverName = serverName.toLowerCase();
				serverName = serverName.substring(7);
				final int end = serverName.indexOf("/");
				serverName = serverName.substring(0, end);
				final String[] domains = serverName.split("\\.");
				int len = domains.length;
				if (len > 3) {
					// www.xxx.com.cn
					domainName = domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
				} else if (len <= 3 && len > 1) {
					// xxx.com or xxx.cn
					domainName = domains[len - 2] + "." + domains[len - 1];
				} else {
					domainName = serverName;
				}
			}

			if (domainName != null && domainName.indexOf(":") > 0) {
				String[] ary = domainName.split("\\:");
				domainName = ary[0];
			}
			return domainName;
		}
	}
}

2.3.4 UserClient

接下来我们肯定要对用户密码进行校验，所以我们需要通过FeignClient去访问 user-service微服务：

在ly-user-interface中编写接口 UserAPI：
在这里插入图片描述
编写FeignClient：

@FeignClient(value = "user-service")
public interface UserClient extends UserApi {
}

2.3.5 service

@Slf4j
@Service
@EnableConfigurationProperties(JwtProperties.class)
public class AuthService {

    @Autowired
    private UserClient userClient;

    @Autowired
    private JwtProperties prop;

    // 登录
    public String login(String username, String password) {

        try {
            // 校验用户名和密码
            User user = userClient.queryUsernameAndPassword(username, password);
            if (user == null) {
                throw new LyException(ExceptionEnum.INVALID_USERNAME_PASSWORD);
            }
            // 生成token
            String token = JwtUtils.generateToken(new UserInfo(user.getId(),username),prop.getPrivateKey(),prop.getExpire());
            return token;
        }catch (Exception e){
            log.error("[授权中心] 用户名或者密码有误，用户名称：{}", username, e);
            throw new LyException(ExceptionEnum.INVALID_USERNAME_PASSWORD);
        }
    }
}

2.3.6 测试

在这里插入图片描述
在页面上刷新，显示204登录成功

接下来我们查看首页cookie，却没有写入。

注：由于原因分析较复杂，且后续还有登录判断操作，因此分成两部分写。地址：鉴权微服务–后半部分

标签：公钥,服务,String,乐优,鉴权,token,return,私钥,public
来源： https://blog.csdn.net/qq_41649078/article/details/90749626

乐优商城--服务(九) ： 鉴权微服务--前半部分

鉴权微服务--前半部分

1. 无状态登录原理

1.1 什么是有状态？

1.2 什么是无状态

1.3 如何实现无状态

1.4 JWT

1.4.1 简介

1.4.2 数据格式

1.4.3 JWT交互流程

1.4.4 非对称加密

1.5 结合Zuul的鉴权流程

1.5.1 没有RSA加密时

1.5.2 结合RSA的鉴权

2. 授权中心

2.1 搭建项目

2.1.1 引入依赖

2.1.1.1 父工程ly-auth

2.1.1.2 ly-auth-common

2.1.1.3 ly-auth-service

2.1.2 配置

2.1.3 启动类

2.1.4 添加网关路由

2.2 编写JWT工具

2.2.1 RSA工具类

2.2.2 常量类

2.2.3 对象工具类：

2.2.4 载荷:UserInfo

2.2.5 JWT工具类

2.2.6 测试

2.2.6.1 测试生成公钥和私钥

2.2.6.2 测试生成token

2.2.6.3 测试解析token

2.3 编写登录授权接口

2.3.1 生成公钥和私钥

2.3.2 controller

2.3.3 CookieUtils

2.3.4 UserClient

2.3.5 service

2.3.6 测试

乐优商城--服务(九) ：鉴权微服务--前半部分