759 lines
28 KiB
Markdown
759 lines
28 KiB
Markdown
## 任务名称: 任务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()).ifPresent(user -> {
|
||
throw new ResourceExistedException("User","username="+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
|
||
|
||
|
||
|
||
### 技术/工具需求:
|
||
- [列出完成任务所需的技术栈、工具、软件版本等。]
|
||
|
||
### 成功标准:
|
||
- [明确完成任务的评判标准，如代码功能实现、性能指标、测试通过条件等。]
|
||
|
||
### 扩展学习(可选):
|
||
- [提供一些额外学习资源或挑战性任务，鼓励学有余力的学生进一步探索。]
|
||
|
||
### 评估与反馈:
|
||
- [说明如何提交作业、代码审查的标准、或任何反馈收集机制。]
|
||
|
||
### 时间估算:
|
||
- [给出预计完成该任务所需的时间，帮助学生合理安排学习计划。] |