SpringSecurity Framework [Authentifizierung]

2024-07-12

Inhaltsverzeichnis

1. Schnellstart

2. Zertifizierung

2.1 Anmeldebestätigungsprozess

2.2 Vorläufige Untersuchung des Prinzips

2.3 Lösen Sie das Problem

2.3.1 Ideenanalyse

2.3.2 Vorbereitung

2.3.3 Umsetzung

2.3.3.1 Benutzer der Datenbanküberprüfung

2.3.3.2 Passwortverschlüsselter Speicher

2.3.3.3 Login-Schnittstelle

2.3.3.4 Authentifizierungsfilter

2.3.3.5 Abmelden

Spring Security ist ein Sicherheitsmanagement-Framework der Spring-Familie und bietet im Vergleich zu Shiro, einem anderen Sicherheits-Framework, umfangreichere Funktionen und umfangreichere Community-Ressourcen.

Im Allgemeinen wird Spring Security häufiger in Großprojekten und Shiro häufiger in kleinen Projekten verwendet, da Shiro im Vergleich zu Spring Security einfacher zu verwenden ist.

Allgemeine Webanwendungen müssenZertifizierungUndAutorisieren。

Authentifizierung: Überprüfen Sie, ob der aktuelle Benutzer, der auf das System zugreift, der Systembenutzer ist, und bestätigen Sie, um welchen Benutzer es sich handelt.
Autorisierung: Stellen Sie nach der Authentifizierung fest, ob der aktuelle Benutzer berechtigt ist, einen Vorgang auszuführen

Authentifizierung und Autorisierung sind die Kernfunktionen von Spring Security als Sicherheitsframework!

1. Schnellstart

Lassen Sie uns zunächst einfach ein SpringBoot-Projekt erstellen.

Zu diesem Zeitpunkt greifen wir auf eine einfache Hallo-Schnittstelle zu, die wir geschrieben haben, um zu überprüfen, ob die Konstruktion erfolgreich ist.

Dann stellen Sie SpringSecurity vor.

Schauen wir uns zu diesem Zeitpunkt die Auswirkungen der Zugriffsschnittstelle an.

Nach der Einführung von SpringSecurity springt die Zugriffsoberfläche automatisch zu einer Anmeldeseite und das Kennwort wird an die Konsole ausgegeben. Sie müssen sich anmelden, um auf die Schnittstelle zuzugreifen.

2. Zertifizierung

2.1 Anmeldebestätigungsprozess

Zunächst müssen wir den Anmeldeüberprüfungsprozess verstehen. Zuerst übermittelt das Frontend den Benutzernamen und das Kennwort, um auf die Anmeldeschnittstelle zuzugreifen. Nachdem der Server den Benutzernamen und das Kennwort erhalten hat, vergleicht er diese mit denen in der Datenbank. Wenn der Benutzername/die Benutzer-ID korrekt verwendet wird, wird ein JWT generiert, und dann antwortet der JWT an das Front-End und greift dann nach der Anmeldung auf andere Anforderungen zu. Jedes Mal, wenn der Server das Token erhält, wird es im Anforderungsheader angezeigt Analysieren Sie den Anforderungsheader, rufen Sie die Benutzer-ID ab und erhalten Sie benutzerbezogene Informationen und Betrachterberechtigungen basierend auf der Benutzernamen-ID. Wenn Sie über die entsprechende Berechtigung verfügen, antworten Sie dem Front-End.

2.2 Vorläufige Untersuchung des Prinzips

Das Prinzip von SpringSecurity ist eigentlich eine Filterkette, die Filter mit verschiedenen Funktionen bereitstellt. Hier betrachten wir zunächst die beteiligten Filter im obigen Schnellstart.

UsernamePasswordAuthenticationFilter ist für die Verarbeitung von Anmeldeanfragen verantwortlich, nachdem der Benutzername und das Kennwort auf der Anmeldeseite eingegeben wurden.
ExceptionTranslationFilter behandelt alle in der Filterkette ausgelösten AccessDeniedException und AuthenticationException
FilterSecurityInterceptor ist ein Filter, der für die Berechtigungsüberprüfung verantwortlich ist

Wir können Debug auch verwenden, um zu sehen, welche Filter sich in der SpringSecurity-Filterkette im aktuellen System befinden und in welcher Reihenfolge.

Schauen wir uns als Nächstes die Analyse des Authentifizierungsflussdiagramms an.

Hier müssen wir nur in der Lage sein, den Prozess zu verstehen:

Der Benutzer hat den Benutzernamen und das Kennwort übermittelt, UsernamePasswordAuthenticationFilter kapselt es als Authentifizierungsobjekt und ruft die Authentifizierungsmethode von DaoAuthenticationProvider zur Authentifizierung auf und ruft dann die LoadUserByUserName-Methode auf, um den Benutzer abzufragen besteht darin, im Speicher zu suchen und dann die entsprechenden Benutzerinformationen in ein UserDetails-Objekt zu kapseln. Verwenden Sie PasswordEncoder, um das Kennwort in UserDetails und das Authentifizierungskennwort zu vergleichen, um festzustellen, ob es korrekt ist, und legen Sie die Berechtigungsinformationen in UserDetails für das Authentifizierungsobjekt fest Geben Sie dann das Authentifizierungsobjekt zurück und verwenden Sie schließlich SecurityContextHolder.getContext(). Die setAuthentication-Methode speichert dieses Objekt, und andere Filter erhalten die aktuellen Benutzerinformationen über SecurityContextHoder. (Sie müssen diesen Absatz nicht auswendig lernen, um ihn zu verstehen)

Dann kennen wir den Prozess, bevor wir ihn ändern können. Wenn wir aus dem Speicher suchen, müssen wir zunächst in der Datenbank suchen (hier müssen wir eine UserDetailsService-Implementierungsklasse anpassen) und verwenden nicht den Standardbenutzernamen und das Kennwort Die Anmeldeschnittstelle muss von Ihnen selbst geschrieben werden und es besteht keine Notwendigkeit, die von ihm bereitgestellte Standardanmeldeseite zu verwenden.

Basierend auf der von uns analysierten Situation können wir uns ein solches Bild machen.

Zu diesem Zeitpunkt wird ein JWT an das Front-End zurückgegeben, und andere vom Front-End gestellte Anforderungen übertragen das Token. Unser erster Schritt besteht also darin, zu prüfen, ob das Token übertragen wird, das Token zu analysieren, die entsprechende Benutzer-ID abzurufen und zu kapseln es als Das Anthentication-Objekt wird im SecurityContextHolder gespeichert (damit andere Filter es abrufen können).

Hier stellt sich also eine weitere Frage: Wie erhalte ich vollständige Benutzerinformationen, nachdem ich die Benutzer-ID vom JWT-Authentifizierungsfilter erhalten habe?

Hier verwenden wir Redis. Wenn der Server die Benutzer-ID zum Generieren von JWT authentifiziert, wird die Benutzer-ID als Schlüssel verwendet und die Benutzerinformationen werden in Redis als Wert gespeichert. Anschließend können die vollständigen Benutzerinformationen abgerufen werden von Redis über die Benutzer-ID.

2.3 Lösen Sie das Problem

2.3.1 Ideenanalyse

Aus der vorläufigen Untersuchung der oben genannten Prinzipien haben wir auch grob analysiert, was wir tun müssen, wenn wir den Authentifizierungsprozess der Front-End- und Back-End-Trennung selbst implementieren.

Anmeldung:

a. Benutzerdefinierte Anmeldeschnittstelle

Rufen Sie die ProviderManager-Methode zur Authentifizierung auf. Wenn die Authentifizierung erfolgreich ist, wird ein JWT generiert.

Speichern Sie Benutzerinformationen in Redis

b. Passen Sie UserDetailsService an

Fragen Sie die Datenbank in dieser Implementierungsklasse ab

überprüfen:

a. Passen Sie den JWT-Authentifizierungsfilter an

Bekomme Token

Analysieren Sie das Token, um seine Benutzer-ID zu erhalten

Erhalten Sie vollständige Benutzerinformationen von Redis

Im SecurityContextHolder speichern

2.3.2 Vorbereitung

Zuerst müssen Sie die entsprechenden Abhängigkeiten hinzufügen


        <!--   SpringSecurity启动器     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
 
        <!--   redis依赖     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--   fastjson依赖     -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.33</version>
        </dependency>
        <!--   jwt依赖     -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>

Dann müssen wir Redis verwenden und Redis-bezogene Konfigurationen hinzufügen.

Erstens ist der Serialisierer von FastJson


package org.example.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
 
import java.nio.charset.Charset;
 
/**
 * Redis使用fastjson序列化
 * @param <T>
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
 
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 
    private Class<T> clazz;
 
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
 
    public FastJsonRedisSerializer(Class<T> clazz){
        super();
        this.clazz=clazz;
    }
    
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null){
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }
 
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes==null || bytes.length<=0){
            return null;
        }
        String str = new String(bytes,DEFAULT_CHARSET);
 
        return JSON.parseObject(str,clazz);
    }
 
    protected JavaType getJavaType(Class<?> clazz){
        return TypeFactory.defaultInstance().constructType(clazz);
    }
    
}

Erstellen Sie RedisConfig und erstellen Sie darin einen Serializer, um Probleme wie verstümmelte Zeichen zu lösen.


package org.example.config;
import org.example.utils.FastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings(value = {"unchecked","rawtypes"})
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<Object,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
 
        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
 
        //使用StringRedisSerializer来序列化和反序列化redus的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
 
        template.afterPropertiesSet();
        return template;
    }
}

Es ist auch notwendig, die Antwortklasse zu vereinheitlichen


package org.example.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult<T>{
    /**
     * 状态码
     */
    private Integer code;
    /**
     * 提示信息，如果有错误时，前端可以获取该字段进行提示
     */
    private String msg;
    /**
     * 查询到的结果数据
     */
    private T data;
 
    public ResponseResult(Integer code,String msg){
        this.code = code;
        this.msg = msg;
    }
 
    public ResponseResult(Integer code,T data){
        this.code = code;
        this.data = data;
    }
 
    public Integer getCode() {
        return code;
    }
 
    public void setCode(Integer code) {
        this.code = code;
    }
 
    public String getMsg() {
        return msg;
    }
 
    public void setMsg(String msg) {
        this.msg = msg;
    }
 
    public T getData() {
        return data;
    }
 
    public void setData(T data) {
        this.data = data;
    }
 
    public ResponseResult(Integer code,String msg,T data){
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

Sie benötigen JWT-Toolklassen, um JWT zu generieren und JWT zu analysieren.


package org.example.utils;
 
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
 
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;
 
public class JwtUtil {
 
    //有效期为
    public static final Long JWT_TTL = 60*60*1000L; //一个小时
    //设置密钥明文
    public static final String JWT_KEY = "hzj";
 
    public static String getUUID(){
        String token = UUID.randomUUID().toString().replaceAll("-","");
        return token;
    }
 
    /**
     * 生成jwt
     * @param subject token中要存放的数据（json格式）
     * @return
     */
    public static String createJWT(String subject){
        JwtBuilder builder = getJwtBuilder(subject,null,getUUID()); //设置过期时间
        return builder.compact();
    }
 
    /**
     * 生成jwt
     * @param subject token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     * @return
     */
    public static String createJWT(String subject,Long ttlMillis){
        JwtBuilder builder = getJwtBuilder(subject,ttlMillis,getUUID()); //设置过期时间
        return builder.compact();
    }
 
    private static JwtBuilder getJwtBuilder(String subject,Long ttlMillis,String uuid){
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalkey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if(ttlMillis==null){
            ttlMillis=JwtUtil.JWT_TTL;
        }
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        return Jwts.builder()
                .setId(uuid) //唯一的Id
                .setSubject(subject) //主题 可以是Json数据
                .setIssuer("hzj") //签发者
                .setIssuedAt(now) //签发时间
                .signWith(signatureAlgorithm,secretKey) //使用HS256对称加密算法签名，第二个参数为密钥
                .setExpiration(expDate);
    }
 
    /**
     * 创建token
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public static String createJWT(String id,String subject,Long ttlMillis){
        JwtBuilder builder = getJwtBuilder(subject,ttlMillis,id);//设置过期时间
        return builder.compact();
    }
 
    public static void main(String[] args) throws Exception{
        String token =
"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1OTg0MjU5MzIsInVzZX" +
"JJZCI6MTExLCJ1c2VybmFtZSI6Ik1hcmtaUVAifQ.PTlOdRG7ROVJqPrA0q2ac7rKFzNNFR3lTMyP_8fIw9Q";
        Claims claims = parseJWT(token);
        System.out.println(claims);
    }
 
    /**
     * 生成加密后的密钥secretkey
     * @return
     */
    public static SecretKey generalkey(){
        byte[] encodeedkey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodeedkey,0,encodeedkey.length,"AES");
        return key;
    }
 
    /**
     * 解析
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception{
        SecretKey secretKey = generalkey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

Definieren Sie eine weitere Redis-Toolklasse RedisCache, die es uns erleichtert, Redistemplate aufzurufen


package org.example.utils;
 
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
 
import java.util.*;
import java.util.concurrent.TimeUnit;
 
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;
 
    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }
 
    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }
 
    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }
 
    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }
 
    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }
 
    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }
 
    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }
 
    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }
 
    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }
 
    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }
 
    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }
 
    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }
 
    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }
 
    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }
 
    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }
 
    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
}

Möglicherweise schreiben wir auch Daten in die Antwort, daher benötigen wir auch eine Toolklasse WebUtils


package org.example.utils;
 
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class WebUtils {
    /**
     * 将字符串渲染到客户端
     *
     * @param response 渲染对象
     * @param string 待渲染的字符串
     * @return null
     */
    public static String renderString(HttpServletResponse response, String string) {
        try
        {
            response.setStatus(200);
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return null;
    }
}

Schreiben Sie abschließend die entsprechende Benutzerentitätsklasse


package org.example.domain;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
 * 用户表(User)实体类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final long serialVersionUID = -40356785423868312L;
    /**
     * 主键
     */
    private Long id;
    /**
     * 用户名
     */
    private String userName;
    /**
     * 昵称
     */
    private String nickName;
    /**
     * 密码
     */
    private String password;
    /**
     * 账号状态（0正常 1停用）
     */
    private String status;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 手机号
     */
    private String phonenumber;
    /**
     * 用户性别（0男，1女，2未知）
     */
    private String sex;
    /**
     * 头像
     */
    private String avatar;
    /**
     * 用户类型（0管理员，1普通用户）
     */
    private String userType;
    /**
     * 创建人的用户id
     */
    private Long createBy;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新人
     */
    private Long updateBy;
    /**
     * 更新时间
     */
    private Date updateTime;
    /**
     * 删除标志（0代表未删除，1代表已删除）
     */
    private Integer delFlag;
}

Gemäß unserer obigen Analyse müssen wir einen UserDetailsService anpassen, damit SpringSecuriry unseren UserDetailsService verwenden kann. Unser eigener UserDetailsService kann den Benutzernamen und das Passwort aus der Datenbank abfragen.

Wir erstellen zunächst eine Datenbanktabelle sys_user.


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

Stellen Sie dann myBatisPlus- und MySQL-Treiber vor.


        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

Anschließend konfigurieren Sie die relevanten Informationen der Datenbank.

Definieren Sie dann die Mapper-Schnittstelle UserMapper und fügen Sie mit mybatisplus entsprechende Anmerkungen hinzu.


package org.example.mapper;
 
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.example.domain.User;
 
public interface UserMapper extends BaseMapper<User> {
}

Konfigurieren Sie dann das Scannen der Komponenten

Testen Sie abschließend, ob der MP normal verwendet werden kann.

Junit vorstellen

Auf diese Weise kann es normal verwendet werden.

2.3.3 Umsetzung

2.3.3.1 Benutzer der Datenbanküberprüfung

Als nächstes müssen wir den Kerncode implementieren.

Passen wir zunächst UserDetailsService an.


package org.example.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.example.domain.LoginUser;
import org.example.domain.User;
import org.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import java.util.Objects;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //查询用户信息 [InMemoryUserDetailsManager是在内存中查找]
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,username);
        User user = userMapper.selectOne(wrapper);
        //如果查询不到数据就抛出异常，给出提示
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名或密码错误!");
        }
 
        //TODO 查询权限信息
 
        //封装为UserDetails对象返回
        return new LoginUser(user);
    }
}

Hier wird der Benutzer als UserDetails gekapselt und zurückgegeben.


package org.example.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginUser implements UserDetails {
    private User user;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }
 
    @Override
    public String getPassword() {
        return user.getPassword();
    }
 
    @Override
    public String getUsername() {
        return user.getUserName();
    }
 
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
 
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
 
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
 
    @Override
    public boolean isEnabled() {
        return true;
    }
}

Schließlich gibt es hier noch einen Punkt: Wir müssen einen Anmeldetest durchführen, um Daten aus der Datenbank abzurufen. Wir müssen Benutzerdaten in die Tabelle schreiben und das Kennwort des Benutzers im Klartext übertragen , müssen Sie {noop} vor dem Passwort hinzufügen.

Hier können Sie den Benutzernamen und das Passwort in die Datenbank eingeben, um sich anzumelden.

2.3.3.2 Passwortverschlüsselter Speicher

Lassen Sie uns darüber sprechen, warum {noop} vor dem Passwort hinzugefügt wird, da der Standard-PasswordEncoder erfordert, dass das Passwortformat in der Datenbank {id}password ist. Es bestimmt die Verschlüsselungsmethode des Passworts basierend auf der ID, aber wir verwenden es im Allgemeinen Übernehmen Sie diese Methode nicht, daher muss PasswordEncoder ersetzt werden.

Als nächstes werden wir es testen und sehen.

Sie können sehen, dass die beiden ursprünglichen Passwörter, die wir hier eingegeben haben, gleich sind, aber wir haben unterschiedliche Ergebnisse erhalten. Dies hängt tatsächlich mit dem Salting-Algorithmus zusammen. Ich werde später auch einen Artikel über benutzerdefinierte Verschlüsselung schreiben.

Nachdem Sie das verschlüsselte Passwort erhalten haben, können Sie das verschlüsselte Passwort in der Datenbank speichern. Anschließend können Sie sich anmelden, indem Sie das vom Frontend übergebene Klartext-Passwort mit dem verschlüsselten Passwort in der Datenbank überprüfen.

Zu diesem Zeitpunkt starteten wir das Anmeldeprojekt und stellten fest, dass wir uns nicht mehr mit dem vorherigen Kennwort anmelden konnten, da die Datenbank das während der Registrierungsphase in der Datenbank gespeicherte verschlüsselte Kennwort und nicht das ursprüngliche Kennwort speichern sollte (weil ich nicht registriert, ich werde das Passwort verschlüsseln) Das Passwort wird von selbst in die Datenbank geschrieben).

2.3.3.3 Login-Schnittstelle

Wir müssen eine Anmeldeschnittstelle implementieren und diese dann von SpringSecurity zulassen lassen. Wenn dies nicht zulässig ist, erfolgt die Benutzerauthentifizierung über die Authentifizierungsmethode von AuthenticationManager. Daher müssen wir den AuthenticationManager für die Injektion konfigurieren in den Container in SecurityConfig.

Wenn die Authentifizierung erfolgreich ist, muss ein JWT generiert und in die Antwort eingefügt werden. Damit der Benutzer den spezifischen Benutzer bei der nächsten Anfrage über das JWT identifizieren kann, müssen die Benutzerinformationen in Redis gespeichert werden Als Schlüssel kann die ID verwendet werden.

Schreiben Sie zuerst LoginController

Dann schreiben Sie den entsprechenden Service.

Fügen Sie AuthenticationManager in SecurityConfig ein und geben Sie die Anmeldeschnittstelle frei.

Wenn in der Geschäftslogik im Dienst die Authentifizierung fehlschlägt, wird eine benutzerdefinierte Ausnahme zurückgegeben. Wenn die Authentifizierung jedoch erfolgreich ist, wie erhalten wir die entsprechenden Informationen?

Hier können wir debuggen und die erhaltenen Objekte sehen.

Hier finden Sie, dass die entsprechenden erforderlichen Informationen im Auftraggeber eingeholt werden können.

Vervollständigen Sie dann den Code.

Testen Sie es abschließend.

2.3.3.4 Authentifizierungsfilter

Ich füge zuerst den Code ein.


@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
 
    @Autowired
    private RedisCache redisCache;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            //放行
            filterChain.doFilter(request, response); //这里放行是因为还有后续的过滤器会给出对应的异常
            return; //token为空 不执行后续流程
        }
        //解析token
        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法!");
        }
        //从redis中获取用户信息
        String redisKey = "login:" + userid;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if (Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录!");
        }
        //将信息存入SecurityContextHolder（因为过滤器链后面的filter都是从中获取认证信息进行对应放行）
        //TODO 获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
 
        //放行
        filterChain.doFilter(request,response); //此时的放行是携带认证的，不同于上方token为空的放行
    }
}

Um das Token hier abzurufen, holen wir uns zunächst das entsprechende Token aus dem Anforderungsheader und prüfen dann, ob es leer ist. Wenn es leer ist, geben wir es direkt frei, ohne den Folgeprozess zu durchlaufen Analysiert das Token, ruft die darin enthaltene Benutzer-ID ab und verwendet dann die Benutzer-ID basierend auf dem. Rufen Sie die entsprechenden Benutzerinformationen von Redis ab und speichern Sie sie schließlich im SecurityContextHolder, da nachfolgende Filter die täglichen Authentifizierungsinformationen daraus abrufen und schließlich ausführen müssen Analyseoperationen.

Ein weiterer Punkt, der Aufmerksamkeit erfordert, ist, dass SecurityContextHolder.getContext().setAuthentication() das Authentifizierungsobjekt übergeben muss. Wenn wir das Objekt erstellen, verwenden wir drei Parameter, da der dritte Parameter der Schlüssel ist, um zu bestimmen, ob eine Authentifizierung durchgeführt werden soll oder nicht.

Als nächstes müssen wir diesen Filter konfigurieren.

Wenn wir dann auf die Benutzer-/Anmeldeschnittstelle zugreifen, wird uns ein Antworttext mit einem Token zurückgegeben. Wenn wir erneut auf die Hallo-Schnittstelle zugreifen, lautet dieser 403. Da er kein Token enthält, entspricht er dem obigen Code. Ohne Token wird der Antworttext freigegeben und die Rückgabe führt den nachfolgenden Prozess nicht aus (Die Freigabe erfolgt hier, weil es andere Filter gibt, die speziell Ausnahmen für die spätere Verarbeitung auslösen, und die Rückgabe soll verhindern, dass die Antwort durchlaufen wird Verfahren)

Wenn wir zu diesem Zeitpunkt das von Benutzer/Anmeldung generierte Token in den Anforderungsheader der Hallo-Schnittstelle einfügen, können wir normal darauf zugreifen.

Dann ist der Zweck unseres Filtersatzes erreicht (Token erhalten, Token analysieren und im SecurityContextHolder speichern).

2.3.3.5 Abmelden

Zu diesem Zeitpunkt ist es für uns einfacher, die entsprechenden Daten in Redis zu löschen. Wenn wir später auf das Token zugreifen, werden die entsprechenden Benutzerinformationen in unserem benutzerdefinierten Filter abgerufen Sie können es nicht abrufen. Das bedeutet, dass Sie nicht angemeldet sind.

Wir tragen dieses Token, um auf die /user/logout-Schnittstelle zuzugreifen.

Anschließend wird die Abmeldefunktion implementiert.

Dieser Artikel wurde aus dem dritten Update von Station B gelernt! ! !

Technologieaustausch