기술나눔

SpringSecurity 프레임워크 [인증]

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

목차

1. 빠른 시작

2. 인증

2.1 로그인 인증 절차

2.2 원리의 예비 탐구

2.3 문제 해결

2.3.1 아이디어 분석

2.3.2 준비

2.3.3 구현

2.3.3.1 데이터베이스 검증 사용자

2.3.3.2 비밀번호 암호화 저장

2.3.3.3 로그인 인터페이스

2.3.3.4 인증 필터

2.3.3.5 로그아웃

Spring Security는 Spring 계열의 보안 관리 프레임워크로, 또 다른 보안 프레임워크인 Shiro에 비해 Shiro보다 풍부한 기능과 풍부한 커뮤니티 리소스를 제공합니다.

일반적으로 Spring Security는 대규모 프로젝트에서 더 일반적으로 사용되며 Shiro는 소규모 프로젝트에서 더 일반적으로 사용됩니다. 왜냐하면 Spring Security에 비해 Shiro가 시작하기 더 쉽기 때문입니다.

일반 웹 애플리케이션에는 다음이 필요합니다.인증그리고승인하다。

  • 인증: 현재 시스템에 접속하고 있는 사용자가 시스템 사용자인지 확인하고, 어떤 사용자인지 확인합니다.
  • 권한 부여: 인증 후 현재 사용자에게 작업 수행 권한이 있는지 확인

인증과 권한 부여는 보안 프레임워크로서 Spring Security의 핵심 기능입니다!

1. 빠른 시작

먼저 SpringBoot 프로젝트를 간단히 빌드해 보겠습니다.

이때 구축 성공 여부를 확인하기 위해 작성한 간단한 hello 인터페이스에 접근합니다.

그런 다음 SpringSecurity를 ​​소개합니다.

이번에는 접속 인터페이스의 효과를 살펴보겠습니다.

SpringSecurity가 도입된 후, 액세스 인터페이스는 자동으로 로그인 페이지로 이동합니다. 기본 사용자 이름은 user이며, 인터페이스에 액세스하려면 로그인해야 합니다.

2. 인증

2.1 로그인 인증 절차

먼저, 로그인 확인 프로세스를 이해해야 합니다. 먼저 프런트 엔드는 로그인 인터페이스에 액세스하기 위해 사용자 이름과 비밀번호를 전달합니다. 서버는 사용자 이름과 비밀번호를 얻은 후 이를 데이터베이스에 있는 것과 비교합니다. 사용자 이름/사용자 ID가 올바르게 사용되면 jwt가 생성되고 jwt를 프런트 엔드에 응답한 다음 로그인 후 다른 요청에 액세스하면 서버가 토큰을 얻을 때마다 요청 헤더에 토큰이 전달됩니다. 파싱을 위한 요청 헤더를 파싱하고, UserID를 획득하고, 사용자 이름 ID를 기반으로 사용자 관련 정보 및 뷰어 권한을 획득하고, 권한이 있는 경우 프런트엔드에 응답합니다.

2.2 원리의 예비 탐구

SpringSecurity의 원리는 실제로 다양한 기능을 가진 필터를 제공하는 필터 체인입니다. 여기서는 먼저 위의 빠른 시작과 관련된 필터를 살펴봅니다.

  • UsernamePasswordAuthenticationFilter는 로그인 페이지에 사용자 이름과 비밀번호를 입력한 후 로그인 요청을 처리하는 역할을 담당합니다.
  • ExceptionTranslationFilter는 필터 체인에서 발생한 모든 AccessDeniedException 및 AuthenticationException을 처리합니다.
  • FilterSecurityInterceptor는 권한 확인을 담당하는 필터입니다.

또한 디버그를 사용하여 현재 시스템의 SpringSecurity 필터 체인에 어떤 필터가 있는지와 그 순서를 확인할 수 있습니다.

다음으로 인증 흐름도 분석을 살펴보겠습니다.

여기서는 프로세스를 간단히 이해하면 됩니다.

사용자가 사용자 이름과 비밀번호를 제출하면 UsernamePasswordAuthenticationFilter는 이를 Authentication 객체로 캡슐화하고 인증을 위한 authenticate 메서드를 호출합니다. 그런 다음 인증을 위해 DaoAuthenticationProvider의 authenticate 메서드를 호출한 다음 loadUserByUserName 메서드를 호출하여 사용자에게 쿼리합니다. 메모리에서 검색한 다음 해당 사용자 정보를 UserDetails 개체에 캡슐화하고 PasswordEncoder를 사용하여 UserDetails의 비밀번호와 인증 비밀번호를 비교하여 올바른지 확인하는 것입니다. 올바른 경우 UserDetails의 권한 정보를 Authentication 개체에 설정합니다. 그런 다음 Authentication 객체를 반환하고 마지막으로 SecurityContextHolder.getContext()를 사용합니다. setAuthentication 메소드를 사용하여 이 객체를 저장하고 다른 필터는 SecurityContextHoder를 통해 현재 사용자 정보를 얻습니다. (이 문단을 이해하기 위해 외울 필요는 없습니다)

그런 다음 수정하기 전에 프로세스를 알고 있습니다. 먼저 메모리에서 검색할 때 데이터베이스에서 검색해야 하며(여기서는 UserDetailsService 구현 클래스를 사용자 정의해야 함) 기본 사용자 이름과 비밀번호를 사용하지 않습니다. , 로그인 인터페이스는 직접 작성해야 하며, 그가 제공한 기본 로그인 페이지를 사용할 필요가 없습니다.

우리가 분석한 상황을 바탕으로 이런 그림을 얻을 수 있다.

이때 jwt는 프론트 엔드로 반환되며 프론트 엔드에서 수행한 다른 요청은 토큰을 전달하므로 첫 번째 단계는 토큰이 전달되었는지 확인하고 토큰을 구문 분석하고 해당 사용자 ID를 얻은 후 캡슐화하는 것입니다. Anthentication 객체는 SecurityContextHolder에 저장됩니다(다른 필터가 이를 얻을 수 있도록).

그렇다면 여기에 또 다른 질문이 있습니다. jwt 인증 필터에서 사용자 ID를 가져온 후 완전한 사용자 정보를 얻는 방법은 무엇입니까?

여기서는 서버가 사용자 ID를 사용하여 프런트엔드에 jwt를 생성하여 인증할 때 사용자 ID가 키로 사용되고 사용자 정보가 값으로 Redis에 저장됩니다. redis에서 userid를 통해.

2.3 문제 해결

2.3.1 아이디어 분석

위의 원칙에 대한 사전 탐색을 통해 프런트엔드와 백엔드 분리 인증 프로세스를 직접 구현하는 경우 수행해야 할 작업을 대략적으로 분석했습니다.

로그인:

a. 사용자 정의 로그인 인터페이스

인증을 위해 ProviderManager 메소드를 호출합니다. 인증이 통과되면 jwt가 생성됩니다.

Redis에 사용자 정보 저장

b. UserDetailsService 사용자 정의

이 구현 클래스에서 데이터베이스를 쿼리합니다.

확인하다:

a. jwt 인증 필터를 사용자 정의합니다.

토큰 받기

토큰을 구문 분석하여 사용자 ID를 얻습니다.

Redis에서 완전한 사용자 정보 얻기

SecurityContextHolder에 저장

2.3.2 준비

먼저 해당 종속성을 추가해야 합니다.

  1.         <!--   SpringSecurity启动器     -->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-security</artifactId>
  5.         </dependency>
  6.  
  7.         <!--   redis依赖     -->
  8.         <dependency>
  9.             <groupId>org.springframework.boot</groupId>
  10.             <artifactId>spring-boot-starter-data-redis</artifactId>
  11.         </dependency>
  12.         <!--   fastjson依赖     -->
  13.         <dependency>
  14.             <groupId>com.alibaba</groupId>
  15.             <artifactId>fastjson</artifactId>
  16.             <version>1.2.33</version>
  17.         </dependency>
  18.         <!--   jwt依赖     -->
  19.         <dependency>
  20.             <groupId>io.jsonwebtoken</groupId>
  21.             <artifactId>jjwt</artifactId>
  22.             <version>0.9.0</version>
  23.         </dependency>

그런 다음 Redis를 사용하고 Redis 관련 구성을 추가해야 합니다.

첫 번째는 FastJson의 직렬 변환기입니다.

  1. package org.example.utils;
  2. import com.alibaba.fastjson.JSON;
  3. import com.alibaba.fastjson.parser.ParserConfig;
  4. import com.alibaba.fastjson.serializer.SerializerFeature;
  5. import com.fasterxml.jackson.databind.JavaType;
  6. import com.fasterxml.jackson.databind.type.TypeFactory;
  7. import org.springframework.data.redis.serializer.RedisSerializer;
  8. import org.springframework.data.redis.serializer.SerializationException;
  9.  
  10. import java.nio.charset.Charset;
  11.  
  12. /**
  13.  * Redis使用fastjson序列化
  14.  * @param <T>
  15.  */
  16. public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
  17.  
  18.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  19.  
  20.     private Class<T> clazz;
  21.  
  22.     static {
  23.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  24.     }
  25.  
  26.     public FastJsonRedisSerializer(Class<T> clazz){
  27.         super();
  28.         this.clazz=clazz;
  29.     }
  30.     
  31.     @Override
  32.     public byte[] serialize(T t) throws SerializationException {
  33.         if (t == null){
  34.             return new byte[0];
  35.         }
  36.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  37.     }
  38.  
  39.     @Override
  40.     public T deserialize(byte[] bytes) throws SerializationException {
  41.         if (bytes==null || bytes.length<=0){
  42.             return null;
  43.         }
  44.         String str = new String(bytes,DEFAULT_CHARSET);
  45.  
  46.         return JSON.parseObject(str,clazz);
  47.     }
  48.  
  49.     protected JavaType getJavaType(Class<?> clazz){
  50.         return TypeFactory.defaultInstance().constructType(clazz);
  51.     }
  52.     
  53. }

RedisConfig를 생성하고 그 안에 직렬 변환기를 생성하여 문자 깨짐과 같은 문제를 해결합니다.

  1. package org.example.config;
  2. import org.example.utils.FastJsonRedisSerializer;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.data.redis.connection.RedisConnectionFactory;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.serializer.StringRedisSerializer;
  8.  
  9. @Configuration
  10. public class RedisConfig {
  11.     @Bean
  12.     @SuppressWarnings(value = {"unchecked","rawtypes"})
  13.     public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
  14.         RedisTemplate<Object,Object> template = new RedisTemplate<>();
  15.         template.setConnectionFactory(connectionFactory);
  16.  
  17.         FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
  18.  
  19.         //使用StringRedisSerializer来序列化和反序列化redus的key值
  20.         template.setKeySerializer(new StringRedisSerializer());
  21.         template.setValueSerializer(serializer);
  22.  
  23.         template.afterPropertiesSet();
  24.         return template;
  25.     }
  26. }

응답 클래스를 통일하는 것도 필요합니다

  1. package org.example.domain;
  2. import com.fasterxml.jackson.annotation.JsonInclude;
  3. @JsonInclude(JsonInclude.Include.NON_NULL)
  4. public class ResponseResult<T>{
  5.     /**
  6.      * 状态码
  7.      */
  8.     private Integer code;
  9.     /**
  10.      * 提示信息，如果有错误时，前端可以获取该字段进行提示
  11.      */
  12.     private String msg;
  13.     /**
  14.      * 查询到的结果数据
  15.      */
  16.     private T data;
  17.  
  18.     public ResponseResult(Integer code,String msg){
  19.         this.code = code;
  20.         this.msg = msg;
  21.     }
  22.  
  23.     public ResponseResult(Integer code,T data){
  24.         this.code = code;
  25.         this.data = data;
  26.     }
  27.  
  28.     public Integer getCode() {
  29.         return code;
  30.     }
  31.  
  32.     public void setCode(Integer code) {
  33.         this.code = code;
  34.     }
  35.  
  36.     public String getMsg() {
  37.         return msg;
  38.     }
  39.  
  40.     public void setMsg(String msg) {
  41.         this.msg = msg;
  42.     }
  43.  
  44.     public T getData() {
  45.         return data;
  46.     }
  47.  
  48.     public void setData(T data) {
  49.         this.data = data;
  50.     }
  51.  
  52.     public ResponseResult(Integer code,String msg,T data){
  53.         this.code = code;
  54.         this.msg = msg;
  55.         this.data = data;
  56.     }
  57. }

jwt를 생성하고 jwt를 구문 분석하려면 jwt 도구 클래스가 필요합니다.

  1. package org.example.utils;
  2.  
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.JwtBuilder;
  5. import io.jsonwebtoken.Jwts;
  6. import io.jsonwebtoken.SignatureAlgorithm;
  7.  
  8. import javax.crypto.SecretKey;
  9. import javax.crypto.spec.SecretKeySpec;
  10. import java.util.Base64;
  11. import java.util.Date;
  12. import java.util.UUID;
  13.  
  14. public class JwtUtil {
  15.  
  16.     //有效期为
  17.     public static final Long JWT_TTL = 60*60*1000L; //一个小时
  18.     //设置密钥明文
  19.     public static final String JWT_KEY = "hzj";
  20.  
  21.     public static String getUUID(){
  22.         String token = UUID.randomUUID().toString().replaceAll("-","");
  23.         return token;
  24.     }
  25.  
  26.     /**
  27.      * 生成jwt
  28.      * @param subject token中要存放的数据（json格式）
  29.      * @return
  30.      */
  31.     public static String createJWT(String subject){
  32.         JwtBuilder builder = getJwtBuilder(subject,null,getUUID()); //设置过期时间
  33.         return builder.compact();
  34.     }
  35.  
  36.     /**
  37.      * 生成jwt
  38.      * @param subject token中要存放的数据（json格式）
  39.      * @param ttlMillis token超时时间
  40.      * @return
  41.      */
  42.     public static String createJWT(String subject,Long ttlMillis){
  43.         JwtBuilder builder = getJwtBuilder(subject,ttlMillis,getUUID()); //设置过期时间
  44.         return builder.compact();
  45.     }
  46.  
  47.     private static JwtBuilder getJwtBuilder(String subject,Long ttlMillis,String uuid){
  48.         SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
  49.         SecretKey secretKey = generalkey();
  50.         long nowMillis = System.currentTimeMillis();
  51.         Date now = new Date(nowMillis);
  52.         if(ttlMillis==null){
  53.             ttlMillis=JwtUtil.JWT_TTL;
  54.         }
  55.         long expMillis = nowMillis + ttlMillis;
  56.         Date expDate = new Date(expMillis);
  57.         return Jwts.builder()
  58.                 .setId(uuid) //唯一的Id
  59.                 .setSubject(subject) //主题 可以是Json数据
  60.                 .setIssuer("hzj") //签发者
  61.                 .setIssuedAt(now) //签发时间
  62.                 .signWith(signatureAlgorithm,secretKey) //使用HS256对称加密算法签名，第二个参数为密钥
  63.                 .setExpiration(expDate);
  64.     }
  65.  
  66.     /**
  67.      * 创建token
  68.      * @param id
  69.      * @param subject
  70.      * @param ttlMillis
  71.      * @return
  72.      */
  73.     public static String createJWT(String id,String subject,Long ttlMillis){
  74.         JwtBuilder builder = getJwtBuilder(subject,ttlMillis,id);//设置过期时间
  75.         return builder.compact();
  76.     }
  77.  
  78.     public static void main(String[] args) throws Exception{
  79.         String token =
  80. "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1OTg0MjU5MzIsInVzZX" +
  81. "JJZCI6MTExLCJ1c2VybmFtZSI6Ik1hcmtaUVAifQ.PTlOdRG7ROVJqPrA0q2ac7rKFzNNFR3lTMyP_8fIw9Q";
  82.         Claims claims = parseJWT(token);
  83.         System.out.println(claims);
  84.     }
  85.  
  86.     /**
  87.      * 生成加密后的密钥secretkey
  88.      * @return
  89.      */
  90.     public static SecretKey generalkey(){
  91.         byte[] encodeedkey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
  92.         SecretKey key = new SecretKeySpec(encodeedkey,0,encodeedkey.length,"AES");
  93.         return key;
  94.     }
  95.  
  96.     /**
  97.      * 解析
  98.      * @param jwt
  99.      * @return
  100.      * @throws Exception
  101.      */
  102.     public static Claims parseJWT(String jwt) throws Exception{
  103.         SecretKey secretKey = generalkey();
  104.         return Jwts.parser()
  105.                 .setSigningKey(secretKey)
  106.                 .parseClaimsJws(jwt)
  107.                 .getBody();
  108.     }
  109. }

redistemplate을 더 쉽게 호출할 수 있도록 하는 또 다른 Redis 도구 클래스 RedisCache를 정의합니다.

  1. package org.example.utils;
  2.  
  3.  
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.BoundSetOperations;
  6. import org.springframework.data.redis.core.HashOperations;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.core.ValueOperations;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import java.util.*;
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  15. @Component
  16. public class RedisCache
  17. {
  18.     @Autowired
  19.     public RedisTemplate redisTemplate;
  20.  
  21.     /**
  22.      * 缓存基本的对象，Integer、String、实体类等
  23.      *
  24.      * @param key 缓存的键值
  25.      * @param value 缓存的值
  26.      */
  27.     public <T> void setCacheObject(final String key, final T value)
  28.     {
  29.         redisTemplate.opsForValue().set(key, value);
  30.     }
  31.  
  32.     /**
  33.      * 缓存基本的对象，Integer、String、实体类等
  34.      *
  35.      * @param key 缓存的键值
  36.      * @param value 缓存的值
  37.      * @param timeout 时间
  38.      * @param timeUnit 时间颗粒度
  39.      */
  40.     public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
  41.     {
  42.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  43.     }
  44.  
  45.     /**
  46.      * 设置有效时间
  47.      *
  48.      * @param key Redis键
  49.      * @param timeout 超时时间
  50.      * @return true=设置成功；false=设置失败
  51.      */
  52.     public boolean expire(final String key, final long timeout)
  53.     {
  54.         return expire(key, timeout, TimeUnit.SECONDS);
  55.     }
  56.  
  57.     /**
  58.      * 设置有效时间
  59.      *
  60.      * @param key Redis键
  61.      * @param timeout 超时时间
  62.      * @param unit 时间单位
  63.      * @return true=设置成功；false=设置失败
  64.      */
  65.     public boolean expire(final String key, final long timeout, final TimeUnit unit)
  66.     {
  67.         return redisTemplate.expire(key, timeout, unit);
  68.     }
  69.  
  70.     /**
  71.      * 获得缓存的基本对象。
  72.      *
  73.      * @param key 缓存键值
  74.      * @return 缓存键值对应的数据
  75.      */
  76.     public <T> T getCacheObject(final String key)
  77.     {
  78.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  79.         return operation.get(key);
  80.     }
  81.  
  82.     /**
  83.      * 删除单个对象
  84.      *
  85.      * @param key
  86.      */
  87.     public boolean deleteObject(final String key)
  88.     {
  89.         return redisTemplate.delete(key);
  90.     }
  91.  
  92.     /**
  93.      * 删除集合对象
  94.      *
  95.      * @param collection 多个对象
  96.      * @return
  97.      */
  98.     public long deleteObject(final Collection collection)
  99.     {
  100.         return redisTemplate.delete(collection);
  101.     }
  102.  
  103.     /**
  104.      * 缓存List数据
  105.      *
  106.      * @param key 缓存的键值
  107.      * @param dataList 待缓存的List数据
  108.      * @return 缓存的对象
  109.      */
  110.     public <T> long setCacheList(final String key, final List<T> dataList)
  111.     {
  112.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  113.         return count == null ? 0 : count;
  114.     }
  115.  
  116.     /**
  117.      * 获得缓存的list对象
  118.      *
  119.      * @param key 缓存的键值
  120.      * @return 缓存键值对应的数据
  121.      */
  122.     public <T> List<T> getCacheList(final String key)
  123.     {
  124.         return redisTemplate.opsForList().range(key, 0, -1);
  125.     }
  126.  
  127.     /**
  128.      * 缓存Set
  129.      *
  130.      * @param key 缓存键值
  131.      * @param dataSet 缓存的数据
  132.      * @return 缓存数据的对象
  133.      */
  134.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
  135.     {
  136.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  137.         Iterator<T> it = dataSet.iterator();
  138.         while (it.hasNext())
  139.         {
  140.             setOperation.add(it.next());
  141.         }
  142.         return setOperation;
  143.     }
  144.  
  145.     /**
  146.      * 获得缓存的set
  147.      *
  148.      * @param key
  149.      * @return
  150.      */
  151.     public <T> Set<T> getCacheSet(final String key)
  152.     {
  153.         return redisTemplate.opsForSet().members(key);
  154.     }
  155.  
  156.     /**
  157.      * 缓存Map
  158.      *
  159.      * @param key
  160.      * @param dataMap
  161.      */
  162.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
  163.     {
  164.         if (dataMap != null) {
  165.             redisTemplate.opsForHash().putAll(key, dataMap);
  166.         }
  167.     }
  168.  
  169.     /**
  170.      * 获得缓存的Map
  171.      *
  172.      * @param key
  173.      * @return
  174.      */
  175.     public <T> Map<String, T> getCacheMap(final String key)
  176.     {
  177.         return redisTemplate.opsForHash().entries(key);
  178.     }
  179.  
  180.     /**
  181.      * 往Hash中存入数据
  182.      *
  183.      * @param key Redis键
  184.      * @param hKey Hash键
  185.      * @param value 值
  186.      */
  187.     public <T> void setCacheMapValue(final String key, final String hKey, final T value)
  188.     {
  189.         redisTemplate.opsForHash().put(key, hKey, value);
  190.     }
  191.  
  192.     /**
  193.      * 获取Hash中的数据
  194.      *
  195.      * @param key Redis键
  196.      * @param hKey Hash键
  197.      * @return Hash中的对象
  198.      */
  199.     public <T> T getCacheMapValue(final String key, final String hKey)
  200.     {
  201.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  202.         return opsForHash.get(key, hKey);
  203.     }
  204.  
  205.     /**
  206.      * 删除Hash中的数据
  207.      *
  208.      * @param key
  209.      * @param hkey
  210.      */
  211.     public void delCacheMapValue(final String key, final String hkey)
  212.     {
  213.         HashOperations hashOperations = redisTemplate.opsForHash();
  214.         hashOperations.delete(key, hkey);
  215.     }
  216.  
  217.     /**
  218.      * 获取多个Hash中的数据
  219.      *
  220.      * @param key Redis键
  221.      * @param hKeys Hash键集合
  222.      * @return Hash对象集合
  223.      */
  224.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
  225.     {
  226.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  227.     }
  228.  
  229.     /**
  230.      * 获得缓存的基本对象列表
  231.      *
  232.      * @param pattern 字符串前缀
  233.      * @return 对象列表
  234.      */
  235.     public Collection<String> keys(final String pattern)
  236.     {
  237.         return redisTemplate.keys(pattern);
  238.     }
  239. }
  240.

응답에 데이터를 쓸 수도 있으므로 WebUtils 도구 클래스도 필요합니다.

  1. package org.example.utils;
  2.  
  3. import javax.servlet.http.HttpServletResponse;
  4. import java.io.IOException;
  5.  
  6. public class WebUtils {
  7.     /**
  8.      * 将字符串渲染到客户端
  9.      *
  10.      * @param response 渲染对象
  11.      * @param string 待渲染的字符串
  12.      * @return null
  13.      */
  14.     public static String renderString(HttpServletResponse response, String string) {
  15.         try
  16.         {
  17.             response.setStatus(200);
  18.             response.setContentType("application/json");
  19.             response.setCharacterEncoding("utf-8");
  20.             response.getWriter().print(string);
  21.         }
  22.         catch (IOException e)
  23.         {
  24.             e.printStackTrace();
  25.         }
  26.         return null;
  27.     }
  28. }

마지막으로 해당 사용자 엔터티 클래스를 작성합니다.

  1. package org.example.domain;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import java.io.Serializable;
  7. import java.util.Date;
  8. /**
  9.  * 用户表(User)实体类
  10.  */
  11. @Data
  12. @AllArgsConstructor
  13. @NoArgsConstructor
  14. public class User implements Serializable {
  15.     private static final long serialVersionUID = -40356785423868312L;
  16.     /**
  17.      * 主键
  18.      */
  19.     private Long id;
  20.     /**
  21.      * 用户名
  22.      */
  23.     private String userName;
  24.     /**
  25.      * 昵称
  26.      */
  27.     private String nickName;
  28.     /**
  29.      * 密码
  30.      */
  31.     private String password;
  32.     /**
  33.      * 账号状态（0正常 1停用）
  34.      */
  35.     private String status;
  36.     /**
  37.      * 邮箱
  38.      */
  39.     private String email;
  40.     /**
  41.      * 手机号
  42.      */
  43.     private String phonenumber;
  44.     /**
  45.      * 用户性别（0男，1女，2未知）
  46.      */
  47.     private String sex;
  48.     /**
  49.      * 头像
  50.      */
  51.     private String avatar;
  52.     /**
  53.      * 用户类型（0管理员，1普通用户）
  54.      */
  55.     private String userType;
  56.     /**
  57.      * 创建人的用户id
  58.      */
  59.     private Long createBy;
  60.     /**
  61.      * 创建时间
  62.      */
  63.     private Date createTime;
  64.     /**
  65.      * 更新人
  66.      */
  67.     private Long updateBy;
  68.     /**
  69.      * 更新时间
  70.      */
  71.     private Date updateTime;
  72.     /**
  73.      * 删除标志（0代表未删除，1代表已删除）
  74.      */
  75.     private Integer delFlag;
  76. }
  77.

위의 분석에 따르면 SpringSecuriry가 UserDetailsService를 사용할 수 있도록 UserDetailsService를 사용자 정의해야 합니다. 자체 UserDetailsService는 데이터베이스에서 사용자 이름과 비밀번호를 쿼리할 수 있습니다.

먼저 데이터베이스 테이블 sys_user를 생성합니다.

  1. CREATE TABLE `sys_user` (
  2.   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  3.   `user_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  4.   `nick_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '呢称',
  5.   `password` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  6.   `status` char(1) DEFAULT '0' COMMENT '账号状态（0正常1停用)',
  7.   `email` varchar(64) DEFAULT NULL COMMENT '邮箱',
  8.   `phonenumber` varchar(32) DEFAULT NULL COMMENT '手机号',
  9.   `sex` char(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知)',
  10.   `avatar` varchar(128) DEFAULT NULL COMMENT '头像',
  11.   `user_type` char(1) NOT NULL DEFAULT '1' COMMENT '用户类型（O管理员，1普通用户)',
  12.   `create_by` bigint DEFAULT NULL COMMENT '创建人的用户id',
  13.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  14.   `update_by` bigint DEFAULT NULL COMMENT '更新人',
  15.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  16.   `del_flag` int DEFAULT '0' COMMENT '删除标志（O代表未删除，1代表已删除)',
  17.   PRIMARY KEY (`id`)
  18. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户表';

그런 다음 myBatisPlus 및 mysql 드라이버를 소개합니다.

  1.         <dependency>
  2.             <groupId>com.baomidou</groupId>
  3.             <artifactId>mybatis-plus-boot-starter</artifactId>
  4.             <version>3.4.3</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>mysql</groupId>
  8.             <artifactId>mysql-connector-java</artifactId>
  9.         </dependency>

그런 다음 데이터베이스의 관련 정보를 구성합니다.

그런 다음 매퍼 인터페이스 UserMapper를 정의하고 mybatisplus를 사용하여 해당 주석을 추가합니다.

  1. package org.example.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import org.example.domain.User;
  5.  
  6. public interface UserMapper extends BaseMapper<User> {
  7. }

그런 다음 구성 요소 검색을 구성합니다.

마지막으로 mp를 정상적으로 사용할 수 있는지 테스트해 보세요.

junit 소개

이렇게 하면 정상적으로 사용할 수 있습니다.

2.3.3 구현

2.3.3.1 데이터베이스 검증 사용자

다음으로 핵심 코드를 구현해야 합니다.

먼저 UserDetailsService를 사용자 정의해 보겠습니다.

  1. package org.example.service.impl;
  2. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  3. import org.example.domain.LoginUser;
  4. import org.example.domain.User;
  5. import org.example.mapper.UserMapper;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.security.core.userdetails.UserDetails;
  8. import org.springframework.security.core.userdetails.UserDetailsService;
  9. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  10. import org.springframework.stereotype.Service;
  11. import java.util.Objects;
  12. @Service
  13. public class UserDetailsServiceImpl implements UserDetailsService {
  14.     @Autowired
  15.     private UserMapper userMapper;
  16.     @Override
  17.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  18.         //查询用户信息 [InMemoryUserDetailsManager是在内存中查找]
  19.         LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  20.         wrapper.eq(User::getUserName,username);
  21.         User user = userMapper.selectOne(wrapper);
  22.         //如果查询不到数据就抛出异常，给出提示
  23.         if(Objects.isNull(user)){
  24.             throw new RuntimeException("用户名或密码错误!");
  25.         }
  26.  
  27.         //TODO 查询权限信息
  28.  
  29.         //封装为UserDetails对象返回
  30.         return new LoginUser(user);
  31.     }
  32. }

여기서 사용자는 UserDetails로 캡슐화되어 반환됩니다.

  1. package org.example.domain;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. import org.springframework.security.core.GrantedAuthority;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7. import java.util.Collection;
  8. @Data
  9. @AllArgsConstructor
  10. @NoArgsConstructor
  11. public class LoginUser implements UserDetails {
  12.     private User user;
  13.     @Override
  14.     public Collection<? extends GrantedAuthority> getAuthorities() {
  15.         return null;
  16.     }
  17.  
  18.     @Override
  19.     public String getPassword() {
  20.         return user.getPassword();
  21.     }
  22.  
  23.     @Override
  24.     public String getUsername() {
  25.         return user.getUserName();
  26.     }
  27.  
  28.     @Override
  29.     public boolean isAccountNonExpired() {
  30.         return true;
  31.     }
  32.  
  33.     @Override
  34.     public boolean isAccountNonLocked() {
  35.         return true;
  36.     }
  37.  
  38.     @Override
  39.     public boolean isCredentialsNonExpired() {
  40.         return true;
  41.     }
  42.  
  43.     @Override
  44.     public boolean isEnabled() {
  45.         return true;
  46.     }
  47. }

마지막으로 여기에는 데이터베이스에서 데이터를 가져오기 위해 로그인 테스트를 수행해야 하며, 사용자의 비밀번호를 일반 텍스트로 전송하려면 테이블에 사용자 데이터를 써야 한다는 점이 있습니다. , 비밀번호 앞에 {noop}를 추가해야 합니다.

여기에 데이터베이스의 사용자 이름과 비밀번호를 입력하여 로그인할 수 있습니다.

2.3.3.2 비밀번호 암호화 저장

기본 PasswordEncoder에서는 데이터베이스의 비밀번호 형식이 {id}password가 되도록 요구하기 때문에 비밀번호 앞에 {noop}을 추가하는 이유에 대해 이야기해 보겠습니다. 이는 id를 기반으로 비밀번호의 암호화 방법을 결정하지만 일반적으로 우리는 이 방법을 채택하지 않으므로 PasswordEncoder를 교체해야 합니다.

다음으로 우리는 그것을 테스트하고 볼 것입니다.

여기에 전달한 두 개의 원래 비밀번호는 동일하지만 다른 결과를 얻었습니다. 이는 실제로 솔팅 알고리즘과 관련이 있습니다. 나중에 사용자 정의 암호화에 대한 기사도 작성할 것입니다.

암호화된 비밀번호를 얻은 후, 암호화된 비밀번호를 데이터베이스에 저장한 다음 프런트 엔드에서 전달된 일반 텍스트 비밀번호를 데이터베이스의 암호화된 비밀번호로 확인하여 로그인할 수 있습니다.

이때 로그인을 위해 프로젝트를 시작했는데 더 이상 이전 비밀번호로 로그인할 수 없다는 사실을 발견했습니다. 데이터베이스는 원래 비밀번호가 아닌 등록 단계에서 데이터베이스에 저장된 암호화된 비밀번호를 저장해야 하기 때문입니다. 등록하지 않았으므로 비밀번호를 암호화하겠습니다) 비밀번호는 데이터베이스 자체에 기록됩니다.

2.3.3.3 로그인 인터페이스

로그인 인터페이스를 구현한 후 SpringSecurity가 이를 허용하도록 해야 합니다. 허용되지 않으면 모순이 됩니다. 인터페이스에서는 AuthenticationManager의 authenticate 메소드를 통해 수행되므로 AuthenticationManager가 주입되도록 구성해야 합니다. SecurityConfig의 컨테이너에 추가합니다.

인증에 성공하면 사용자가 다음 요청 시 jwt를 통해 특정 사용자를 식별할 수 있도록 jwt를 생성하여 응답에 넣어야 하며 사용자 정보는 redis에 저장되어야 합니다. ID를 열쇠로 사용할 수 있습니다.

LoginController를 먼저 작성하세요.

그런 다음 해당 서비스를 작성하십시오.

SecurityConfig에 AuthenticationManager를 삽입하고 로그인 인터페이스를 해제합니다.

서비스의 비즈니스 로직에서는 인증에 실패하면 사용자 정의 예외가 반환되지만, 인증에 성공하면 해당 정보를 어떻게 얻습니까?

여기서 우리는 획득한 객체를 디버그하고 볼 수 있습니다.

해당 필수 정보는 교장에서 얻을 수 있습니다.

그런 다음 코드를 완성하세요.

마지막으로 테스트해 보세요.

2.3.3.4 인증 필터

먼저 코드를 붙여넣겠습니다.

  1. @Component
  2. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
  3.  
  4.     @Autowired
  5.     private RedisCache redisCache;
  6.  
  7.     @Override
  8.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  9.         //获取token
  10.         String token = request.getHeader("token");
  11.         if (!StringUtils.hasText(token)) {
  12.             //放行
  13.             filterChain.doFilter(request, response); //这里放行是因为还有后续的过滤器会给出对应的异常
  14.             return; //token为空 不执行后续流程
  15.         }
  16.         //解析token
  17.         String userid;
  18.         try {
  19.             Claims claims = JwtUtil.parseJWT(token);
  20.             userid = claims.getSubject();
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.             throw new RuntimeException("token非法!");
  24.         }
  25.         //从redis中获取用户信息
  26.         String redisKey = "login:" + userid;
  27.         LoginUser loginUser = redisCache.getCacheObject(redisKey);
  28.         if (Objects.isNull(loginUser)){
  29.             throw new RuntimeException("用户未登录!");
  30.         }
  31.         //将信息存入SecurityContextHolder（因为过滤器链后面的filter都是从中获取认证信息进行对应放行）
  32.         //TODO 获取权限信息封装到Authentication中
  33.         UsernamePasswordAuthenticationToken authenticationToken =
  34.                 new UsernamePasswordAuthenticationToken(loginUser,null,null);
  35.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
  36.  
  37.         //放行
  38.         filterChain.doFilter(request,response); //此时的放行是携带认证的，不同于上方token为空的放行
  39.     }
  40. }

우선 여기서 토큰을 얻으려면 요청 헤더에서 해당 토큰을 가져온 후 비어 있는지 확인하고 비어 있으면 후속 프로세스를 거치지 않고 직접 릴리스합니다. 토큰을 구문 분석하고, 내부에서 userid를 가져온 다음 redis에서 해당 사용자 정보를 얻은 후 마지막으로 SecurityContextHolder에 저장합니다. 왜냐하면 후속 필터는 일일 인증 정보를 가져와서 마지막으로 수행해야 하기 때문입니다. 분석 작업.

주의가 필요한 또 다른 점은 SecurityContextHolder.getContext().setAuthentication()이 인증 개체를 전달해야 한다는 것입니다. 개체를 빌드할 때 세 번째 매개 변수가 인증 여부를 결정하는 핵심이기 때문입니다.

다음으로 이 필터를 구성해야 합니다.

그런 다음 사용자/로그인 인터페이스에 액세스하면 토큰이 포함된 응답 본문이 반환됩니다. hello 인터페이스에 다시 액세스하면 403이 됩니다. 토큰을 전달하지 않으므로 위 코드에 해당합니다. 토큰이 없으면 응답 본문이 해제되고 반환은 후속 프로세스를 실행하지 않습니다. (여기서 해제하는 것은 나중에 처리하기 위해 특별히 예외를 발생시키는 다른 필터가 있기 때문이며 반환은 응답을 통과하지 못하도록 하기 위한 것입니다. 프로세스)

이때 사용자/로그인으로 생성된 토큰을 hello 인터페이스의 요청 헤더에 넣으면 정상적으로 접근할 수 있다.

그러면 필터 세트의 목적이 달성되었습니다(토큰 획득, 토큰 구문 분석 및 SecurityContextHolder에 저장).

2.3.3.5 로그아웃

이 시점에서는 로그아웃하기가 더 쉽습니다. 나중에 액세스하기 위해 토큰을 가져올 때 Redis의 해당 사용자 정보는 현재 사용자 정의 필터에서 얻을 수 있습니다. 얻을 수 없다는 것은 로그인되어 있지 않다는 뜻입니다.

/user/logout 인터페이스에 액세스하기 위해 이 토큰을 가지고 있습니다.

그런 다음 로그아웃 기능이 구현됩니다.

이번 글은 스테이션B 3차 업데이트를 통해 알게된 내용입니다! ! !

개인 프로필

그는 30년 이상 기술 연구에 전념해 왔으며, java, linux, javascript, php, css 등 다양한 언어에 능숙하며, 오픈 소스 분야에 많은 공헌을 했습니다. 나중에 참조할 수 있도록 기술 개발의 일부 문제를 공유하는 개발자 문서 스테이션입니다.

내 연락처 정보

우편