paopao/docs/tasks/任务7-Sprint-1-基于JWT的用户认证实现.md

## 任务名称: 任务7-基于JWT的用户认证实现
### 目标:
- spring的配置类的使用
- 基于jwt的认证和授权

### 预备知识:
- JWT
- spring security

### 操作步骤:
#### 1. 撰写登录接口的API文档
使用模板[API接口说明模板](../API接口说明模板.md),根据演示站点的实际请求和回应，填写API接口说明模板。

#### 2. 引入spring security
在build.gradle中引入spring security依赖,在 dependencies中添加如下依赖:
```groovy
	implementation 'org.springframework.boot:spring-boot-starter-security'
	testImplementation 'org.springframework.security:spring-security-test'
```

#### 3. 引入JWT工具包
jjwt 是一个轻量级的JWT工具包，用于生成和验证JWT。 项目中引入jjwt,在build.gradle中添加如下依赖:

```groovy
	implementation 'io.jsonwebtoken:jjwt-api:0.12.5'
	runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.5'
	runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.5'
```
#### 4. 系统安全相关的自定义配置项
在application.yml中配置系统安全相关配置项:
```yaml
app:

  security:
    jwt:
      secret-key: uYuVw0mke38MfLhO19wUQyRgwrmYo89ibpQTXPHi4vg=
      expiration: 36000000
    white-list:
      - path: "/api-docs/**"
        methods: ["GET","PUT","POST"]
      - path: "/swagger-ui/**"
        methods: ["GET"]
      - path: "/v3/**"
        methods: [ "GET" ]
      - path: "/v1/auth/**"
        methods: [ "GET","PUT","POST"]
    allowed-origins:
      - "http://localhost:8080"
```
实现安全相关自定义配置的配置类SecurityProperties：
```java
package com.lk.paopao.conf;

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Getter
@Setter
@Component
@ConfigurationProperties(prefix = "app.security")
public class SecurityProperties {

    private List<WhiteListRule> whiteList = new ArrayList<>();
    private List<String> allowedOrigins;

    @Getter
    @Setter
    public static class WhiteListRule {
        private String path;
        private List<String> methods;
    }
}
```


#### 5. 实现UserDetailsService接口和UserDetails实现类
UserDetailsService接口
UserDetailsService接口是Spring Security提供的一个核心服务接口，其主要目的是加载用户的详细信息，特别是用于认证（登录验证）和授权（访问控制）的信息。这个接口包含一个核心方法loadUserByUsername(String username)，该方法根据用户名（或其他唯一的用户标识符）加载用户的详细信息。Spring Security在用户尝试登录时，会自动调用这个方法来获取用户信息，并进一步验证用户的凭证（如密码）是否正确。

实现UserDetailsService接口，需要定义一个类并实现这个方法，通常这个方法会查询数据库、LDAP或者其他用户存储系统，获取用户的详细信息，并封装到一个实现了UserDetails接口的对象中返回。这使得Spring Security可以灵活地与各种用户数据源集成。

UserDetails接口
UserDetails接口代表了用户的核心安全信息，包括但不限于用户名、密码、账户是否过期、凭证是否过期、账户是否锁定等状态信息，以及用户所具有的权限（通常通过角色来表示）。通过实现这个接口，可以定制化地定义用户实体类来保存和提供这些安全相关信息。例如，一个简单的实现可能包含用户名、密码、角色列表等字段。

当一个实现了UserDetailsService的类返回一个实现了UserDetails的对象时，Spring Security会使用这些信息来决定用户是否可以成功登录，以及登录后能够访问哪些资源。具体来说，它会验证用户提供的密码是否与存储的密码匹配，并检查用户的账户状态是否允许登录（例如，没有过期，未被锁定）。

总结来说，实现UserDetailsService是为了让Spring Security知道如何根据用户名加载用户详细信息，而实现UserDetails则是为了定义这些详细信息应该包含哪些内容，从而支撑起Spring Security的认证和授权逻辑。这两个接口的结合使用，为Spring Security提供了一个强大且灵活的用户认证和授权机制。

**实现UserDetails接口**

```java
package com.lk.paopao.security;

import com.lk.paopao.entity.User;
import lombok.Getter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;

/**
 * 用户详情实现类，继承自UserDetails接口，用于提供用户认证所需信息。
 */
public class UserDetailsImpl implements UserDetails {
    private static final long serialVersionUID = 1L;

    @Getter
    private Long id;

    private String username;

    private String password;

    public UserDetailsImpl(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;

    }

    public static UserDetailsImpl build(User user) {

        return new UserDetailsImpl(user.getId(), user.getUsername(), user.getPassword());
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

}

```

**实现UserDetailsService接口**
```java
package com.lk.paopao.security;


import com.lk.paopao.entity.User;
import com.lk.paopao.repository.UserRepository;
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 org.springframework.transaction.annotation.Transactional;

/**
 * 自定义用户详情服务实现类，用于加载和验证用户详细信息。
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    UserRepository userRepository;

    /**
     * 根据用户名加载用户详情。
     *
     * @param username 用户名
     * @return UserDetails 用户详情对象
     * @throws UsernameNotFoundException 如果用户不存在，则抛出异常
     */
    @Override
    @Transactional
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 通过用户名查找用户，如果不存在则抛出异常
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User Not Found with username: " + username));

        // 构建并返回UserDetails对象
        return UserDetailsImpl.build(user);
    }
}
```

#### 6. 实现jwt的工具类
使用jjwt生成JWT Token和验证JWT Token。
```java
package com.lk.paopao.security;

import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.UnsupportedJwtException;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import io.jsonwebtoken.security.SignatureException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;

@Component
public class JwtUtils {
    // 日志记录器
    private static final Logger logger = LoggerFactory.getLogger(JwtUtils.class);

    // JWT密钥
    @Value("${app.security.jwt.secret-key}")
    private String jwtSecret;

    // JWT过期时间（毫秒）
    @Value("${app.security.jwt.expiration}")
    private int jwtExpirationMs;

    /**
     * 生成JWT Token
     *
     * @param authentication 认证信息，包含用户详情
     * @return 生成的JWT Token字符串
     */
    public String generateJwtToken(Authentication authentication) {
        // 提取用户详情
        UserDetailsImpl userPrincipal = (UserDetailsImpl) authentication.getPrincipal();

        // 创建JWT，设置主题、签发时间、过期时间和签名密钥
        return Jwts.builder()
                .subject((userPrincipal.getUsername()))
                .issuedAt(new Date())
                .expiration(new Date((new Date()).getTime() + jwtExpirationMs))
                .signWith(getSigningKey())
                .compact();
    }

    /**
     * 获取签名密钥
     *
     * @return 签名所用的SecretKey
     */
    private SecretKey getSigningKey() {
        // 解码JWT密钥
        byte[] keyBytes = Decoders.BASE64.decode(jwtSecret);
        return Keys.hmacShaKeyFor(keyBytes);
    }

    /**
     * 从JWT Token中提取用户名
     *
     * @param token JWT Token字符串
     * @return 提取的用户名
     */
    public String getUserNameFromJwtToken(String token) {
        // 解析JWT Token并提取主题（用户名）
        return Jwts.parser()
                .verifyWith(getSigningKey())
                .build()
                .parseSignedClaims(token)
                .getPayload()
                .getSubject();
    }

    /**
     * 验证JWT Token的有效性
     *
     * @param authToken JWT Token字符串
     * @return 如果Token有效返回true，否则返回false
     */
    public boolean validateJwtToken(String authToken) {
        try {
            // 尝试解析JWT Token，如无异常则表示Token有效
            Jwts.parser()
                    .verifyWith(getSigningKey())
                    .build()
                    .parseSignedClaims(authToken);
            return true;
        } catch (Exception e) {
            // 记录JWT签名异常
            logger.debug("Invalid JWT signature: {}", e.getMessage());
        } 

        return false;
    }
}
```

#### 7. 创建JWT拦截器
Spring框架中，拦截器（Interceptor）是一个用于在请求处理流程之前或之后执行的一系列逻辑的组件。它们可以用于日志记录、安全控制、事务管理等。

AuthTokenFilter 是一个继承自 OncePerRequestFilter 的拦截器，它的作用是检查HTTP请求中的JWT令牌，并在令牌有效的情况下，将用户认证信息设置到Spring Security的安全上下文中。

```java
package com.lk.paopao.security;


import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

/**
 * OncePerRequestFilter作为SpringMVC中的一个过滤器，在每次请求的时候都会执行。它是对于Filter的抽象实现。
 * OncePerRequestFilter表示每次的Request都会进行拦截，不管是资源的请求还是数据的请求.
 * AuthTokenFilter类继承自OncePerRequestFilter，用于在每个HTTP请求上执行JWT令牌的验证。
 */
public class AuthTokenFilter extends OncePerRequestFilter {
    // 注入JwtUtils服务，用于JWT令牌的处理。
    @Autowired
    private JwtUtils jwtUtils;

    // 注入UserDetailsServiceImpl服务，用于根据用户名加载用户详细信息。
    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    // 日志记录器
    private static final Logger logger = LoggerFactory.getLogger(AuthTokenFilter.class);

    /**
     * 重写doFilterInternal方法，用于在请求链中执行过滤逻辑。
     *
     * @param request     HttpServletRequest对象，代表客户端的HTTP请求。
     * @param response    HttpServletResponse对象，用于向客户端发送HTTP响应。
     * @param filterChain 过滤链对象，允许将请求传递给下一个过滤器或处理器。
     * @throws ServletException 如果处理请求时发生Servlet相关异常。
     * @throws IOException      如果处理请求时发生IO异常。
     */
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            // 解析JWT令牌。
            String jwt = parseJwt(request);
            if (jwt != null && jwtUtils.validateJwtToken(jwt)) {
                // 从JWT令牌中获取用户名。
                String username = jwtUtils.getUserNameFromJwtToken(jwt);

                // 加载用户详细信息。
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                // 创建认证对象。
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                // 设置认证详情。
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                // 设置当前线程的安全上下文认证信息。
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception e) {
            // 记录无法设置用户认证的错误。
            logger.error("Cannot set user authentication:", e);
        }

        // 继续处理请求链。
        filterChain.doFilter(request, response);
    }

    /**
     * 从HTTP请求中解析JWT令牌。
     *
     * @param request HttpServletRequest对象。
     * @return 从请求头中解析出的JWT令牌字符串，如果无法解析则返回null。
     */
    private String parseJwt(HttpServletRequest request) {
        // 从请求头中获取"Authorization"字段。
        String headerAuth = request.getHeader("Authorization");

        // 如果存在且以"Bearer "开头，则提取并返回令牌字符串。
        if (StringUtils.hasText(headerAuth) && headerAuth.startsWith("Bearer ")) {
            return headerAuth.substring(7);
        }

        return null;
    }
}
```

#### 8. 实现 AuthenticationEntryPoint
AuthenticationEntryPoint 是一个用于处理未认证请求的接口。当用户尝试访问受保护资源时，如果用户尚未通过身份验证，则AuthenticationEntryPoint将处理该请求。
```java
package com.lk.paopao.security;

import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * 当用户请求了一个受保护的资源，但是用户没有通过认证，那么抛出异常，AuthenticationEntryPoint. Commence(..)就会被调用。
 * 这个对应的代码在ExceptionTranslationFilter中，当ExceptionTranslationFilter catch到异常后，就会间接调用AuthenticationEntryPoint。
 * <p>
 * AuthEntryPointJwt:处理JWT认证失败的入口点。
 * 当用户请求需要认证的资源但未提供有效令牌时，会触发此入口点。
 * 实现了AuthenticationEntryPoint接口，用于定义应用程序在身份验证失败时的响应行为。
 */
@Component
class AuthEntryPointJwt implements AuthenticationEntryPoint {

    private static final Logger logger = LoggerFactory.getLogger(AuthEntryPointJwt.class);

    /**
     * 当认证失败时，向客户端返回适当的错误响应。
     *
     * @param request       HttpServletRequest对象，代表客户端的HTTP请求。
     * @param response      HttpServletResponse对象，用于向客户端发送HTTP响应。
     * @param authException 身份验证异常，包含认证失败的详细信息。
     * @throws IOException      如果在写响应时发生I/O错误。
     * @throws ServletException 如果在处理请求时发生Servlet异常。
     */
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        // 记录未经授权的错误信息
        logger.debug("Unauthorized error: {}", authException.getMessage());

        // 设置响应类型为JSON，状态码为401（未授权）
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

        // 构建响应体，包含状态码、错误信息和请求路径
        final Map<String, Object> body = new HashMap<>();
        body.put("code", HttpServletResponse.SC_UNAUTHORIZED);
        body.put("msg", authException.getMessage());
        // 将响应体转换为JSON并写入响应流
        final ObjectMapper mapper = new ObjectMapper();
        mapper.writeValue(response.getOutputStream(), body);
    }
}

```
#### 9. spring security的配置类
需要实现一个Spring Security配置类，用于设置应用程序的安全特性，包括认证、授权、密码加密、跨域资源共享（CORS）等。

```JAVA
package com.lk.paopao.security;


import com.lk.paopao.conf.SecurityProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.handler.HandlerMappingIntrospector;

import java.util.Map;
import static org.springframework.security.config.http.SessionCreationPolicy.STATELESS;

@Configuration // 配置类注解，代表这是一个Spring配置类。
@EnableWebSecurity // 启用Spring Web安全功能。
@EnableMethodSecurity // 启用方法级别的安全控制。
public class SecurityConfiguration {

    @Autowired
    UserDetailsService userDetailsService;
    @Autowired
    private AuthEntryPointJwt unauthorizedHandler;

    @Autowired
    SecurityProperties securityProperties;

    public Map<String, HttpMethod> METHODS = Map.of(
            "GET", HttpMethod.GET,
            "POST", HttpMethod.POST,
            "PUT", HttpMethod.PUT,
            "DELETE", HttpMethod.DELETE
    );

    /**
     * 创建并返回一个AuthTokenFilter实例，用于过滤和处理JWT认证令牌。
     *
     * @return AuthTokenFilter 实例。https://i…
     */
    @Bean
    public AuthTokenFilter authenticationJwtTokenFilter() {
        return new AuthTokenFilter();
    }

    /**
     * 创建并配置DaoAuthenticationProvider，用于处理用户认证。
     *
     * @return 配置好的DaoAuthenticationProvider实例。
     */
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();

        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());

        return authProvider;
    }

    /**
     * 创建并返回一个BCryptPasswordEncoder实例，用于密码加密。
     *
     * @return BCryptPasswordEncoder 实例。
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 配置并返回一个AuthenticationManager实例，它是Spring Security的认证管理器。
     *
     * @param authConfig 认证配置。
     * @return 配置好的AuthenticationManager实例。
     * @throws Exception 可能抛出的异常。
     */
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception {
        return authConfig.getAuthenticationManager();
    }

    /**
     * 配置HTTP安全设置，定义如何处理请求和授权。
     *
     * @param http         HttpSecurity配置对象。
     * @param introspector 用于检查HandlerMapping的 introspector。
     * @return 配置好的SecurityFilterChain，它定义了应用的过滤链。
     * @throws Exception 可能抛出的异常。
     */
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http, HandlerMappingIntrospector introspector) throws Exception {
        // 禁用CSRF保护
        http.csrf(AbstractHttpConfigurer::disable).authorizeHttpRequests(req -> {
            // 允许OPTIONS请求
            req.requestMatchers(HttpMethod.OPTIONS, "/**").permitAll();
            // 配置白名单
            for (SecurityProperties.WhiteListRule rule : securityProperties.getWhiteList()) {
                for (String method : rule.getMethods()) {
                    req.requestMatchers(METHODS.get(method.toUpperCase()), rule.getPath()).permitAll();
                }
            }
            // 其他请求需要身份验证
            req.anyRequest().authenticated();
        });

        // 设置未授权访问的处理,设置会话管理策略为无状态.设置认证提供者,在UsernamePasswordAuthenticationFilter之前添加自定义过滤器
        http.exceptionHandling(ex -> ex.authenticationEntryPoint(unauthorizedHandler))
                .sessionManagement(session -> session.sessionCreationPolicy(STATELESS))
                .authenticationProvider(authenticationProvider())
                .addFilterBefore(authenticationJwtTokenFilter(), UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    /**
     * 配置跨域过滤器
     *
     * @return CorsFilter
     */
    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        for (String origin : securityProperties.getAllowedOrigins()) {
            config.addAllowedOrigin(origin);
        }
        config.setAllowCredentials(true);

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);

        return new CorsFilter(source);
    }
}

```

#### 10. 实现登录接口

**在AuthController中添加登录接口**
```java

    @PostMapping("/login")
    public DataResult<Map<String,String>> login(@RequestBody LoginRequest loginRequest){
        return ResultUtil.ok(authService.login(loginRequest.getUsername(),loginRequest.getPassword()));
    }
```

**在AuthService中添加登录逻辑**

并修改注册逻辑，密码加密.

完整的AuthService类如下:

```java

package com.lk.paopao.service;

import com.lk.paopao.dto.rest.request.RegisterRequest;
import com.lk.paopao.entity.User;
import com.lk.paopao.exception.ResourceExistedException;
import com.lk.paopao.repository.UserRepository;
import com.lk.paopao.security.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.Map;

@Service
@Transactional
public class AuthService {
    // 从配置文件中读取默认头像地址
    @Value("${app.default.head-icon}")
    private String DEFAULT_HEAD_ICON;
    // 注入用户实体的数据库接口
    @Autowired
    UserRepository userRepository;
    // 自动注入认证管理器
    @Autowired
    AuthenticationManager authenticationManager;
    // 自动注入密码编码器
    @Autowired
    PasswordEncoder encoder;
    // 自动注入JWT工具类
    @Autowired
    JwtUtils jwtUtils;

    /**
     * 用户注册。
     * @param reg 注册请求对象，包含用户名和密码
     * @return 注册后的用户信息
     */
    public User register(RegisterRequest reg) {
        // 检查用户名是否已存在,如果存在则抛出异常
        userRepository.findByUsername(reg.getUsername()).orElseThrow(() -> new ResourceExistedException("User","useranme="+reg.getUsername()));
        // 创建用户对象并设置信息
        User user = new User();
        // 设置密码,暂时使用明文密码
        user.setPassword(encoder.encode(reg.getPassword()));
        // 设置昵称为用户名
        user.setUsername(reg.getUsername());
        // 设置昵称为用户名
        user.setNickname(reg.getUsername());
        // 设置默认头像
        user.setAvatar(DEFAULT_HEAD_ICON);
        // 在数据库中创建用户
        return userRepository.save(user);
    }
    /**
     * 用户登录，返回JWT令牌。
     * @param username 用户名
     * @param password 密码
     * @return 包含JWT令牌的Map
     */
    public Map<String,String> login(String username, String password) {
        // 认证用户
        Authentication authentication = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username,password));

        // 设置认证信息到SecurityContextHolder
        SecurityContextHolder.getContext()
                .setAuthentication(authentication);
        // 生成JWT令牌
        String jwt = jwtUtils.generateJwtToken(authentication);

        // 返回包含JWT令牌的Map
        Map<String,String> token = new HashMap<>();
        token.put("token",jwt);

        return token;
    }
}
```

#### 11. 通过swagger ui 测试登录接口

http://localhost:8080/api-docs



### 技术/工具需求:
- [列出完成任务所需的技术栈、工具、软件版本等。]

### 成功标准:
- [明确完成任务的评判标准，如代码功能实现、性能指标、测试通过条件等。]

### 扩展学习(可选):
- [提供一些额外学习资源或挑战性任务，鼓励学有余力的学生进一步探索。]

### 评估与反馈:
- [说明如何提交作业、代码审查的标准、或任何反馈收集机制。]

### 时间估算:
- [给出预计完成该任务所需的时间，帮助学生合理安排学习计划。]