Berbagi teknologi

Kerangka SpringSecurity [Otentikasi]

2024-07-12

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

Daftar isi

1. Mulai Cepat

2. Sertifikasi

2.1 Proses verifikasi masuk

2.2 Eksplorasi awal prinsip tersebut

2.3 Memecahkan masalah

2.3.1 Analisis ide

2.3.2 Persiapan

2.3.3 Implementasi

2.3.3.1 Pengguna verifikasi basis data

2.3.3.2 Penyimpanan terenkripsi kata sandi

2.3.3.3 Antarmuka masuk

2.3.3.4 Filter otentikasi

2.3.3.5 Keluar

Spring Security adalah kerangka manajemen keamanan dalam keluarga Spring. Dibandingkan dengan Shiro, kerangka keamanan lainnya, Spring Security menyediakan fungsi yang lebih kaya dan sumber daya komunitas yang lebih kaya daripada Shiro.

Secara umum, Spring Security lebih umum digunakan pada proyek skala besar, dan Shiro lebih umum digunakan pada proyek kecil, karena dibandingkan dengan Spring Security, Shiro lebih mudah untuk memulai.

Aplikasi web umum memerlukannyaSertifikasiDanMengizinkan。

  • Otentikasi: Verifikasi apakah pengguna saat ini yang mengakses sistem adalah pengguna sistem, dan konfirmasikan pengguna yang mana.
  • Otorisasi: Setelah autentikasi, tentukan apakah pengguna saat ini memiliki izin untuk melakukan suatu operasi

Otentikasi dan otorisasi adalah fungsi inti Spring Security sebagai kerangka keamanan!

1. Mulai Cepat

Pertama-tama mari kita buat proyek SpringBoot.

Saat ini, kami mengakses antarmuka hello sederhana yang kami tulis untuk memverifikasi apakah konstruksi berhasil.

Kemudian perkenalkan SpringSecurity.

Saat ini, mari kita lihat efek antarmuka akses.

Setelah SpringSecurity diperkenalkan, antarmuka akses akan secara otomatis melompat ke halaman login. Nama pengguna default adalah pengguna, dan kata sandi akan dikeluarkan ke konsol.

2. Sertifikasi

2.1 Proses verifikasi masuk

Pertama-tama, kita perlu memahami proses verifikasi login. Pertama, front end membawa nama pengguna dan kata sandi untuk mengakses antarmuka login. Setelah server mendapatkan nama pengguna dan kata sandi, server membandingkannya dengan yang ada di database. Jika nama pengguna/ID pengguna digunakan dengan benar, jwt dibuat, lalu Tanggapi jwt ke ujung depan, dan kemudian akses permintaan lain setelah masuk akan membawa token di header permintaan header permintaan untuk parsing, memperoleh UserID, dan memperoleh informasi terkait pengguna dan izin pemirsa berdasarkan id nama pengguna, jika Jika Anda memiliki izin, tanggapi ke ujung depan.

2.2 Eksplorasi awal prinsip tersebut

Prinsip SpringSecurity sebenarnya adalah rantai filter, yang menyediakan filter dengan berbagai fungsi. Di sini pertama-tama kita melihat filter yang terlibat dalam mulai cepat di atas.

  • UsernamePasswordAuthenticationFilter bertanggung jawab untuk memproses permintaan login setelah mengisi username dan password pada halaman login.
  • ExceptionTranslationFilter menangani AccessDeniedException dan AuthenticationException apa pun yang dimasukkan ke dalam rantai filter
  • FilterSecurityInterceptor adalah filter yang bertanggung jawab untuk verifikasi izin

Kita juga dapat menggunakan Debug untuk melihat filter mana yang ada dalam rantai filter SpringSecurity di sistem saat ini dan urutannya.

Selanjutnya, mari kita lihat analisis diagram alur otentikasi.

Di sini kita hanya perlu bisa memahami prosesnya.

Pengguna mengirimkan nama pengguna dan kata sandi, UsernamePasswordAuthenticationFilter merangkumnya sebagai objek Otentikasi, dan memanggil metode autentikasi untuk autentikasi. Kemudian memanggil metode autentikasi DaoAuthenticationProvider untuk autentikasi, dan kemudian memanggil metode loadUserByUserName untuk menanyakan kueri pengguna di sini adalah mencari di memori, lalu Enkapsulasi informasi pengguna yang sesuai ke dalam objek UserDetails, gunakan PasswordEncoder untuk membandingkan kata sandi di UserDetails dan kata sandi Otentikasi untuk melihat apakah sudah benar. Jika benar, atur informasi izin di UserDetails ke objek Otentikasi , lalu kembalikan objek Otentikasi, dan terakhir gunakan metode SecurityContextHolder.getContext().setAuthentication menyimpan objek ini, dan filter lain akan memperoleh informasi pengguna saat ini melalui SecurityContextHoder. (Anda tidak perlu menghafal paragraf ini untuk memahaminya)

Kemudian kita mengetahui prosesnya sebelum kita dapat memodifikasinya. Pertama-tama, ketika mencari dari memori, kita harus mencari dari database (di sini kita perlu menyesuaikan kelas implementasi UserDetailsService), dan kita tidak akan menggunakan nama pengguna dan kata sandi default. , dan antarmuka login harus ditulis sendiri, dan tidak perlu menggunakan halaman login default yang disediakan olehnya.

Berdasarkan situasi yang kami analisis, kami mendapatkan gambaran seperti itu.

Saat ini, jwt dikembalikan ke front end. Saat ini, permintaan lain yang dibuat oleh front end akan membawa token. Jadi, langkah pertama kita adalah memverifikasi apakah token tersebut dibawa, mengurai token, dan mendapatkan userid yang sesuai , dan merangkumnya sebagai objek Anthentication disimpan di SecurityContextHolder (sehingga filter lain bisa mendapatkannya).

Jadi ada pertanyaan lain di sini. Bagaimana cara mendapatkan informasi pengguna yang lengkap setelah mendapatkan userid dari filter otentikasi jwt?

Di sini kita menggunakan redis. Ketika server mengautentikasi dengan menggunakan ID pengguna untuk menghasilkan jwt ke front end, ID pengguna digunakan sebagai kunci dan informasi pengguna disimpan dalam redis sebagai nilainya dari redis melalui userid.

2.3 Memecahkan masalah

2.3.1 Analisis ide

Dari eksplorasi awal prinsip-prinsip di atas, kami juga telah menganalisis secara kasar apa yang perlu kami lakukan jika kami menerapkan sendiri proses otentikasi pemisahan front-end dan back-end.

Gabung:

a.antarmuka masuk khusus

Panggil metode ProviderManager untuk autentikasi. Jika autentikasi lolos, jwt akan dibuat.

Simpan informasi pengguna di redis

b. Sesuaikan Layanan Detail Pengguna

Kueri database di kelas implementasi ini

memeriksa:

a. Sesuaikan filter otentikasi jwt

Dapat token

Parsing token untuk mendapatkan userid-nya

Dapatkan informasi pengguna lengkap dari redis

Simpan di SecurityContextHolder

2.3.2 Persiapan

Pertama, Anda perlu menambahkan dependensi yang sesuai

  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>

Kemudian kita perlu menggunakan Redis dan menambahkan konfigurasi terkait Redis.

Pertama adalah serializer 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. }

Buat RedisConfig dan buat serializer di dalamnya untuk menyelesaikan masalah seperti karakter yang kacau.

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

Penting juga untuk menyatukan kelas respons

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

Anda memerlukan kelas alat jwt untuk menghasilkan jwt dan mengurai 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. }

Tentukan kelas alat Redis lainnya, RedisCache, yang memudahkan kita memanggil 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.

Kita juga dapat menulis data untuk responnya, jadi kita juga memerlukan alat kelas 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. }

Terakhir, tulis kelas entitas pengguna yang sesuai

  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.

Berdasarkan analisis kami di atas, kami perlu menyesuaikan UserDetailsService agar SpringSecuriry menggunakan UserDetailsService kami. UserDetailsService kami sendiri dapat menanyakan nama pengguna dan kata sandi dari database.

Pertama-tama kita membuat tabel 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='用户表';

Kemudian perkenalkan driver myBatisPlus dan 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>

Kemudian konfigurasikan informasi yang relevan dari database.

Kemudian tentukan antarmuka mapper UserMapper dan gunakan mybatisplus untuk menambahkan anotasi yang sesuai.

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

Kemudian konfigurasikan pemindaian komponen

Terakhir tes apakah mp dapat digunakan secara normal.

Perkenalkan Junit

Dengan cara ini dapat digunakan secara normal.

2.3.3 Implementasi

2.3.3.1 Pengguna verifikasi basis data

Selanjutnya kita perlu mengimplementasikan kode inti.

Pertama, mari kita sesuaikan 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. }

Di sini pengguna dienkapsulasi sebagai UserDetails dan dikembalikan.

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

Terakhir, ada satu hal di sini, yaitu kita perlu melakukan tes login untuk mendapatkan data dari database. Kita perlu menulis data pengguna ke dalam tabel, dan jika Anda ingin kata sandi pengguna dikirimkan dalam bentuk teks yang jelas , Anda perlu menambahkan {noop} sebelum kata sandi.

Di sini Anda dapat memasukkan nama pengguna dan kata sandi ke dalam database untuk login.

2.3.3.2 Penyimpanan terenkripsi kata sandi

Mari kita bahas mengapa {noop} harus ditambahkan di depan kata sandi, karena PasswordEncoder default memerlukan format kata sandi dalam database menjadi {id}kata sandi. Ini akan menentukan metode enkripsi kata sandi berdasarkan id, tapi kami umumnya tidak menggunakan metode ini, jadi PasswordEncoder perlu diganti.

Selanjutnya kita akan mengujinya dan melihat.

Anda dapat melihat bahwa dua kata sandi asli yang kami berikan di sini sama, tetapi kami mendapatkan hasil yang berbeda. Ini sebenarnya terkait dengan algoritma pengasinan. Saya akan menulis artikel tentang enkripsi khusus nanti.

Setelah mendapatkan kata sandi terenkripsi, Anda dapat menyimpan kata sandi terenkripsi di database. Kemudian Anda dapat masuk dengan memverifikasi kata sandi teks biasa yang dikirimkan dari ujung depan dengan kata sandi terenkripsi di database.

Saat ini, kami memulai proyek untuk masuk, dan menemukan bahwa kami tidak dapat lagi masuk dengan kata sandi sebelumnya, karena database harus menyimpan kata sandi terenkripsi yang disimpan dalam database pada tahap pendaftaran, bukan kata sandi asli (karena saya tidak mendaftar, saya akan mengenkripsi kata sandinya) Kata sandi itu ditulis ke dalam database dengan sendirinya).

2.3.3.3 Antarmuka masuk

Kita perlu mengimplementasikan antarmuka login dan kemudian membiarkan SpringSecuruty mengizinkannya. Jika tidak diizinkan, itu akan bertentangan. Di antarmuka, otentikasi pengguna dilakukan melalui metode otentikasi AuthenticationManager, jadi kita perlu mengkonfigurasi AuthenticationManager yang akan disuntikkan. ke dalam wadah di SecurityConfig.

Jika otentikasi berhasil, jwt perlu dibuat dan dimasukkan ke dalam respons. Agar pengguna dapat mengidentifikasi pengguna tertentu melalui jwt saat membuat permintaan berikutnya, informasi pengguna perlu disimpan di redis, dan pengguna harus disimpan di redis. ID dapat digunakan sebagai kunci.

Tulis LoginController terlebih dahulu

Kemudian tulis Layanan yang sesuai.

Suntikkan AuthenticationManager di SecurityConfig dan lepaskan antarmuka login.

Dalam logika bisnis di layanan, jika otentikasi gagal, pengecualian khusus akan dikembalikan, tetapi jika otentikasi berhasil, bagaimana kita mendapatkan informasi terkait.

Di sini kita dapat melakukan debug dan melihat objek yang diperoleh.

Di sini ditemukan bahwa informasi terkait yang diperlukan dapat diperoleh dari Kepala Sekolah.

Kemudian lengkapi kodenya.

Terakhir, ujilah.

2.3.3.4 Filter otentikasi

Saya akan menempelkan kodenya terlebih dahulu.

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

Pertama-tama untuk mendapatkan token disini, kita ambil token yang sesuai dari header permintaan, lalu periksa apakah kosong, jika kosong kita akan langsung melepaskannya tanpa melalui proses lanjutan akan mengurai token, mendapatkan userid di dalamnya, dan kemudian berdasarkan userid. Dapatkan informasi pengguna yang sesuai dari redis, dan terakhir simpan di SecurityContextHolder, karena filter selanjutnya perlu mendapatkan informasi otentikasi harian darinya, dan akhirnya melakukan analisis. operasi.

Hal lain yang perlu diperhatikan adalah SecurityContextHolder.getContext().setAuthentication() perlu meneruskan objek otentikasi. Saat kita membuat objek, kita menggunakan tiga parameter, karena parameter ketiga adalah kunci untuk menentukan apakah akan mengautentikasi atau tidak.

Selanjutnya kita perlu mengkonfigurasi filter ini.

Kemudian ketika kita mengakses antarmuka pengguna/login, badan respons dengan token akan dikembalikan kepada kita. Ketika kita mengakses antarmuka hello lagi, itu akan menjadi 403. Karena tidak membawa token, maka sesuai dengan kode di atas. Jika tidak ada token, isi respons akan dilepaskan dan pengembalian tidak akan menjalankan proses selanjutnya (Pelepasan di sini karena ada filter lain yang secara khusus memberikan pengecualian untuk diproses nanti, dan pengembalian adalah untuk mencegahnya melewatinya. proses respons)

Saat ini, jika kita memasukkan token yang dihasilkan oleh pengguna/login ke dalam header permintaan antarmuka hello, kita dapat mengaksesnya secara normal.

Maka tujuan dari kumpulan filter kami telah tercapai (mendapatkan token, menguraikan token, dan menyimpannya di SecurityContextHolder)

2.3.3.5 Keluar

Pada titik ini, lebih mudah bagi kami untuk keluar. Kami hanya perlu menghapus data terkait di redis. Saat kami membawa token untuk akses nanti, informasi pengguna terkait di redis akan diperoleh di filter khusus kami Jika tidak bisa, berarti Anda belum login.

Kami membawa token ini untuk mengakses antarmuka /user/logout.

Kemudian fungsi logout diimplementasikan.

Artikel ini dipelajari dari pembaruan ketiga stasiun b! ! !

Profil pribadi

Ia telah mengabdikan dirinya untuk meneliti teknologi selama lebih dari 30 tahun, dan mahir dalam berbagai bahasa seperti java, linux, javascript, php, css, dll. Ia telah memberikan banyak kontribusi di bidang open source stasiun dokumentasi pengembang untuk berbagi beberapa masalah dalam pengembangan teknologi untuk referensi di masa mendatang

informasi kontak saya

Surat