Condivisione della tecnologia

SpringSecurity Framework [Autenticazione]

2024-07-12

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

Sommario

1. Avvio rapido

2. Certificazione

2.1 Processo di verifica dell'accesso

2.2 Esplorazione preliminare del principio

2.3 Risolvere il problema

2.3.1 Analisi delle idee

2.3.2 Preparazione

2.3.3 Attuazione

2.3.3.1 Utente di verifica del database

2.3.3.2 Archiviazione crittografata con password

2.3.3.3 Interfaccia di accesso

2.3.3.4 Filtro di autenticazione

2.3.3.5 Disconnettersi

Spring Security è un framework di gestione della sicurezza della famiglia Spring Rispetto a Shiro, un altro framework di sicurezza, fornisce funzioni e risorse della comunità più ricche rispetto a Shiro.

In generale, Spring Security è più comunemente usato in progetti su larga scala, mentre Shiro è più comunemente usato in piccoli progetti, perché rispetto a Spring Security, con Shiro è più facile iniziare.

Le applicazioni web generali devono farloCertificazioneEAutorizzare。

  • Autenticazione: verifica se l'utente corrente che accede al sistema è l'utente del sistema e conferma quale utente è.
  • Autorizzazione: dopo l'autenticazione, determinare se l'utente corrente dispone dell'autorizzazione per eseguire un'operazione

L'autenticazione e l'autorizzazione sono le funzioni principali di Spring Security come struttura di sicurezza!

1. Avvio rapido

Per prima cosa creiamo semplicemente un progetto SpringBoot.

A questo punto, accediamo a una semplice interfaccia di saluto che abbiamo scritto per verificare se la costruzione ha avuto successo.

Quindi introdurre SpringSecurity.

A questo punto, diamo un'occhiata all'effetto dell'interfaccia di accesso.

Dopo l'introduzione di SpringSecurity, l'interfaccia di accesso passerà automaticamente a una pagina di accesso. Il nome utente predefinito è user e la password verrà inviata alla console. È necessario effettuare il login per accedere all'interfaccia.

2. Certificazione

2.1 Processo di verifica dell'accesso

Prima di tutto, dobbiamo comprendere il processo di verifica dell'accesso. Innanzitutto, il front-end trasporta il nome utente e la password per accedere all'interfaccia di accesso. Dopo che il server ha ottenuto il nome utente e la password, li confronta con quelli nel database. Se il nome utente/ID utente viene utilizzato correttamente, viene generato un jwt, quindi Rispondi jwt al front-end e quindi l'accesso ad altre richieste dopo l'accesso porterà il token nell'intestazione della richiesta ogni volta che il server ottiene il token l'intestazione della richiesta per l'analisi, ottiene l'ID utente e ottiene informazioni relative all'utente e autorizzazioni di visualizzazione in base all'ID nome utente, se si dispone dell'autorizzazione, rispondere al front-end.

2.2 Esplorazione preliminare del principio

Il principio di SpringSecurity è in realtà una catena di filtri, che fornisce filtri con varie funzioni. Qui esamineremo prima i filtri coinvolti nell'avvio rapido sopra.

  • UsernamePasswordAuthenticationFilter è responsabile dell'elaborazione delle richieste di accesso dopo aver inserito nome utente e password nella pagina di accesso.
  • ExceptionTranslationFilter gestisce qualsiasi AccessDeniedException e AuthenticationException lanciate nella catena di filtri
  • FilterSecurityInterceptor è un filtro responsabile della verifica dei permessi

Possiamo anche utilizzare Debug per vedere quali filtri si trovano nella catena di filtri SpringSecurity nel sistema corrente e il loro ordine.

Successivamente, diamo un’occhiata all’analisi del diagramma di flusso di autenticazione.

Qui dobbiamo solo essere in grado di comprendere il processo Per dirla semplicemente:

L'utente ha inviato il nome utente e la password, UsernamePasswordAuthenticationFilter lo incapsula come oggetto Authentication e chiama il metodo authenticate per l'autenticazione, quindi chiama il metodo authenticate di DaoAuthenticationProvider per l'autenticazione, quindi chiama il metodo loadUserByUserName per interrogare l'utente qui consiste nel cercare in memoria, quindi incapsulare le informazioni utente corrispondenti in un oggetto UserDetails, utilizzare PasswordEncoder per confrontare la password in UserDetails e la password di autenticazione per verificare se è corretta. Se corretta, impostare le informazioni sull'autorizzazione in UserDetails sull'oggetto Authentication , quindi restituire l'oggetto Authentication e infine utilizzare il metodo SecurityContextHolder.getContext().setAuthentication che memorizza questo oggetto e altri filtri otterranno le informazioni dell'utente corrente tramite SecurityContextHoder. (Non è necessario memorizzare questo paragrafo per capirlo)

Quindi conosciamo il processo prima di poterlo modificare. Prima di tutto, durante la ricerca dalla memoria, dobbiamo cercare nel database (qui dobbiamo personalizzare una classe di implementazione UserDetailsService) e non utilizzeremo il nome utente e la password predefiniti. e l'interfaccia di accesso deve essere scritta da te e non è necessario utilizzare la pagina di accesso predefinita da lui fornita.

Sulla base della situazione che abbiamo analizzato, possiamo ottenere un quadro del genere.

In questo momento, un jwt viene restituito al front-end e le altre richieste effettuate dal front-end trasporteranno il token. Quindi il nostro primo passo è verificare se il token viene trasportato, analizzarlo, ottenere l'ID utente corrispondente e incapsularlo come oggetto Anthentication viene archiviato in SecurityContextHolder (in modo che altri filtri possano ottenerlo).

Quindi c'è un'altra domanda qui. Come ottenere informazioni complete sull'utente dopo aver ottenuto l'ID utente dal filtro di autenticazione jwt?

Qui utilizziamo redis. Quando il server esegue l'autenticazione utilizzando l'ID utente per generare jwt al front-end, l'ID utente viene utilizzato come chiave e le informazioni dell'utente vengono archiviate in redis come valore. Successivamente è possibile ottenere le informazioni complete sull'utente da Redis tramite l'ID utente.

2.3 Risolvere il problema

2.3.1 Analisi delle idee

Dall'esplorazione preliminare dei principi di cui sopra, abbiamo anche analizzato approssimativamente cosa dobbiamo fare se implementiamo da soli il processo di autenticazione della separazione front-end e back-end.

Login:

a. Interfaccia di accesso personalizzata

Chiama il metodo ProviderManager per l'autenticazione Se l'autenticazione passa, viene generato un jwt.

Archivia le informazioni dell'utente in Redis

b. Personalizza il servizio Dettagli utente

Interrogare il database in questa classe di implementazione

controllo:

a. Personalizza il filtro di autenticazione jwt

Ottieni gettone

Analizzare il token per ottenere il relativo ID utente

Ottieni informazioni utente complete da Redis

Archiviare in SecurityContextHolder

2.3.2 Preparazione

Per prima cosa devi aggiungere le dipendenze corrispondenti

  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>

Quindi dobbiamo utilizzare Redis e aggiungere le configurazioni relative a Redis.

Il primo è il serializzatore di 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. }

Crea RedisConfig e crea un serializzatore al suo interno per risolvere problemi come caratteri confusi.

  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. }

È inoltre necessario unificare la classe di risposta

  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. }

Sono necessarie le classi degli strumenti jwt per generare jwt e analizzare 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. }

Definire un'altra classe dello strumento Redis, RedisCache, che semplifica la chiamata a redistemplate

  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.

Potremmo anche scrivere dati nella risposta, quindi abbiamo bisogno anche di una classe di strumenti 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. }

Infine scrivi la classe dell'entità utente corrispondente

  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.

Secondo la nostra analisi di cui sopra, dobbiamo personalizzare un UserDetailsService per consentire a SpringSecuriry di utilizzare il nostro UserDetailsService. Il nostro UserDetailsService può interrogare il nome utente e la password dal database.

Per prima cosa creiamo una tabella di database 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='用户表';

Quindi introdurre myBatisPlus e i driver 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>

Quindi configurare le informazioni rilevanti del database.

Quindi definisci l'interfaccia del mappatore UserMapper e usa mybatisplus per aggiungere le annotazioni corrispondenti.

  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. }

Quindi configurare la scansione dei componenti

Infine, verifica se mp può essere utilizzato normalmente.

Presentare Junit

In questo modo può essere utilizzato normalmente.

2.3.3 Attuazione

2.3.3.1 Utente di verifica del database

Successivamente dobbiamo implementare il codice principale.

Innanzitutto, personalizziamo 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. }

Qui l'utente viene incapsulato come UserDetails e restituito.

  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. }

Infine, c'è un punto qui, ovvero dobbiamo eseguire un test di accesso per ottenere i dati dal database. Dobbiamo scrivere i dati dell'utente nella tabella e, se desideriamo, che la password dell'utente venga trasmessa in chiaro , devi aggiungere {noop} prima della password.

Qui è possibile inserire il nome utente e la password nel database per accedere.

2.3.3.2 Archiviazione crittografata con password

Parliamo del motivo per cui {noop} viene aggiunto davanti alla password, poiché il PasswordEncoder predefinito richiede che il formato della password nel database sia {id}password. Determinerà il metodo di crittografia della password in base all'ID, ma generalmente non adottare questo metodo, quindi PasswordEncoder deve essere sostituito.

Successivamente lo testeremo e vedremo.

Puoi vedere che le due password originali che abbiamo passato qui sono le stesse, ma abbiamo ottenuto risultati diversi. Questo è in realtà correlato all'algoritmo di salting. In seguito scriverò anche un articolo sulla crittografia personalizzata.

Dopo aver ottenuto la password crittografata, è possibile archiviare la password crittografata nel database, quindi è possibile accedere verificando la password in testo normale passata dal front-end con la password crittografata nel database.

A questo punto, abbiamo avviato il progetto di accesso e abbiamo scoperto che non potevamo più accedere con la password precedente, perché il database dovrebbe memorizzare la password crittografata memorizzata nel database durante la fase di registrazione, non la password originale (perché io non mi sono registrato, crittograferò la password) La password viene scritta da sola nel database).

2.3.3.3 Interfaccia di accesso

Dobbiamo implementare un'interfaccia di accesso e quindi lasciare che SpringSecuruty lo consenta. Se non è consentito, sarà contraddittorio Nell'interfaccia, l'autenticazione dell'utente viene eseguita tramite il metodo di autenticazione di AuthenticationManager, quindi dobbiamo configurare AuthenticationManager da iniettare. nel contenitore in SecurityConfig.

Se l'autenticazione ha esito positivo, è necessario generare un jwt e inserirlo nella risposta. Affinché l'utente possa identificare l'utente specifico tramite jwt quando effettua la richiesta successiva, le informazioni dell'utente devono essere archiviate in Redis e l'utente. L'ID può essere utilizzato come chiave.

Scrivi prima LoginController

Quindi scrivere il servizio corrispondente.

Iniettare AuthenticationManager in SecurityConfig e rilasciare l'interfaccia di accesso.

Nella logica aziendale del servizio, se l'autenticazione fallisce, verrà restituita un'eccezione personalizzata, ma se l'autenticazione ha esito positivo, come otteniamo le informazioni corrispondenti.

Qui possiamo eseguire il debug e vedere gli oggetti ottenuti.

Qui si trova che le informazioni necessarie corrispondenti possono essere ottenute nel Committente.

Quindi completa il codice.

Infine, provalo.

2.3.3.4 Filtro di autenticazione

Incollerò prima il codice.

  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. }

Prima di tutto, per ottenere il token qui, otteniamo il token corrispondente dall'intestazione della richiesta, quindi controlliamo che sia vuoto, lo rilasceremo direttamente senza passare attraverso il processo di follow-up analizzerà il token, otterrà l'ID utente all'interno, quindi utilizzerà l'ID utente in base a Ottieni le informazioni utente corrispondenti da redis e infine lo memorizzerà in SecurityContextHolder, poiché i filtri successivi devono ottenere da esso le informazioni di autenticazione giornaliera e infine eseguire operazioni di analisi.

Un altro punto che richiede attenzione è che SecurityContextHolder.getContext().setAuthentication() deve passare l'oggetto di autenticazione, quando costruiamo l'oggetto, utilizziamo tre parametri, perché il terzo parametro è la chiave per determinare se autenticarsi o meno.

Successivamente dobbiamo configurare questo filtro.

Quindi quando accediamo all'interfaccia utente/login, ci verrà restituito un corpo della risposta con un token. Quando accediamo nuovamente all'interfaccia hello, sarà 403. Poiché non contiene un token, corrisponde al codice sopra. Senza un token, il corpo della risposta verrà rilasciato e il ritorno non eseguirà il processo successivo (il rilascio qui è perché ci sono altri filtri che lanciano specificamente eccezioni per l'elaborazione successiva e il ritorno serve per impedire che passi attraverso la risposta. processi)

In questo momento, se inseriamo il token generato da user/login nell'intestazione della richiesta dell'interfaccia hello, possiamo accedervi normalmente.

Quindi lo scopo del nostro set di filtri è stato raggiunto (ottenimento di token, analisi dei token e memorizzazione in SecurityContextHolder)

2.3.3.5 Disconnettersi

A questo punto è più semplice per noi disconnetterci. Dobbiamo solo eliminare i dati corrispondenti in Redis. Quando porteremo il token per l'accesso in un secondo momento, le informazioni utente corrispondenti in Redis verranno ottenute nel nostro filtro personalizzato non riesci a ottenerlo significa che non sei loggato.

Portiamo questo token per accedere all'interfaccia /user/logout.

Quindi viene implementata la funzione di logout.

Questo articolo è stato appreso dal terzo aggiornamento della stazione b! ! !

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta