在本文中，我们将探讨如何将 spring security 与 jwt 集成，为您的应用程序构建坚实的安全层。我们将完成从基本配置到实现自定义身份验证过滤器的每个步骤，确保您拥有必要的工具来高效、大规模地保护您的 api。

配置

在 spring initializr 中，我们将使用 java 21、maven、jar 和这些依赖项构建一个项目：

spring 数据 jpa
春天网
龙目岛
春季安全
postgresql 驱动程序
oauth2 资源服务器

设置 postgresql 数据库

使用 docker，您将使用 docker-compose 创建一个 postgresql 数据库。
在项目的根目录创建一个 docker-compose.yaml 文件。

services:
postgre:
image: postgres:latest
ports:

• "5432:5432"
  environment:
• postgres_db=database
• postgres_user=admin
• postgres_password=admin
  volumes:
• postgres_data:/var/lib/postgresql/data

volumes:
postgres_data:

登录后复制

运行命令启动容器。

docker compose up -d
登录后复制

设置 application.properties 文件

这个文件是spring boot应用程序的配置。

spring.datasource.url=jdbc:postgresql://localhost:5432/database
spring.datasource.username=admin
spring.datasource.password=admin

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

jwt.public.key=classpath:public.key
jwt.private.key=classpath:private.key
登录后复制

jwt.public.key 和 jwt.private.key 是我们将进一步创建的密钥。

生成私钥和公钥

永远不要将这些密钥提交到你的github
点击下载“电脑DLL/驱动修复工具”；

在控制台运行，在资源目录下生成私钥

cd src/main/resources
openssl genrsa > private.key
登录后复制

之后，创建链接到私钥的公钥。

openssl rsa -in private.key -pubout -out public.key
登录后复制

代码

创建安全配置文件

靠近主函数创建一个目录 configs 并在其中创建一个 securityconfig.java 文件。

import java.security.interfaces.rsaprivatekey;
import java.security.interfaces.rsapublickey;

import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.http.httpmethod;
import org.springframework.security.config.annotation.web.builders.httpsecurity;
import org.springframework.security.config.annotation.web.configuration.enablewebsecurity;
import org.springframework.security.crypto.bcrypt.bcryptpasswordencoder;
import org.springframework.security.oauth2.jwt.jwtdecoder;
import org.springframework.security.oauth2.jwt.jwtencoder;
import org.springframework.security.oauth2.jwt.nimbusjwtdecoder;
import org.springframework.security.oauth2.jwt.nimbusjwtencoder;
import org.springframework.security.web.securityfilterchain;

import com.nimbusds.jose.jwk.jwkset;
import com.nimbusds.jose.jwk.rsakey;
import com.nimbusds.jose.jwk.source.immutablejwkset;

@configuration
@enablewebsecurity
@enablemethodsecurity
public class securityconfig {

@value("${jwt.public.key}")
private rsapublickey publickey;

@value("${jwt.private.key}")
private rsaprivatekey privatekey;

@bean
securityfilterchain securityfilterchain(httpsecurity http) throws exception {
    http
            .csrf(csrf -> csrf.disable())
            .authorizehttprequests(auth -> auth.requestmatchers(httpmethod.post, "/signin").permitall()
                    .requestmatchers(httpmethod.post, "/login").permitall()
                    .anyrequest().authenticated())
            .oauth2resourceserver(config -> config.jwt(jwt -> jwt.decoder(jwtdecoder())));

    return http.build();
}

@bean
bcryptpasswordencoder bpasswordencoder() {
    return new bcryptpasswordencoder();
}

@bean
jwtencoder jwtencoder() {
    var jwk = new rsakey.builder(this.publickey).privatekey(this.privatekey).build();

    var jwks = new immutablejwkset(new jwkset(jwk));

    return new nimbusjwtencoder(jwks);
}

@bean
jwtdecoder jwtdecoder() {
    return nimbusjwtdecoder.withpublickey(publickey).build();
}

}
登录后复制

解释

@enablewebscurity：当您使用@enablewebsecurity时，它会自动触发spring security的配置以保护web应用程序。此配置包括设置过滤器、保护端点以及应用各种安全规则。

@enablemethodsecurity：是 spring security 中的一个注释，可在 spring 应用程序中启用方法级安全性。它允许您使用 @preauthorize、@postauthorize、@secured 和 @rolesallowed 等注释直接在方法级别应用安全规则。

privatekey 和 publickey：是用于签名和验证 jwt 的 rsa 公钥和私钥。 @value 注解将属性文件（application.properties）中的键注入到这些字段中。

csrf：禁用 csrf（跨站请求伪造）保护，该保护通常在使用 jwt 进行身份验证的无状态 rest api 中禁用。

authorizehttprequests：配置基于url的授权规则。

requestmatchers(httpmethod.post, "/signin").permitall()：允许未经身份验证访问 /signin 和 /login 端点，这意味着任何人都可以在不登录的情况下访问这些路由。

anyrequest().authenticated()：需要对所有其他请求进行身份验证。

oauth2resourceserver：将应用程序配置为使用 jwt 进行身份验证的 oauth 2.0 资源服务器。

config.jwt(jwt -> jwt.decoder(jwtdecoder()))：指定将用于解码和验证 jwt 令牌的 jwt 解码器 bean (jwtdecoder)。

bcryptpasswordencoder：这个bean定义了一个密码编码器，它使用bcrypt哈希算法对密码进行编码。 bcrypt 因其自适应特性而成为安全存储密码的热门选择，使其能够抵抗暴力攻击。

jwtencoder：这个bean负责编码（签名）jwt令牌。

rsakey.builder：使用提供的公钥和私钥 rsa 密钥创建新的 rsa 密钥。

immutablejwkset(new jwkset(jwk))：将 rsa 密钥包装在 json web 密钥集 (jwkset) 中，使其不可变。

nimbusjwtencoder(jwks)：使用 nimbus 库创建 jwt 编码器，该编码器将使用 rsa 私钥对令牌进行签名。

jwtdecoder：这个bean负责解码（验证）jwt令牌。

nimbusjwtdecoder.withpublickey(publickey).build()：使用rsa公钥创建jwt解码器，用于验证jwt令牌的签名。

实体

import org.springframework.security.crypto.password.passwordencoder;

import jakarta.persistence.column;
import jakarta.persistence.entity;
import jakarta.persistence.enumtype;
import jakarta.persistence.enumerated;
import jakarta.persistence.generatedvalue;
import jakarta.persistence.generationtype;
import jakarta.persistence.id;
import jakarta.persistence.table;
import lombok.getter;
import lombok.noargsconstructor;
import lombok.setter;

@entity
@table(name = "tb_clients")
@getter
@setter
@noargsconstructor
public class cliententity {

@id
@generatedvalue(strategy = generationtype.sequence)
@column(name = "client_id")
private long clientid;

private string name;

@column(unique = true)
private string cpf;

@column(unique = true)
private string email;

private string password;

@column(name = "user_type")
private string usertype = "client";

public boolean islogincorrect(string password, passwordencoder passwordencoder) {
    return passwordencoder.matches(password, this.password);
}

}
登录后复制

存储库

import java.util.optional;

import org.springframework.data.jpa.repository.jparepository;
import org.springframework.stereotype.repository;

import example.com.challengepicpay.entities.cliententity;

@repository
public interface clientrepository extends jparepository {
optional findbyemail(string email);

optional<cliententity> findbycpf(string cpf);

optional<cliententity> findbyemailorcpf(string email, string cpf);

}
登录后复制

服务

客户服务

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.http.httpstatus;
import org.springframework.security.crypto.bcrypt.bcryptpasswordencoder;
import org.springframework.stereotype.service;
import org.springframework.web.server.responsestatusexception;

import example.com.challengepicpay.entities.cliententity;
import example.com.challengepicpay.repositories.clientrepository;

@service
public class clientservice {

@autowired
private clientrepository clientrepository;

@autowired
private bcryptpasswordencoder bpasswordencoder;

public cliententity createclient(string name, string cpf, string email, string password) {

    var clientexists = this.clientrepository.findbyemailorcpf(email, cpf);

    if (clientexists.ispresent()) {
        throw new responsestatusexception(httpstatus.bad_request, "email/cpf already exists.");
    }

    var newclient = new cliententity();

    newclient.setname(name);
    newclient.setcpf(cpf);
    newclient.setemail(email);
    newclient.setpassword(bpasswordencoder.encode(password));

    return clientrepository.save(newclient);
}

}
登录后复制

代币服务

import java.time.instant;

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.http.httpstatus;
import org.springframework.security.authentication.badcredentialsexception;
import org.springframework.security.crypto.bcrypt.bcryptpasswordencoder;
import org.springframework.security.oauth2.jwt.jwtclaimsset;
import org.springframework.security.oauth2.jwt.jwtencoder;
import org.springframework.security.oauth2.jwt.jwtencoderparameters;
import org.springframework.stereotype.service;
import org.springframework.web.server.responsestatusexception;

import example.com.challengepicpay.repositories.clientrepository;

@service
public class tokenservice {

@autowired
private clientrepository clientrepository;

@autowired
private jwtencoder jwtencoder;

@autowired
private bcryptpasswordencoder bcryptpasswordencoder;

public string login(string email, string password) {

    var client = this.clientrepository.findbyemail(email)
            .orelsethrow(() -> new responsestatusexception(httpstatus.bad_request, "email not found"));

    var iscorrect = client.islogincorrect(password, bcryptpasswordencoder);

    if (!iscorrect) {
        throw new badcredentialsexception("email/password invalid");
    }

    var now = instant.now();
    var expiresin = 300l;

    var claims = jwtclaimsset.builder()
            .issuer("pic_pay_backend")
            .subject(client.getemail())
            .issuedat(now)
            .expiresat(now.plusseconds(expiresin))
            .claim("scope", client.getusertype())
            .build();

    var jwtvalue = jwtencoder.encode(jwtencoderparameters.from(claims)).gettokenvalue();

    return jwtvalue;

}

}
登录后复制

控制器

客户端控制器

package example.com.challengepicpay.controllers;

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.http.httpstatus;
import org.springframework.http.responseentity;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestbody;
import org.springframework.web.bind.annotation.restcontroller;
import org.springframework.security.oauth2.server.resource.authentication.jwtauthenticationtoken;
import example.com.challengepicpay.controllers.dto.newclientdto;
import example.com.challengepicpay.entities.cliententity;
import example.com.challengepicpay.services.clientservice;

@restcontroller
public class clientcontroller {

@autowired
private clientservice clientservice;

@postmapping("/signin")
public responseentity<cliententity> createnewclient(@requestbody newclientdto client) {
    var newclient = this.clientservice.createclient(client.name(), client.cpf(), client.email(), client.password());

    return responseentity.status(httpstatus.created).body(newclient);
}

@getmapping("/protectedroute")
@preauthorize("hasauthority('scope_client')")
public responseentity<string> protectedroute(jwtauthenticationtoken token) {
    return responseentity.ok("authorized");
}

}
登录后复制

解释

/protectedroute 是私有路由，登录后只能使用 jwt 访问。

例如，令牌必须作为不记名令牌包含在标头中。

您可以稍后在应用程序中使用令牌信息，例如在服务层中。

@preauthorize：spring security中的@preauthorize注解用于在调用方法之前执行授权检查。此注释通常应用于 spring 组件（如控制器或服务）中的方法级别，以根据用户的角色、权限或其他安全相关条件来限制访问。
注解用于定义方法执行必须满足的条件。如果条件评估为真，则该方法继续进行。如果评估结果为 false，则访问被拒绝，

"hasauthority('scope_client')"：检查当前经过身份验证的用户或客户端是否具有特定权限 scope_client。如果这样做，则执行 protectedroute() 方法。如果不这样做，访问将被拒绝。

token controller：在这里，你可以登录应用程序，如果成功，会返回一个token。

package example.com.challengePicPay.controllers;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;

import example.com.challengePicPay.controllers.dto.LoginDTO;
import example.com.challengePicPay.services.TokenService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@RestController
public class TokenController {

@Autowired
private TokenService tokenService;

@PostMapping("/login")
public ResponseEntity<map string>&gt; login(@RequestBody LoginDTO loginDTO) {
    var token = this.tokenService.login(loginDTO.email(), loginDTO.password());

    return ResponseEntity.ok(Map.of("token", token));
}

}
登录后复制

参考

春季安全
spring security-toptal 文章

      以上就是Spring Security 与 JWT的详细内容，更多请关注php中文网其它相关文章！