技術共有

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 ファミリーのセキュリティ管理フレームワークであり、別のセキュリティ フレームワークである Roku と比較すると、Shiro よりも豊富な機能と豊富なコミュニティ リソースを提供します。

一般に、Spring Security は大規模なプロジェクトで使用されることが多く、Shiro は Spring Security に比べて始めやすいため、小規模なプロジェクトで使用されることが多くなります。

一般的な Web アプリケーションでは、認証そして承認する。

  • 認証: システムにアクセスしている現在のユーザーがシステム ユーザーであるかどうかを検証し、どのユーザーであるかを確認します。
  • 認可: 認証後、現在のユーザーに操作を実行する権限があるかどうかを判断します。

認証と認可は、セキュリティ フレームワークとしての 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 を通じて現在のユーザー情報を取得します。 (この段落を理解するために暗記する必要はありません)

次に、変更する前にプロセスを把握します。まず、メモリから検索する場合はデータベースから検索する必要があり (ここでは UserDetailsS​​ervice 実装クラスをカスタマイズする必要があります)、デフォルトのユーザー名とパスワードは使用しません。 、ログイン インターフェイスは自分で作成する必要があり、彼が提供するデフォルトのログイン ページを使用する必要はありません。

私たちが分析した状況に基づいて、このようなイメージを得ることができます。

この時点で、jwt がフロントエンドに返され、フロントエンドによって行われた他のリクエストでトークンが送信されます。そのため、最初のステップは、トークンが送信されているかどうかを確認し、トークンを解析し、対応するユーザー ID を取得してカプセル化することです。 Anthentication オブジェクトとして SecurityContextHolder に保存されます (他のフィルターがそれを取得できるようにするため)。

ここで別の質問があります。jwt 認証フィルターからユーザー ID を取得した後、完全なユーザー情報を取得するにはどうすればよいですか?

ここでは redis を使用します。サーバーがユーザー ID を使用して認証を行い、フロントエンドに jwt を生成すると、ユーザー ID がキーとして使用され、ユーザーの情報が値として redis に保存されます。これにより、完全なユーザー情報が取得されます。 Redis からユーザー ID 経由で。

2.3 問題を解決する

2.3.1 アイデア分析

上記の原則の予備的な検討から、フロントエンドとバックエンドの分離の認証プロセスを独自に実装する場合に何をする必要があるかについても大まかに分析しました。

ログイン：

a. カスタムログインインターフェース

認証のために ProviderManager メソッドを呼び出します。認証が成功すると、jwt が生成されます。

ユーザー情報をredisに保存する

b. UserDetailsS​​ervice をカスタマイズする

この実装クラスでデータベースにクエリを実行します

チェック：

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

別の Redis ツール クラス RedisCache を定義します。これにより、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.

応答にデータを書き込むこともあるので、ツール クラス 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.

上記の分析によると、SpringSecurity が UserDetailsS​​ervice を使用できるように UserDetailsS​​ervice をカスタマイズする必要があります。独自の UserDetailsS​​ervice は、データベースからユーザー名とパスワードをクエリできます。

まず、データベース テーブル 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 データベース検証ユーザー

次に、コアコードを実装する必要があります。

まず、UserDetailsS​​ervice をカスタマイズしましょう。

  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 パスワード暗号化ストレージ

パスワードの前に {noop} が追加される理由について説明します。デフォルトの PasswordEncoder では、データベース内のパスワード形式が {id}password である必要がありますが、一般的には ID に基づいてパスワードの暗号化方式が決定されます。この方法は採用されていないため、PasswordEncoder を置き換える必要があります。

次にテストして確認してみます。

ここで渡した 2 つの元のパスワードは同じであることがわかりますが、これは実際にはソルティング アルゴリズムに関連しています。後でカスタム暗号化についても記事を書きます。

暗号化されたパスワードを取得したら、その暗号化されたパスワードをデータベースに保存し、フロントエンドから渡された平文のパスワードをデータベース内の暗号化されたパスワードと照合することでログインできます。

この時点で、ログインするプロジェクトを開始しましたが、以前のパスワードではログインできないことがわかりました。データベースには、元のパスワードではなく、登録フェーズ中にデータベースに保存された暗号化されたパスワードが保存される必要があるためです（登録しませんでした。パスワードを暗号化します) パスワードは自動的にデータベースに書き込まれます)。

2.3.3.3 ログインインターフェース

ログインインターフェースを実装して SpringSecurity に許可させる必要があります。これが許可されていない場合、インターフェースでは AuthenticationManager の認証メソッドを通じてユーザー認証が実行されるため、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. }

まず、ここでトークンを取得するために、リクエストヘッダーから対応するトークンを取得し、それが空であることを確認し、後続のプロセスを経ずに直接解放します。トークンを解析し、内部のユーザー ID を取得し、そのユーザー ID に基づいて対応するユーザー情報を Redis から取得し、最後に SecurityContextHolder に保存します。これは、後続のフィルターがそこから毎日の認証情報を取得し、最後に分析を実行する必要があるためです。オペレーション。

もう 1 つの注意が必要な点は、SecurityContextHolder.getContext().setAuthentication() が認証オブジェクトを渡す必要があることです。これは、3 番目のパラメーターが認証するかどうかを決定するキーであるためです。

次に、このフィルターを構成する必要があります。

その後、ユーザー/ログイン インターフェイスにアクセスすると、トークンを含む応答本文が返されます。hello インターフェイスに再度アクセスすると、403 になります。トークンが含まれていないため、上記のコードに対応します。トークンがないと、応答本文は解放され、リターンは後続のプロセスを実行しません (ここでの解放は、後で処理するために特別に例外をスローする他のフィルターがあるためであり、リターンは応答を通過しないようにするためです。プロセス）

このとき、user/loginが生成したトークンをhelloインターフェースのリクエストヘッダに入れると正常にアクセスできるようになります。

これで、一連のフィルターの目的が達成されました (トークンの取得、トークンの解析、およびそれらの SecurityContextHolder への保管)。

2.3.3.5 ログアウト

この時点で、redis 内の対応するデータを削除するだけで済みます。後でアクセスするために、redis 内の対応するユーザー情報がカスタム フィルターで取得されます。取得できない場合は、ログインしていないことを意味します。

/user/logout インターフェイスにアクセスするためにこのトークンを運びます。

次に、ログアウト機能が実装されます。

この記事はb局の第3回更新で知りました！ ！ ！

個人プロフィール

彼は 30 年以上テクノロジーの研究に専念しており、java、linux、javascript、php、css などのさまざまな言語に堪能であり、オープンソース分野で多くの貢献を行っています。将来の参考のために技術開発におけるいくつかの問題を共有する開発者ドキュメント ステーション。

プライベートな連絡先の最初の情報

送料