Teknologian jakaminen

SpringSecurity Framework [todennus]

2024-07-12

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

Sisällysluettelo

1. Pika-aloitus

2. Sertifiointi

2.1 Kirjautumisen vahvistusprosessi

2.2 Periaatteen alustava selvitys

2.3 Ratkaise ongelma

2.3.1 Idea-analyysi

2.3.2 Valmistelu

2.3.3 Toteutus

2.3.3.1 Tietokannan vahvistuskäyttäjä

2.3.3.2 Salasanasalattu tallennustila

2.3.3.3 Kirjautumisliittymä

2.3.3.4 Todennussuodatin

2.3.3.5 Kirjaudu ulos

Spring Security on Spring-perheen turvallisuuden hallintakehys verrattuna Shiroon, toiseen tietoturvakehykseen, se tarjoaa rikkaampia toimintoja ja rikkaampia yhteisöresursseja kuin Shiro.

Yleisesti ottaen Spring Securityä käytetään yleisemmin suurissa projekteissa ja Shiroa käytetään yleisemmin pienissä projekteissa, koska Spring Securityyn verrattuna Shiro on helpompi aloittaa.

Yleiset verkkosovellukset tarvitsevatSertifiointijaValtuuta。

  • Todennus: Tarkista, onko nykyinen järjestelmää käyttävä käyttäjä järjestelmän käyttäjä, ja vahvista, mikä käyttäjä se on.
  • Valtuutus: Määritä todennuksen jälkeen, onko nykyisellä käyttäjällä oikeus suorittaa toiminto

Todennus ja valtuutus ovat Spring Securityn ydintoimintoja tietoturvakehyksenä!

1. Pika-aloitus

Rakennataan ensin SpringBoot-projekti.

Tällä hetkellä käytämme yksinkertaista hello-käyttöliittymää, jonka kirjoitimme varmistaaksemme, onko rakentaminen onnistunut.

Esittele sitten SpringSecurity.

Katsotaanpa tällä kertaa käyttöliittymän vaikutusta.

Kun SpringSecurity on otettu käyttöön, käyttöliittymä siirtyy automaattisesti sisäänkirjautumissivulle. Oletuskäyttäjätunnus on käyttäjä, ja salasana lähetetään konsoliin.

2. Sertifiointi

2.1 Kirjautumisen vahvistusprosessi

Ensinnäkin meidän on ymmärrettävä sisäänkirjautumisen varmistusprosessi. Ensinnäkin käyttöliittymä sisältää käyttäjänimen ja salasanan kirjautumisliittymään pääsemiseksi. Jos käyttäjätunnusta/käyttäjätunnusta käytetään oikein, jwt luodaan ja sitten Vastaa jwt käyttöliittymään, ja sitten pääsy muihin pyyntöihin kirjautumisen jälkeen kuljettaa tunnuksen pyynnön otsikossa Aina, kun palvelin hankkii tunnuksen jäsennyspyynnön otsikko, hankkii käyttäjätunnuksen ja hankkii käyttäjätietoa ja katsojan käyttöoikeudet käyttäjätunnuksen perusteella, jos sinulla on lupa, vastaa käyttöliittymään.

2.2 Periaatteen alustava selvitys

SpringSecurityn periaate on itse asiassa suodatinketju, joka tarjoaa suodattimille erilaisia ​​toimintoja.

  • UsernamePasswordAuthenticationFilter vastaa kirjautumispyyntöjen käsittelystä sen jälkeen, kun käyttäjätunnus ja salasana on täytetty kirjautumissivulla.
  • ExceptionTranslationFilter käsittelee kaikki suodatinketjuun sijoitetut AccessDeniedException- ja AuthenticationException-
  • FilterSecurityInterceptor on suodatin, joka vastaa lupien tarkistamisesta

Debugin avulla voimme myös nähdä, mitkä suodattimet ovat SpringSecurity-suodatinketjussa nykyisessä järjestelmässä ja niiden järjestyksen.

Katsotaan seuraavaksi todennuksen vuokaavion analyysiä.

Tässä meidän tarvitsee vain ymmärtää prosessi Yksinkertaisesti sanottuna:

Käyttäjä lähetti käyttäjänimen ja salasanan, UsernamePasswordAuthenticationFilter kapseloi sen Authentication-objektiksi ja kutsuu todennusmenetelmän DaoAuthenticationProvider-todennusta varten ja kutsuu sitten loadUserByUserName-menetelmän käyttäjälle on etsiä muistista ja kapseloida vastaavat käyttäjätiedot UserDetails-objektiin, vertailla UserDetails-salasanaa ja Authentication-salasanaa, jos se on oikein, aseta UserDetailsin käyttöoikeustiedot Authentication-objektiin , palauta sitten Authentication-objekti ja lopuksi käytä SecurityContextHolder.getContext( ).setAuthentication-menetelmä tallentaa tämän objektin, ja muut suodattimet saavat nykyiset käyttäjätiedot SecurityContextHoderin kautta. (Sinun ei tarvitse opetella ulkoa tätä kappaletta ymmärtääkseen sen)

Sitten tunnemme prosessin ennen kuin voimme muokata sitä. Ensinnäkin, kun etsimme muistista, meidän on haettava tietokannasta (tässä meidän on mukautettava UserDetailsService-toteutusluokka), emmekä käytä oletusarvoista Käyttäjätunnusta ja salasanaa. , ja kirjautumisliittymän tulee olla itse kirjoittama, eikä hänen toimittamaa oletuskirjautumissivua tarvitse käyttää.

Analysoimamme tilanteen perusteella voimme saada tällaisen kuvan.

Tällä hetkellä jwt palautetaan käyttöliittymään, ja muut käyttöliittymän tekemät pyynnöt kuljettavat tokenin. Joten ensimmäinen askel on tarkistaa, onko merkintä mukana, jäsentää token, hankkia vastaava käyttäjätunnus ja kapseloida. se on Anthentication-objekti tallennetaan SecurityContextHolderiin (jotta muut suodattimet voivat saada sen).

Joten tässä on toinen kysymys, kuinka saada täydelliset käyttäjätiedot sen jälkeen, kun käyttäjätunnus on saatu jwt-todennussuodattimesta?

Tässä käytetään redis:tä, kun palvelin todentaa käyttäjätunnuksen avulla jwt:n käyttöliittymään, käyttäjätunnusta käytetään avaimena ja käyttäjän tiedot tallennetaan arvona redisistä käyttäjätunnuksen kautta.

2.3 Ratkaise ongelma

2.3.1 Idea-analyysi

Yllä olevien periaatteiden alustavan selvityksen perusteella olemme myös karkeasti analysoineet, mitä meidän tulee tehdä, jos toteutamme etupään ja takapään erottelun autentikointiprosessin itse.

Kirjaudu sisään:

a. Mukautettu kirjautumisliittymä

Kutsu ProviderManager-menetelmä todennusta varten. Jos todennus onnistuu, jwt luodaan.

Tallenna käyttäjätiedot redisiin

b. Mukauta UserDetailsService

Tee kysely tämän toteutusluokan tietokannasta

tarkistaa:

a. Mukauta jwt-todennussuodatinta

Hanki tunnus

Jäsennä tunnus saadaksesi sen käyttäjätunnuksen

Hanki täydelliset käyttäjätiedot redisiltä

Tallenna SecurityContextHolderissa

2.3.2 Valmistelu

Ensin sinun on lisättävä vastaavat riippuvuudet

  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>

Sitten meidän on käytettävä Redistä ja lisättävä Redikseen liittyvät kokoonpanot.

Ensimmäinen on FastJsonin serialisointi

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

Luo RedisConfig ja luo siihen serialisoija ongelmien, kuten sotkuisten merkkien, ratkaisemiseksi.

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

On myös tarpeen yhtenäistää vastausluokka

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

Tarvitset jwt-työkaluluokat jwt:n luomiseen ja jwt:n jäsentämiseen.

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

Määrittele toinen Redis-työkaluluokka RedisCache, jonka avulla meidän on helpompi kutsua redistemplatea

  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.

Saatamme myös kirjoittaa tietoja vastaukseen, joten tarvitsemme myös työkaluluokan 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. }

Kirjoita lopuksi vastaava käyttäjäentiteettiluokka

  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.

Yllä olevan analyysimme mukaan meidän on mukautettava UserDetailsService, jotta SpringSecuriry voi käyttää UserDetailsServiceä. Oma UserDetailsServicemme voi tiedustella käyttäjätunnusta ja salasanaa tietokannasta.

Luomme ensin tietokantataulukon 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='用户表';

Esittele sitten myBatisPlus- ja mysql-ajurit.

  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>

Määritä sitten tietokannan olennaiset tiedot.

Määritä sitten kartoittajan käyttöliittymä UserMapper ja lisää vastaavat huomautukset mybatisplus-ohjelmalla.

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

Määritä sitten komponenttien skannaus

Lopuksi testaa, voiko mp:tä käyttää normaalisti.

Esittele junit

Näin sitä voidaan käyttää normaalisti.

2.3.3 Toteutus

2.3.3.1 Tietokannan vahvistuskäyttäjä

Seuraavaksi meidän on otettava käyttöön ydinkoodi.

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

Tässä käyttäjä kapseloidaan UserDetails-muodossa ja palautetaan.

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

Lopuksi tässä on asia, eli meidän on suoritettava sisäänkirjautumistesti saadaksemme tietoja tietokannasta. Meidän on kirjoitettava käyttäjätiedot taulukkoon, ja jos haluat, että käyttäjän salasana lähetetään selkeänä tekstinä , sinun on lisättävä {noop} ennen salasanaa.

Täällä voit syöttää käyttäjätunnuksen ja salasanan tietokantaan kirjautuaksesi sisään.

2.3.3.2 Salasanasalattu tallennustila

Puhutaanpa siitä, miksi salasanan eteen lisätään {noop}, koska oletusarvoinen PasswordEncoder vaatii tietokannan salasanamuodon olevan {id}salasana. Se määrittää salasanan salausmenetelmän tunnuksen perusteella, mutta me yleensä Älä käytä tätä menetelmää, joten PasswordEncoder on vaihdettava.

Seuraavaksi testataan ja katsotaan.

Näet, että tässä antamamme kaksi alkuperäistä salasanaa ovat samat, mutta saimme erilaisia ​​​​tuloksia. Tämä liittyy itse asiassa suolausalgoritmiin. Kirjoitan myös artikkelin mukautetusta salauksesta.

Kun olet saanut salatun salasanan, voit tallentaa salatun salasanan tietokantaan. Tämän jälkeen voit kirjautua sisään tarkistamalla käyttöliittymästä välitetyn selkeän salasanan tietokannassa olevalla salatulla salasanalla.

Tässä vaiheessa aloitimme sisäänkirjautumisprojektin ja huomasimme, että emme voi enää kirjautua sisään aiemmalla salasanalla, koska tietokantaan pitäisi tallentaa rekisteröitymisvaiheessa tietokantaan tallennettu salattu salasana, ei alkuperäinen salasana (koska minä ei rekisteröitynyt, salaan salasanan) Salasana kirjoitetaan tietokantaan itsestään).

2.3.3.3 Kirjautumisliittymä

Meidän on otettava käyttöön kirjautumisrajapinta ja annettava SpringSecurutyn sallia se. Jos se ei ole sallittua, se on ristiriitainen. SecurityConfigin säilöön.

Jos todennus onnistuu, jwt on luotava ja lisättävä vastaukseen, jotta käyttäjä voi tunnistaa tietyn käyttäjän jwt:n kautta seuraavan pyynnön tehdessään, käyttäjätiedot on tallennettava redikseen ja käyttäjä. ID:tä voidaan käyttää avaimena.

Kirjoita ensin LoginController

Kirjoita sitten vastaava palvelu.

Lisää AuthenticationManager SecurityConfigiin ja vapauta kirjautumisliittymä.

Palvelun liiketoimintalogiikassa jos todennus epäonnistuu, palautetaan mukautettu poikkeus, mutta jos todennus onnistuu, miten saamme vastaavat tiedot.

Täällä voimme tehdä virheenkorjauksen ja nähdä saadut objektit.

Tästä selviää, että vastaavat vaaditut tiedot ovat saatavissa Rehtorilta.

Täytä sitten koodi.

Lopuksi testaa sitä.

2.3.3.4 Todennussuodatin

Liitän koodin ensin.

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

Ensinnäkin, saadaksemme tunnuksen tänne, saamme vastaavan tunnuksen pyynnön otsikosta ja tarkistamme sen olevan tyhjä. Jos se on tyhjä, vapautamme sen suoraan ilman seurantaprosessia jäsentää tunnuksen, saa käyttäjätunnuksen sisään ja sitten käyttäjätunnuksen perusteella hankkii vastaavat käyttäjätiedot redisistä ja tallentaa ne lopuksi SecurityContextHolderiin, koska myöhempien suodattimien on hankittava siitä päivittäiset todennustiedot ja suoritettava lopuksi analyysi. toiminnot.

Toinen huomioitava seikka on se, että SecurityContextHolder.getContext().setAuthentication():n on läpäistävä todennusobjekti.

Seuraavaksi meidän on määritettävä tämä suodatin.

Sitten kun käytämme käyttäjä/kirjautumisliittymää, meille palautetaan vastausteksti, jossa on token. Kun siirrymme uudelleen hello-käyttöliittymään, se on 403. Koska se ei sisällä merkkiä, se vastaa yllä olevaa koodia. Ilman merkkiä vastauksen runko vapautetaan, eikä palautus suorita seuraavaa prosessia (vapautus johtuu siitä, että on olemassa muita suodattimia, jotka antavat poikkeuksia myöhempää käsittelyä varten, ja palautuksen tarkoituksena on estää sitä kulkemasta vastauksen läpi. käsitellä asiaa)

Tällä hetkellä, jos laitamme käyttäjän/sisäänkirjautumisen luoman tunnuksen hello-käyttöliittymän pyyntöotsikkoon, voimme käyttää sitä normaalisti.

Sitten suodatinsarjamme tarkoitus on saavutettu (tokenien hankkiminen, tunnisteiden jäsentäminen ja niiden tallentaminen SecurityContextHolderiin)

2.3.3.5 Kirjaudu ulos

Tässä vaiheessa meidän on helpompi kirjautua ulos Redis-sovelluksesta et saa sitä, se tarkoittaa, että et ole kirjautunut sisään.

Käytämme tätä merkkiä käyttääksemme /user/logout-käyttöliittymää.

Sitten uloskirjautumistoiminto toteutetaan.

Tämä artikkeli opittiin aseman b kolmannesta päivityksestä! ! !

Henkilökohtainen profiili

Hän on omistautunut teknologian tutkimukselle yli 30 vuoden ajan ja hallitsee useita kieliä, kuten java, linux, javascript, php, css jne. Hän on tehnyt paljon työtä avoimen lähdekoodin alalla Kehittäjän dokumentaatioasema jakaaksesi joitain teknologian kehittämisen ongelmia tulevaa käyttöä varten

yhteystietoni

Mail