安全模块构建
大约 8 分钟
spring-security 集成
1.
//jwt依赖相关
api(libraries.'servlet-api')
api(libraries.'commons-codec')
api(libraries.'jjwt')
api(libraries.'jaxb-api')
api(libraries.'jaxb-impl')
api(libraries.'jaxb-core')
//数据安全
api('org.springframework.boot:spring-boot-starter-security')
数据库连接配置
package com.yix.system.security;
import com.yix.common.enums.UserStatus;
import com.yix.common.exception.user.UserException;
import com.yix.common.web.security.dto.LoginUserDto;
import com.yix.common.web.security.dto.SysUserDto;
import com.yix.system.service.ISysPermissionService;
import com.yix.system.service.ISysUserService;
import com.yix.system.service.impl.SysPasswordService;
import lombok.extern.slf4j.Slf4j;
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;
/**
* 用户验证处理
*
* @author wangdx
*/
@Service
@Slf4j
public class UserDetailsServiceImpl implements UserDetailsService {
private static final String USER_PASSWORD_ERR = "user.password.not.match";
@Autowired
private ISysUserService userService;
@Autowired
private SysPasswordService passwordService;
@Autowired
private ISysPermissionService permissionService;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
SysUserDto user = userService.selectUserByUserName(username);
if (Objects.isNull(user)
|| UserStatus.DISABLE.getCode().equals(user.getDeleted())
|| UserStatus.DELETED.getCode().equals(user.getDeleted())
) {
log.warn("登录用户：{} 不存在.| 已被删除. | 已被停用.", username);
throw new UserException.UserPasswordNotMatchException();
}
passwordService.validate(user);
return createLoginUser(user);
}
public UserDetails createLoginUser(SysUserDto user) {
return new LoginUserDto(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));
}
}
jwt 配置
package com.yix.system.security;
import cn.hutool.http.useragent.UserAgent;
import cn.hutool.http.useragent.UserAgentParser;
import com.yix.common.config.YixJwtConfig;
import com.yix.common.constant.CacheConstants;
import com.yix.common.constant.Constants;
import com.yix.common.constant.HttpStatus;
import com.yix.common.exception.ServiceException;
import com.yix.common.exception.user.UserException;
import com.yix.common.utils.ServletUtils;
import com.yix.common.utils.StringUtils;
import com.yix.common.utils.ip.AddressUtils;
import com.yix.common.utils.ip.IpUtils;
import com.yix.common.utils.redis.RedisCache;
import com.yix.common.utils.uuid.UUIDUitls;
import com.yix.common.web.security.dto.LoginUserDto;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
/**
* @author wangdx
*/
@Component
@Slf4j
public class TokenService {
protected static final long MILLIS_SECOND = 1000;
protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;
private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;
private static final String USER_INFO_ERROR = "user.info.error";
@Autowired
private RedisCache redisCache;
@Autowired
private YixJwtConfig yixJwtConfig;
/**
* 获取用户身份信息
*
* @return 用户信息
*/
public LoginUserDto getLoginUser(HttpServletRequest request) {
// 获取请求携带的令牌
String token = getToken(request);
if (Objects.nonNull(token)) {
try {
Claims claims = parseToken(token);
// 解析对应的权限以及用户信息
String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
String userKey = getTokenKey(uuid);
LoginUserDto user = redisCache.getCacheObject(userKey);
return user;
} catch (Exception e) {
log.error("令牌过期，获取用户信息异常'{}'", e.getMessage());
throw new UserException.JWTException();
}
}
return null;
}
/**
* 设置用户身份信息
*/
public void setLoginUser(LoginUserDto loginUser) {
if (Objects.nonNull(loginUser) && Objects.nonNull(loginUser.getToken())) {
refreshToken(loginUser);
}
}
/**
* 删除用户身份信息
*/
public void delLoginUser(String token) {
if (Objects.nonNull(token)) {
String userKey = getTokenKey(token);
redisCache.deleteObject(userKey);
}
}
/**
* 创建令牌
*
* @param loginUser 用户信息
* @return 令牌
*/
public String createToken(LoginUserDto loginUser) {
String token = loginUser.getUserId() + UUIDUitls.fastUUID();
loginUser.setToken(token);
setUserAgent(loginUser);
refreshToken(loginUser);
Map<String, Object> claims = new HashMap<>();
claims.put(Constants.LOGIN_USER_KEY, token);
return createToken(claims);
}
/**
* 验证令牌有效期，相差不足20分钟，自动刷新缓存
*
* @param loginUser
* @return 令牌
*/
public void verifyToken(LoginUserDto loginUser) {
long expireTime = loginUser.getExpireTime();
long currentTime = System.currentTimeMillis();
if (expireTime - currentTime <= MILLIS_MINUTE_TEN) {
refreshToken(loginUser);
}
}
/**
* 刷新令牌有效期
*
* @param loginUser 登录信息
*/
public void refreshToken(LoginUserDto loginUser) {
loginUser.setLoginTime(System.currentTimeMillis());
loginUser.setExpireTime(loginUser.getLoginTime() + yixJwtConfig.getExpireTime() * MILLIS_MINUTE);
// 根据uuid将loginUser缓存
String userKey = getTokenKey(loginUser.getToken());
redisCache.setCacheObject(userKey, loginUser, yixJwtConfig.getExpireTime(), TimeUnit.MINUTES);
}
/**
* 设置用户代理信息
*
* @param loginUser 登录信息
*/
public void setUserAgent(LoginUserDto loginUser) {
UserAgent userAgent = UserAgentParser.parse(ServletUtils.getRequest().getHeader("User-Agent"));
String ip = IpUtils.getIpAddr();
loginUser.setIpaddr(ip);
loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
loginUser.setBrowser(userAgent.getBrowser().getName());
loginUser.setOs(userAgent.getOs().getName());
}
/**
* 从数据声明生成令牌
*
* @param claims 数据声明
* @return 令牌
*/
private String createToken(Map<String, Object> claims) {
String token = Jwts.builder()
.setClaims(claims)
.signWith(SignatureAlgorithm.HS512, yixJwtConfig.getSecret()).compact();
return token;
}
/**
* 从令牌中获取数据声明
*
* @param token 令牌
* @return 数据声明
*/
private Claims parseToken(String token) {
return Jwts.parser()
.setSigningKey(yixJwtConfig.getSecret())
.parseClaimsJws(token)
.getBody();
}
/**
* 从令牌中获取用户名
*
* @param token 令牌
* @return 用户名
*/
public String getUsernameFromToken(String token) {
Claims claims = parseToken(token);
return claims.getSubject();
}
/**
* 获取请求token
*
* @param request
* @return token
*/
private String getToken(HttpServletRequest request) {
String token = request.getHeader(yixJwtConfig.getHeader());
if (StringUtils.isNotEmpty(token) && token.startsWith(yixJwtConfig.getTokenPrefix())) {
token = token.replace(yixJwtConfig.getTokenPrefix(), "");
}
return token;
}
private String getTokenKey(String uuid) {
return CacheConstants.LOGIN_TOKEN_KEY + uuid;
}
}
security 配置
package com.yix.framework.config.security;
import com.yix.common.config.YixSecurityConfig;
import com.yix.framework.web.security.aware.PermitAllUrlProperties;
import com.yix.framework.web.security.filter.JwtAuthenticationTokenFilter;
import com.yix.framework.web.security.handle.AuthenticationEntryPointImpl;
import com.yix.framework.web.security.handle.LogoutSuccessHandlerImpl;
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.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutFilter;
import org.springframework.web.filter.CorsFilter;
/**
* spring security配置
*
* @author wangdx
*/
@Configuration
//@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private AuthenticationEntryPointImpl unauthorizedHandler; //认证失败处理类
@Autowired
private LogoutSuccessHandlerImpl logoutSuccessHandler;//退出处理类
@Autowired
private JwtAuthenticationTokenFilter authenticationTokenFilter;//token认证过滤器
@Autowired
private CorsFilter corsFilter; //跨域过滤器
@Autowired
private PermitAllUrlProperties permitAllUrl; //允许匿名访问的地址
@Autowired
private YixSecurityConfig yixSecurityConfig;
/**
* 身份认证接口
*/
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
}
/**
* 强散列哈希加密实现
*/
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* 解决 无法直接注入 AuthenticationManager
*/
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
/**
* anyRequest | 匹配所有请求路径
* access | SpringEl表达式结果为true时可以访问
* anonymous | 匿名可以访问
* denyAll | 用户不能访问
* fullyAuthenticated | 用户完全认证可以访问（非remember-me下自动登录）
* hasAnyAuthority | 如果有参数，参数表示权限，则其中任何一个权限可以访问
* hasAnyRole | 如果有参数，参数表示角色，则其中任何一个角色可以访问
* hasAuthority | 如果有参数，参数表示权限，则其权限可以访问
* hasIpAddress | 如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
* hasRole | 如果有参数，参数表示角色，则其角色可以访问
* permitAll | 用户可以任意访问
* rememberMe | 允许通过remember-me登录的用户访问
* authenticated | 用户登录后可访问
*/
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
// 注解标记允许匿名访问的url
ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry
= httpSecurity.authorizeRequests();
permitAllUrl.getUrls().forEach(url -> registry.antMatchers(url).permitAll());
httpSecurity
// CSRF禁用，因为不使用session
.csrf().disable()
// 禁用HTTP响应标头
.headers().cacheControl().disable().frameOptions().disable().and()
// 认证失败处理类
.exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
// 基于token，所以不需要session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
// 过滤请求
.authorizeRequests()
// 对于登录login 注册register 验证码captchaImage 允许匿名访问
.antMatchers(yixSecurityConfig.getExcludeUrl().split(",")).permitAll()
// 对于登录login 注册register 验证码captchaImage 允许匿名访问
.antMatchers("/login", "/register", "/captchaImage").permitAll()
// 静态资源，可匿名访问
.antMatchers(HttpMethod.GET, "/", "/*.html", "/**/*.html", "/**/*.css", "/**/*.js", "/profile/**").permitAll()
.antMatchers("/doc.html", "/swagger-ui/index.html", "/swagger-resources/**", "/webjars/**"
, "/*/api-docs/**", "/druid/**").permitAll()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
// 添加Logout filter
httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);
// 添加JWT filter
httpSecurity.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
// 添加CORS filter
httpSecurity.addFilterBefore(corsFilter, JwtAuthenticationTokenFilter.class);
httpSecurity.addFilterBefore(corsFilter, LogoutFilter.class);
}
}
package com.yix.framework.config.webmvc;
import com.yix.common.config.YixConfig;
import com.yix.common.constant.Constants;
import com.yix.framework.web.interceptor.RepeatSubmitInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.CacheControl;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.concurrent.TimeUnit;
/**
* @author wangdx
*/
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Autowired
private RepeatSubmitInterceptor repeatSubmitInterceptor;
/**
* 自定义拦截规则
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**");
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
/** 本地文件上传路径 */
registry.addResourceHandler(Constants.RESOURCE_PREFIX + "/**")
.addResourceLocations("file:" + YixConfig.getProfile() + "/");
/** swagger配置 */
registry.addResourceHandler("/swagger-ui/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/springfox-swagger-ui/")
.setCacheControl(CacheControl.maxAge(5, TimeUnit.HOURS).cachePublic());
}
/**
* 跨域配置
*/
@Bean
public CorsFilter corsFilter() {
CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
// 设置访问源地址
config.addAllowedOriginPattern("*");
// 设置访问源请求头
config.addAllowedHeader("*");
// 设置访问源请求方法
config.addAllowedMethod("*");
// 有效期 1800秒
config.setMaxAge(1800L);
// 添加映射路径，拦截一切请求
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
// 返回新的CorsFilter
return new CorsFilter(source);
}
}
package com.yix.framework.web.security.aware;
import com.yix.common.annotation.Anonymous;
import org.apache.commons.lang3.RegExUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import java.util.*;
import java.util.regex.Pattern;
/**
* 设置Anonymous注解允许匿名访问的url
*
* @author wangdx
*/
@Configuration
public class PermitAllUrlProperties implements InitializingBean, ApplicationContextAware {
private static final Pattern PATTERN = Pattern.compile("\\{(.*?)\\}");
private ApplicationContext applicationContext;
private List<String> urls = new ArrayList<>();
public String ASTERISK = "*";
@Override
public void afterPropertiesSet() throws Exception {
RequestMappingHandlerMapping mapping = applicationContext.getBean(RequestMappingHandlerMapping.class);
Map<RequestMappingInfo, HandlerMethod> map = mapping.getHandlerMethods();
map.keySet().forEach(info -> {
HandlerMethod handlerMethod = map.get(info);
// 获取方法上边的注解 替代path variable 为 *
Anonymous method = AnnotationUtils.findAnnotation(handlerMethod.getMethod(), Anonymous.class);
Optional.ofNullable(method).ifPresent(anonymous -> Objects.requireNonNull(info.getPatternsCondition().getPatterns())
.forEach(url -> urls.add(RegExUtils.replaceAll(url, PATTERN, ASTERISK))));
// 获取类上边的注解, 替代path variable 为 *
Anonymous controller = AnnotationUtils.findAnnotation(handlerMethod.getBeanType(), Anonymous.class);
Optional.ofNullable(controller).ifPresent(anonymous -> Objects.requireNonNull(info.getPatternsCondition().getPatterns())
.forEach(url -> urls.add(RegExUtils.replaceAll(url, PATTERN, ASTERISK))));
});
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public List<String> getUrls() {
return urls;
}
public void setUrls(List<String> urls) {
this.urls = urls;
}
}
package com.yix.framework.web.security.filter;
import com.yix.common.utils.security.SecurityUtils;
import com.yix.common.web.security.dto.LoginUserDto;
import com.yix.system.security.TokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
/**
* token过滤器 验证token有效性
*
* @author wangdx
*/
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Autowired
private TokenService tokenService;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response
, FilterChain filterChain) throws ServletException, IOException {
LoginUserDto loginUser = tokenService.getLoginUser(request);
if (Objects.nonNull(loginUser) && Objects.isNull(SecurityUtils.getAuthentication())) {
tokenService.verifyToken(loginUser);
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
}
filterChain.doFilter(request, response);
}
}
package com.yix.framework.web.security.handle;
import com.yix.common.constant.HttpStatus;
import com.yix.common.utils.ServletUtils;
import com.yix.common.utils.json.JacksonUtils;
import com.yix.common.utils.security.SecurityUtils;
import com.yix.common.web.dto.AjaxResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author wangdx
*/
@Component
@SuppressWarnings("JavadocReference")
@Slf4j
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
private static final String SECURITY_FORBIDDEN = "security.forbidden";
@Override
public void handle(HttpServletRequest request, HttpServletResponse response
, AccessDeniedException e) throws IOException, ServletException {
// 打印 warn 的原因是，不定期合并 warn，看看有没恶意破坏
log.warn("[commence][访问 URL({}) 时，用户({}) 权限不够]", request.getRequestURI(),
SecurityUtils.getUserId(), e);
ServletUtils.renderString(response
, JacksonUtils.toJsonString(AjaxResult.errorI18n(HttpStatus.FORBIDDEN, SECURITY_FORBIDDEN, new Object[]{request.getRequestURI()})));
}
}
package com.yix.framework.web.security.handle;
import com.yix.common.constant.HttpStatus;
import com.yix.common.utils.ServletUtils;
import com.yix.common.utils.json.JacksonUtils;
import com.yix.common.web.dto.AjaxResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;
/**
* 访问一个需要认证的 URL 资源，但是此时自己尚未认证（登录）的情况下
*
* @author wangdx
*/
@Component
@Slf4j
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint, Serializable {
private static final String SECURITY_ERROR = "security.error";
@Override
public void commence(HttpServletRequest request, HttpServletResponse response
, AuthenticationException authException) throws IOException, ServletException {
ServletUtils.renderString(response
, JacksonUtils.toJsonString(AjaxResult.errorI18n(HttpStatus.UNAUTHORIZED, SECURITY_ERROR, new Object[]{request.getRequestURI()})));
}
}
package com.yix.framework.web.security.handle;
import com.yix.common.utils.ServletUtils;
import com.yix.common.utils.json.JacksonUtils;
import com.yix.common.web.dto.AjaxResult;
import com.yix.common.web.security.dto.LoginUserDto;
import com.yix.system.security.TokenService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
/**
* 自定义退出处理类 返回成功
*
* @author wangdx
*/
@Slf4j
@Configuration
public class LogoutSuccessHandlerImpl implements LogoutSuccessHandler {
private static final String LOGOUT_SUCCESS = "user.logout.success";
@Autowired
private TokenService tokenService;
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
LoginUserDto loginUser = tokenService.getLoginUser(request);
if (Objects.nonNull(loginUser)) {
String userName = loginUser.getUsername();
// 删除用户缓存记录
tokenService.delLoginUser(loginUser.getToken());
// 记录用户退出日志
// AsyncManager.me().execute(AsyncFactory.recordLogininfor(userName, Constants.LOGOUT, MessageUtils.message("user.logout.success")));
}
ServletUtils.renderString(response, JacksonUtils.toJsonString(AjaxResult.successI18n(LOGOUT_SUCCESS, new Object[]{})));
}
}
用户登录
package com.yix.system.service.impl;
import com.yix.common.exception.ServiceException;
import com.yix.common.exception.user.UserException;
import com.yix.common.utils.ip.IpUtils;
import com.yix.common.web.exception.GlobalExceptionHandler;
import com.yix.common.web.security.context.AuthenticationContextHolder;
import com.yix.common.web.security.dto.LoginUserDto;
import com.yix.common.web.security.dto.SysUserDto;
import com.yix.system.security.TokenService;
import com.yix.system.service.ISysConfigService;
import com.yix.system.service.ISysLoginService;
import com.yix.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.LocalDateTime;
/**
* @author wangdx
*/
@Service
public class SysLoginService implements ISysLoginService {
@Autowired
private ISysConfigService configService;
@Resource
private AuthenticationManager authenticationManager;
@Autowired
private TokenService tokenService;
@Autowired
private ISysUserService sysUserService;
public Object login(String username, String password, String code, String uuid) {
// 验证码校验
// validateCaptcha(username, code, uuid);
// 登录前置校验
// loginPreCheck(username, password);
// 用户验证
Authentication authentication = null;
try {
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
AuthenticationContextHolder.setContext(authenticationToken);
// 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
authentication = authenticationManager.authenticate(authenticationToken);
} catch (Exception e) {
GlobalExceptionHandler globalExceptionHandler = new GlobalExceptionHandler();
globalExceptionHandler.handleThrowable(e);
} finally {
AuthenticationContextHolder.clearContext();
}
// AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
LoginUserDto loginUser = (LoginUserDto) authentication.getPrincipal();
recordLoginInfo(loginUser.getUserId());
// 生成token
return tokenService.createToken(loginUser);
}
/**
* 记录登录信息
*
* @param userId 用户ID
*/
public void recordLoginInfo(Long userId) {
SysUserDto sysUser = new SysUserDto();
sysUser.setUserId(userId);
sysUser.setLoginIp(IpUtils.getIpAddr());
sysUser.setLoginDateTime(LocalDateTime.now());
sysUserService.updateUserProfile(sysUser);
}
}