SpringSecurity在分布式环境下的使用流程分析_Java

参考

来源于黑马程序员：手把手教你精通新版springsecurity

分布式认证概念说明

分布式认证，即我们常说的单点登录，简称sso，指的是在多应用系统的项目中，用户只需要登录一次，就可以访问所有互相信任的应用系统。

分布式认证流程图

首先，我们要明确，在分布式项目中，每台服务器都有各自独立的session，而这些session之间是无法直接共享资源的，所以，session通常不能被作为单点登录的技术方案。最合理的单点登录方案流程如下图所示：

总结一下，单点登录的实现分两大环节：

**用户认证：**这一环节主要是用户向认证服务器发起认证请求，认证服务器给用户返回一个成功的令牌token，主要在认证服务器中完成，即图中的a系统，注意a系统只能有一个。
**身份校验：**这一环节是用户携带token去访问其他服务器时，在其他服务器中要对token的真伪进行检验，主要在资源服务器中完成，即图中的b系统，这里b系统可以有很多个。

jwt介绍

概念说明

从分布式认证流程中，我们不难发现，这中间起最关键作用的就是token，token的安全与否，直接关系到系统的健壮性，这里我们选择使用jwt来实现token的生成和校验。 jwt，全称json web token，官网地址https://jwt.io，是一款出色的分布式身份校验方案。可以生成token，也可以解析检验token。

jwt生成的token由三部分组成

头部：主要设置一些规范信息，签名部分的编码格式就在头部中声明。
载荷：token中存放有效信息的部分，比如用户名，用户角色，过期时间等，但是不要放密码，会泄露！
签名：将头部与载荷分别采用base64编码后，用“.”相连，再加入盐，最后使用头部声明的编码类型进行编码，就得到了签名。【通过随机盐在进行加密】

jwt生成token的安全性分析

从jwt生成的token组成上来看，要想避免token被伪造，主要就得看签名部分了，而签名部分又有三部分组成，其中头部和载荷的base64编码，几乎是透明的，毫无安全性可言，那么最终守护token安全的重担就落在了加入的盐上面了！

试想：如果生成token所用的盐与解析token时加入的盐是一样的。岂不是类似于中国人民银行把人民币防伪技术公开了？大家可以用这个盐来解析token，就能用来伪造token。这时，我们就需要对盐采用非对称加密的方式进行加密，以达到生成token与校验token方所用的盐不一致的安全效果！

非对称加密rsa介绍

**基本原理：**同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
私钥加密，持有私钥或公钥才可以解密
公钥加密，持有私钥才可解密
优点：安全，难以破解
缺点：算法比较耗时，为了安全，可以接受
历史：三位数学家rivest、shamir 和 adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：rsa。

【总结】：也就是说，我们加密信息的时候，使用的是公钥，而验证token真伪的时候，使用的是公钥

jwt相关工具类

jar包

<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-api</artifactid>
    <version>0.10.7</version>
</dependency>
<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-impl</artifactid>
    <version>0.10.7</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-jackson</artifactid>
    <version>0.10.7</version>
    <scope>runtime</scope>
</dependency>

载荷对象

/**
* 为了方便后期获取token中的用户信息，将token中载荷部分单独封装成一个对象
*/
@data
public class payload<t> {
}

jwt工具类

/**
 * 生成token以及校验token相关方法
 */
public class jwtutils {
    private static final string jwt_payload_user_key = "user";
    /**
     * 私钥加密token
     *
     * @param userinfo   载荷中的数据
     * @param privatekey 私钥
     * @param expire     过期时间，单位分钟
     * @return jwt
     */
    public static string generatetokenexpireinminutes(object userinfo, privatekey privatekey, int expire) {
        return jwts.builder()
                .claim(jwt_payload_user_key, jsonutils.tostring(userinfo))
                .setid(createjti())
                .setexpiration(datetime.now().plusminutes(expire).todate())
                .signwith(privatekey, signaturealgorithm.rs256)
                .compact();
    }
    /**
     * 私钥加密token
     *
     * @param userinfo   载荷中的数据
     * @param privatekey 私钥
     * @param expire     过期时间，单位秒
     * @return jwt
     */
    public static string generatetokenexpireinseconds(object userinfo, privatekey privatekey, int expire) {
        return jwts.builder()
                .claim(jwt_payload_user_key, jsonutils.tostring(userinfo))
                .setid(createjti())
                .setexpiration(datetime.now().plusseconds(expire).todate())
                .signwith(privatekey, signaturealgorithm.rs256)
                .compact();
    }
    /**
     * 公钥解析token
     *
     * @param token     用户请求中的token
     * @param publickey 公钥
     * @return jws<claims>
     */
    private static jws<claims> parsertoken(string token, publickey publickey) {
        return jwts.parser().setsigningkey(publickey).parseclaimsjws(token);
    }
    private static string createjti() {
        return new string(base64.getencoder().encode(uuid.randomuuid().tostring().getbytes()));
    }
    /**
     * 获取token中的用户信息
     *
     * @param token     用户请求中的令牌
     * @param publickey 公钥
     * @return 用户信息
     */
    public static <t> payload<t> getinfofromtoken(string token, publickey publickey, class<t> usertype) {
        jws<claims> claimsjws = parsertoken(token, publickey);
        claims body = claimsjws.getbody();
        payload<t> claims = new payload<>();
        claims.setid(body.getid());
        claims.setuserinfo(jsonutils.tobean(body.get(jwt_payload_user_key).tostring(), usertype));
        claims.setexpiration(body.getexpiration());
        return claims;
    }
    /**
     * 获取token中的载荷信息
     *
     * @param token     用户请求中的令牌
     * @param publickey 公钥
     * @return 用户信息
     */
    public static <t> payload<t> getinfofromtoken(string token, publickey publickey) {
        jws<claims> claimsjws = parsertoken(token, publickey);
        claims body = claimsjws.getbody();
        payload<t> claims = new payload<>();
        claims.setid(body.getid());
        claims.setexpiration(body.getexpiration());
        return claims;
    }
}

rsa工具类

非对称加密工具列

public class rsautils {
    private static final int default_key_size = 2048;
    /**
     * 从文件中读取公钥
     *
     * @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
     */
    private static publickey getpublickey(byte[] bytes) throws exception {
        bytes = base64.getdecoder().decode(bytes);
        x509encodedkeyspec spec = new x509encodedkeyspec(bytes);
        keyfactory factory = keyfactory.getinstance("rsa");
        return factory.generatepublic(spec);
    }
    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws exception
     */
    private static privatekey getprivatekey(byte[] bytes) throws nosuchalgorithmexception, invalidkeyspecexception {
        bytes = base64.getdecoder().decode(bytes);
        pkcs8encodedkeyspec spec = new pkcs8encodedkeyspec(bytes);
        keyfactory factory = keyfactory.getinstance("rsa");
        return factory.generateprivate(spec);
    }
    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publickeyfilename  公钥文件路径
     * @param privatekeyfilename 私钥文件路径
     * @param secret             生成密钥的密文
     */
    public static void generatekey(string publickeyfilename, string privatekeyfilename, string secret, int keysize) throws exception {
        keypairgenerator keypairgenerator = keypairgenerator.getinstance("rsa");
        securerandom securerandom = new securerandom(secret.getbytes());
        keypairgenerator.initialize(math.max(keysize, default_key_size), securerandom);
        keypair keypair = keypairgenerator.genkeypair();
        // 获取公钥并写出
        byte[] publickeybytes = keypair.getpublic().getencoded();
        publickeybytes = base64.getencoder().encode(publickeybytes);
        writefile(publickeyfilename, publickeybytes);
        // 获取私钥并写出
        byte[] privatekeybytes = keypair.getprivate().getencoded();
        privatekeybytes = base64.getencoder().encode(privatekeybytes);
        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);
    }
}

springsecurity+jwt+rsa分布式认证思路分析

springsecurity主要是通过过滤器来实现功能的！我们要找到springsecurity实现认证和校验身份的过滤器！回顾集中式认证流程

用户认证

使用usernamepasswordauthenticationfilter过滤器中attemptauthentication方法实现认证功能，该过滤器父类中successfulauthentication方法实现认证成功后的操作。

身份校验

使用basicauthenticationfilter过滤器中dofilterinternal方法验证是否登录，以决定能否进入后续过滤器。分析分布式认证流程

用户认证

由于，分布式项目，多数是前后端分离的架构设计，我们要满足可以接受异步post的认证请求参数，需要修改usernamepasswordauthenticationfilter过滤器中attemptauthentication方法，让其能够接收请求体。

另外，默认successfulauthentication方法在认证通过后，是把用户信息直接放入session就完事了，现在我们需要修改这个方法，在认证通过后生成token并返回给用户。

身份校验

原来basicauthenticationfilter过滤器中dofilterinternal方法校验用户是否登录，就是看session中是否有用户信息，我们要修改为，验证用户携带的token是否合法，并解析出用户信息，交给springsecurity，以便于后续的授权功能可以正常使用。

springsecurity+jwt+rsa分布式认证实现

创建父工程并导入jar包

<?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">
    <modelversion>4.0.0</modelversion>
    <groupid>com.itheima</groupid>
    <artifactid>springboot_security_jwt_rsa_parent</artifactid>
    <packaging>pom</packaging>
    <version>1.0-snapshot</version>
    <modules>
        <module>heima_common</module>
        <module>heima_auth_server</module>
        <module>heima_source_product</module>
    </modules>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.1.3.release</version>
        <relativepath/>
    </parent>
</project>

通用模块

创建通用子模块并导入jwt相关jar包

<?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>springboot_security_jwt_rsa_parent</artifactid>
        <groupid>com.itheima</groupid>
        <version>1.0-snapshot</version>
    </parent>
    <modelversion>4.0.0</modelversion>
    <artifactid>heima_common</artifactid>
    <dependencies>
        <dependency>
            <groupid>io.jsonwebtoken</groupid>
            <artifactid>jjwt-api</artifactid>
            <version>0.10.7</version>
        </dependency>
        <dependency>
            <groupid>io.jsonwebtoken</groupid>
            <artifactid>jjwt-impl</artifactid>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>io.jsonwebtoken</groupid>
            <artifactid>jjwt-jackson</artifactid>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <!--jackson包-->
        <dependency>
            <groupid>com.fasterxml.jackson.core</groupid>
            <artifactid>jackson-databind</artifactid>
            <version>2.9.9</version>
        </dependency>
        <!--日志包-->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-logging</artifactid>
        </dependency>
        <dependency>
            <groupid>joda-time</groupid>
            <artifactid>joda-time</artifactid>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
        </dependency>
    </dependencies>
</project>

导入工具类

工具类如下

payload.java

/**
 * 为了方便后期获取token中的用户信息，将token中载荷部分单独封装成一个对象
 */
@data
public class payload<t> {
    private string id;
    private t userinfo;
    private date expiration;
}

jsonutil.java

public class jsonutils {
    public static final objectmapper mapper = new objectmapper();
    private static final logger logger = loggerfactory.getlogger(jsonutils.class);
    public static string tostring(object obj) {
        if (obj == null) {
            return null;
        }
        if (obj.getclass() == string.class) {
            return (string) obj;
        }
        try {
            return mapper.writevalueasstring(obj);
        } catch (jsonprocessingexception e) {
            logger.error("json序列化出错：" + obj, e);
            return null;
        }
    }
    public static <t> t tobean(string json, class<t> tclass) {
        try {
            return mapper.readvalue(json, tclass);
        } catch (ioexception e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }
    public static <e> list<e> tolist(string json, class<e> eclass) {
        try {
            return mapper.readvalue(json, mapper.gettypefactory().constructcollectiontype(list.class, eclass));
        } catch (ioexception e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }
    public static <k, v> map<k, v> tomap(string json, class<k> kclass, class<v> vclass) {
        try {
            return mapper.readvalue(json, mapper.gettypefactory().constructmaptype(map.class, kclass, vclass));
        } catch (ioexception e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }
    public static <t> t nativeread(string json, typereference<t> type) {
        try {
            return mapper.readvalue(json, type);
        } catch (ioexception e) {
            logger.error("json解析出错：" + json, e);
            return null;
        }
    }
}

jwtuitls.java

public class jwtutils {
    private static final string jwt_payload_user_key = "user";
    /**
     * 私钥加密token
     *
     * @param userinfo   载荷中的数据
     * @param privatekey 私钥
     * @param expire     过期时间，单位分钟
     * @return jwt
     */
    public static string generatetokenexpireinminutes(object userinfo, privatekey privatekey, int expire) {
        return jwts.builder()
                .claim(jwt_payload_user_key, jsonutils.tostring(userinfo))
                .setid(createjti())
                .setexpiration(datetime.now().plusminutes(expire).todate())
                .signwith(privatekey, signaturealgorithm.rs256)
                .compact();
    }
    /**
     * 私钥加密token
     *
     * @param userinfo   载荷中的数据
     * @param privatekey 私钥
     * @param expire     过期时间，单位秒
     * @return jwt
     */
    public static string generatetokenexpireinseconds(object userinfo, privatekey privatekey, int expire) {
        return jwts.builder()
                .claim(jwt_payload_user_key, jsonutils.tostring(userinfo))
                .setid(createjti())
                .setexpiration(datetime.now().plusseconds(expire).todate())
                .signwith(privatekey, signaturealgorithm.rs256)
                .compact();
    }
    /**
     * 公钥解析token
     *
     * @param token     用户请求中的token
     * @param publickey 公钥
     * @return jws<claims>
     */
    private static jws<claims> parsertoken(string token, publickey publickey) {
        return jwts.parser().setsigningkey(publickey).parseclaimsjws(token);
    }
    private static string createjti() {
        return new string(base64.getencoder().encode(uuid.randomuuid().tostring().getbytes()));
    }
    /**
     * 获取token中的用户信息
     *
     * @param token     用户请求中的令牌
     * @param publickey 公钥
     * @return 用户信息
     */
    public static <t> payload<t> getinfofromtoken(string token, publickey publickey, class<t> usertype) {
        jws<claims> claimsjws = parsertoken(token, publickey);
        claims body = claimsjws.getbody();
        payload<t> claims = new payload<>();
        claims.setid(body.getid());
        claims.setuserinfo(jsonutils.tobean(body.get(jwt_payload_user_key).tostring(), usertype));
        claims.setexpiration(body.getexpiration());
        return claims;
    }
    /**
     * 获取token中的载荷信息
     *
     * @param token     用户请求中的令牌
     * @param publickey 公钥
     * @return 用户信息
     */
    public static <t> payload<t> getinfofromtoken(string token, publickey publickey) {
        jws<claims> claimsjws = parsertoken(token, publickey);
        claims body = claimsjws.getbody();
        payload<t> claims = new payload<>();
        claims.setid(body.getid());
        claims.setexpiration(body.getexpiration());
        return claims;
    }
}

rsautils.java

public class rsautils {
    private static final int default_key_size = 2048;
    /**
     * 从文件中读取公钥
     *
     * @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
     */
    private static publickey getpublickey(byte[] bytes) throws exception {
        bytes = base64.getdecoder().decode(bytes);
        x509encodedkeyspec spec = new x509encodedkeyspec(bytes);
        keyfactory factory = keyfactory.getinstance("rsa");
        return factory.generatepublic(spec);
    }
    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws exception
     */
    private static privatekey getprivatekey(byte[] bytes) throws nosuchalgorithmexception, invalidkeyspecexception {
        bytes = base64.getdecoder().decode(bytes);
        pkcs8encodedkeyspec spec = new pkcs8encodedkeyspec(bytes);
        keyfactory factory = keyfactory.getinstance("rsa");
        return factory.generateprivate(spec);
    }
    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publickeyfilename  公钥文件路径
     * @param privatekeyfilename 私钥文件路径
     * @param secret             生成密钥的密文
     */
    public static void generatekey(string publickeyfilename, string privatekeyfilename, string secret, int keysize) throws exception {
        keypairgenerator keypairgenerator = keypairgenerator.getinstance("rsa");
        securerandom securerandom = new securerandom(secret.getbytes());
        keypairgenerator.initialize(math.max(keysize, default_key_size), securerandom);
        keypair keypair = keypairgenerator.genkeypair();
        // 获取公钥并写出
        byte[] publickeybytes = keypair.getpublic().getencoded();
        publickeybytes = base64.getencoder().encode(publickeybytes);
        writefile(publickeyfilename, publickeybytes);
        // 获取私钥并写出
        byte[] privatekeybytes = keypair.getprivate().getencoded();
        privatekeybytes = base64.getencoder().encode(privatekeybytes);
        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);
    }
}

在通用子模块中编写测试类生成rsa公钥和私钥

public class rsautilstest {
    private string publicfile = "d:\\auth_key\\rsa_key.pub";
    private string privatefile = "d:\\auth_key\\rsa_key";
    @test
    public void generatekey() throws exception {
    	rsautils.generatekey(publicfile, privatefile, "heima", 2048);
    }
}

执行后查看d:\auth_key目录发现私钥和公钥文件生成成功

认证服务

创建认证服务工程并导入jar包

<?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>springboot_security_jwt_rsa_parent</artifactid>
        <groupid>com.itheima</groupid>
        <version>1.0-snapshot</version>
    </parent>
    <modelversion>4.0.0</modelversion>
    <artifactid>heima_auth_server</artifactid>
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-security</artifactid>
        </dependency>
        <dependency>
            <groupid>com.itheima</groupid>
            <artifactid>heima_common</artifactid>
            <version>1.0-snapshot</version>
        </dependency>
        <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>
    </dependencies>
</project>

创建认证服务配置文件

server:
  port: 9001
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.driver
    url: jdbc:mysql:///security_authority
    username: root
    password: root
mybatis:
  type-aliases-package: com.itheima.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    com.itheima: debug
rsa:
  key:
    pubkeyfile: d:\auth_key\id_key_rsa.pub
    prikeyfile: d:\auth_key\id_key_rsa

提供解析公钥和私钥的配置类

@data
@configurationproperties(prefix = "heima.key")
public class rsakeyproperties {
    private string pubkeypath;
    private string prikeypath;
    private publickey publickey;
    private privatekey privatekey;
    @postconstruct
    public void loadkey() throws exception {
        publickey = rsautils.getpublickey(pubkeypath);
        privatekey = rsautils.getprivatekey(prikeypath);
    }
}

创建认证服务启动类

@springbootapplication
@mapperscan("com.itheima.mapper")
@enableconfigurationproperties(rsakeyproperties.class)
public class authapplication {
    public static void main(string[] args) {
    	springapplication.run(authapplication.class, args);
    }
}

将上面集中式案例中数据库认证相关代码复制到认证服务中

需要复制的代码如果所示：

注意这里要去掉mapper中继承的通用mapper接口，处理器类上换成@restcontroller，这里前后端绝对分离，不能再跳转页面了，要返回数据。

public class jwtloginfilter extends usernamepasswordauthenticationfilter {
    private authenticationmanager authenticationmanager;
    private rsakeyproperties prop;
    public jwtloginfilter(authenticationmanager authenticationmanager, rsakeyproperties prop) {
        this.authenticationmanager = authenticationmanager;
        this.prop = prop;
    }
    public authentication attemptauthentication(httpservletrequest request, httpservletresponse response) throws authenticationexception {
        try {
            sysuser sysuser = new objectmapper().readvalue(request.getinputstream(), sysuser.class);
            usernamepasswordauthenticationtoken authrequest = new usernamepasswordauthenticationtoken(sysuser.getusername(), sysuser.getpassword());
            return authenticationmanager.authenticate(authrequest);
        }catch (exception e){
            try {
                response.setcontenttype("application/json;charset=utf-8");
                response.setstatus(httpservletresponse.sc_unauthorized);
                printwriter out = response.getwriter();
                map resultmap = new hashmap();
                resultmap.put("code", httpservletresponse.sc_unauthorized);
                resultmap.put("msg", "用户名或密码错误！");
                out.write(new objectmapper().writevalueasstring(resultmap));
                out.flush();
                out.close();
            }catch (exception outex){
                outex.printstacktrace();
            }
            throw new runtimeexception(e);
        }
    }
    public void successfulauthentication(httpservletrequest request, httpservletresponse response, filterchain chain, authentication authresult) throws ioexception, servletexception {
        sysuser user = new sysuser();
        user.setusername(authresult.getname());
        user.setroles((list<sysrole>) authresult.getauthorities());
        string token = jwtutils.generatetokenexpireinminutes(user, prop.getprivatekey(), 24 * 60);
        response.addheader("authorization", "bearer "+token);
        try {
            response.setcontenttype("application/json;charset=utf-8");
            response.setstatus(httpservletresponse.sc_ok);
            printwriter out = response.getwriter();
            map resultmap = new hashmap();
            resultmap.put("code", httpservletresponse.sc_ok);
            resultmap.put("msg", "认证通过！");
            out.write(new objectmapper().writevalueasstring(resultmap));
            out.flush();
            out.close();
        }catch (exception outex){
            outex.printstacktrace();
        }
    }
}

编写检验token过滤器

public class jwtverifyfilter extends basicauthenticationfilter {
    private rsakeyproperties prop;
    public jwtverifyfilter(authenticationmanager authenticationmanager, rsakeyproperties prop) {
        super(authenticationmanager);
        this.prop = prop;
    }
    public void dofilterinternal(httpservletrequest request, httpservletresponse response, filterchain chain) throws ioexception, servletexception {
        string header = request.getheader("authorization");
        if (header == null || !header.startswith("bearer ")) {
            //如果携带错误的token，则给用户提示请登录！
            chain.dofilter(request, response);
            response.setcontenttype("application/json;charset=utf-8");
            response.setstatus(httpservletresponse.sc_forbidden);
            printwriter out = response.getwriter();
            map resultmap = new hashmap();
            resultmap.put("code", httpservletresponse.sc_forbidden);
            resultmap.put("msg", "请登录！");
            out.write(new objectmapper().writevalueasstring(resultmap));
            out.flush();
            out.close();
        } else {
            //如果携带了正确格式的token要先得到token
            string token = header.replace("bearer ", "");
            //验证tken是否正确
            payload<sysuser> payload = jwtutils.getinfofromtoken(token, prop.getpublickey(), sysuser.class);
            sysuser user = payload.getuserinfo();
            if(user!=null){
                usernamepasswordauthenticationtoken authresult = new usernamepasswordauthenticationtoken(user.getusername(), null, user.getauthorities());
                securitycontextholder.getcontext().setauthentication(authresult);
                chain.dofilter(request, response);
            }
        }
    }
}

编写springsecurity配置类

@configuration
@enablewebsecurity
@enableglobalmethodsecurity(securedenabled=true)
public class websecurityconfig extends websecurityconfigureradapter {
    @autowired
    private userservice userservice;
    @autowired
    private rsakeyproperties prop;
    @bean
    public bcryptpasswordencoder passwordencoder(){
        return new bcryptpasswordencoder();
    }
    //指定认证对象的来源
    public void configure(authenticationmanagerbuilder auth) throws exception {
        auth.userdetailsservice(userservice).passwordencoder(passwordencoder());
    }
    //springsecurity配置信息
    public void configure(httpsecurity http) throws exception {
        http.csrf()
            .disable()
            .authorizerequests()
            .antmatchers("/product").hasanyrole("user")
            .anyrequest()
            .authenticated()
            .and()
            .addfilter(new jwtloginfilter(super.authenticationmanager(), prop))
            .addfilter(new jwtverifyfilter(super.authenticationmanager(), prop))
            .sessionmanagement().sessioncreationpolicy(sessioncreationpolicy.stateless);
    }
}

启动测试认证服务

认证请求

认证通过结果

token在headers中：

验证认证请求

资源服务

说明

资源服务可以有很多个，这里只拿产品服务为例，记住，资源服务中只能通过公钥验证认证。不能签发token！

创建产品服务并导入jar包

根据实际业务导包即可，咱们就暂时和认证服务一样了。

<?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>springboot_security_jwt_rsa_parent</artifactid>
        <groupid>com.itheima</groupid>
        <version>1.0-snapshot</version>
    </parent>
    <modelversion>4.0.0</modelversion>
    <artifactid>heima_source_product</artifactid>
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-security</artifactid>
        </dependency>
        <dependency>
            <groupid>com.itheima</groupid>
            <artifactid>heima_common</artifactid>
            <version>1.0-snapshot</version>
        </dependency>
        <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>
    </dependencies>
</project>

编写产品服务配置文件

切记这里只能有公钥地址！

server:
  port: 9002
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.driver
    url: jdbc:mysql:///security_authority
    username: root
    password: root
mybatis:
  type-aliases-package: com.itheima.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    com.itheima: debug
rsa:
  key:
    pubkeyfile: d:\auth_key\id_key_rsa.pub

编写读取公钥的配置类

@configurationproperties("rsa.key")
public class rsakeyproperties {
    private string pubkeyfile;
    private publickey publickey;
    @postconstruct
    public void creatersakey() throws exception {
        publickey = rsautils.getpublickey(pubkeyfile);
    }
    public string getpubkeyfile() {
        return pubkeyfile;
    }
    public void setpubkeyfile(string pubkeyfile) {
        this.pubkeyfile = pubkeyfile;
    }
    public publickey getpublickey() {
        return publickey;
    }
    public void setpublickey(publickey publickey) {
        this.publickey = publickey;
    }
}

编写启动类

@springbootapplication
@mapperscan("com.itheima.mapper")
@enableconfigurationproperties(rsakeyproperties.class)
public class authsourceapplication {
    public static void main(string[] args) {
        springapplication.run(authsourceapplication.class, args);
    }
}

复制认证服务中，用户对象，角色对象和校验认证的接口

这时目录结构如图：

复制认证服务中springsecurity配置类做修改，去掉“增加自定义认证过滤器”即可！

@configuration
@enablewebsecurity
@enableglobalmethodsecurity(securedenabled=true)
public class websecurityconfig extends websecurityconfigureradapter {
    @autowired
    private rsakeyproperties prop;
    //springsecurity配置信息
    public void configure(httpsecurity http) throws exception {
        http.csrf()
            .disable()
            .authorizerequests()
            .antmatchers("/product").hasanyrole("user")
            .anyrequest()
            .authenticated()
            .and()
            .addfilter(new jwtverifyfilter(super.authenticationmanager(), prop))
            .sessionmanagement().sessioncreationpolicy(sessioncreationpolicy.stateless);
    }
}

编写产品处理器

@restcontroller
@requestmapping("/product")
public class productcontroller {
    @getmapping
    public string findall(){
    	return "产品测试成功！";
    }
}

启动产品服务做测试

携带token

在产品处理器上添加访问需要admin角色

@restcontroller
@requestmapping("/product")
public class productcontroller {
    @secured("role_admin")
    @getmapping
    public string findall(){
    	return "产品测试成功！";
    }
}

重启测试权限不足

在数据库中手动给用户添加admin角色

重新认证获取新token再测试ok了！

到此这篇关于springsecurity在分布式环境下的使用的文章就介绍到这了,更多相关springsecurity分布式内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！


验证码：

SpringSecurity在分布式环境下的使用流程分析

2025年02月17日 • Java •我要评论

分布式认证概念说明

分布式认证流程图

jwt介绍

概念说明

jwt生成的token由三部分组成

jwt生成token的安全性分析

非对称加密rsa介绍

jwt相关工具类

jar包

载荷对象

jwt工具类

rsa工具类

springsecurity+jwt+rsa分布式认证思路分析

用户认证

身份校验

用户认证

身份校验

springsecurity+jwt+rsa分布式认证实现

创建父工程并导入jar包

通用模块

导入工具类

payload.java

jsonutil.java

jwtuitls.java

rsautils.java

认证服务

创建认证服务工程并导入jar包

创建认证服务配置文件

提供解析公钥和私钥的配置类

创建认证服务启动类

将上面集中式案例中数据库认证相关代码复制到认证服务中

编写检验token过滤器

编写springsecurity配置类

启动测试认证服务

认证请求

认证通过结果

验证认证请求

资源服务

说明

创建产品服务并导入jar包

编写产品服务配置文件

编写读取公钥的配置类

编写启动类

复制认证服务中，用户对象，角色对象和校验认证的接口

编写产品处理器

启动产品服务做测试

相关文章:

MyBatis-Plus实用篇超完整教程

发表评论