}
public void setData(Object data) {
this.data = data;
}
}
Database.java
这里我们使用一个 HashMap 模拟了一个数据库,密码我已经预先用 Bcrypt
加密过了,这也是 Spring Security 官方推荐的加密算法(MD5 加密已经在 Spring Security 5 中被移除了,不安全)。
| 用户名 | 密码 | 权限 |
| — | — | — |
| jack | jack123 存 Bcrypt 加密后 | ROLE_USER |
| danny | danny123 存 Bcrypt 加密后 | ROLE_EDITOR |
| smith | smith123 存 Bcrypt 加密后 | ROLE_ADMIN |
@Component
public class Database {
private Map<String, UserEntity> data = null;
public Map<String, UserEntity> getDatabase() {
if (data == null) {
data = new HashMap<>();
UserEntity jack = new UserEntity(
“jack”,
“$2a 10 10 10AQol1A.LkxoJ5dEzS5o5E.QG9jD.hncoeCGdVaMQZaiYZ98V/JyRq”,
getGrants(“ROLE_USER”));
UserEntity danny = new UserEntity(
“danny”,
“$2a$10$8nMJR6r7lvh9H2INtM2vtuA156dHTcQUyU.2Q2OK/7LwMd/I.HM12”,
getGrants(“ROLE_EDITOR”));
UserEntity smith = new UserEntity(
“smith”,
“$2a 10 10 10E86mKigOx1NeIr7D6CJM3OQnWdaPXOjWe4OoRqDqFgNgowvJW9nAi”,
getGrants(“ROLE_ADMIN”));
data.put(“jack”, jack);
data.put(“danny”, danny);
data.put(“smith”, smith);
}
return data;
}
private Collection getGrants(String role) {
return AuthorityUtils.commaSeparatedStringToAuthorityList(role);
}
}
UserService.java
这里再模拟一个 service,主要就是模仿数据库的操作。
@Service
public class UserService {
@Autowired
private Database database;
public UserEntity getUserByUsername(String username) {
return database.getDatabase().get(username);
}
}
JwtUtil.java
自己编写的一个工具类,主要负责 JWT 的签名和鉴权。
public class JwtUtil {
// 过期时间5分钟
private final static long EXPIRE_TIME = 5 * 60 * 1000;
/**
* 生成签名,5min后过期
* @param username 用户名
* @param secret 用户的密码
* @return 加密的token
*/
public static String sign(String username, String secret) {
Date expireDate = new Date(System.currentTimeMillis() + EXPIRE_TIME);
try {
Algorithm algorithm = Algorithm.HMAC256(secret);
return JWT.create()
.withClaim(“username”, username)
.withExpiresAt(expireDate)
.sign(algorithm);
} catch (Exception e) {
return null;
}
}
/**
* 校验token是否正确
* @param token 密钥
* @param secret 用户的密码
* @return 是否正确
*/
public static boolean verify(String token, String username, String secret) {
try {
Algorithm algorithm = Algorithm.HMAC256(secret);
JWTVerifier verifier = JWT.require(algorithm)
.withClaim(“username”, username)
.build();
DecodedJWT jwt = verifier.verify(token);
return true;
} catch (Exception e) {
return false;
}
}
/**
* 获得token中的信息无需secret解密也能获得
* @return token中包含的用户名
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim(“username”).asString();
} catch (JWTDecodeException e) {
return null;
}
}
}
Spring Security 改造
登入这块,我们使用自定义的 JwtAuthenticationFilter
来进行登入。
请求鉴权,我们使用自定义的 JwtAuthorizationFilter
来处理。
也许大家觉得两个单词长的有点像,???。
UserDetailsServiceImpl.java
我们首先实现官方的 UserDetailsService
接口,这里主要负责一个从数据库拿数据的操作。
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserService userService;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
UserEntity userEntity = userService.getUserByUsername(username);
if (userEntity == null) {
throw new UsernameNotFoundException(“This username didn’t exist.”);
}
return new User(userEntity.getUsername(), userEntity.getPassword(), userEntity.getRole());
}
}
后序我们还需要对其进行缓存改造,不然每次请求都要从数据库拿一次数据鉴权,对数据库压力太大了。
JwtAuthenticationFilter.java
这个过滤器主要处理登入操作,我们继承了 UsernamePasswordAuthenticationFilter
,这样能大大简化我们的工作量。
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
/*
过滤器一定要设置 AuthenticationManager,所以此处我们这么编写,这里的 AuthenticationManager
我会从 Security 配置的时候传入
*/
public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
/*
运行父类 UsernamePasswordAuthenticationFilter 的构造方法,能够设置此滤器指定
方法为 POST [\login]
*/
super();
setAuthenticationManager(authenticationManager);
}
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
// 从请求的 POST 中拿取 username 和 password 两个字段进行登入
String username = request.getParameter(“username”);
String password = request.getParameter(“password”);
UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);
// 设置一些客户 IP 啥信息,后面想用的话可以用,虽然没啥用
setDetails(request, token);
// 交给 AuthenticationManager 进行鉴权
return getAuthenticationManager().authenticate(token);
}
/*
鉴权成功进行的操作,我们这里设置返回加密后的 token
*/
@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
handleResponse(request, response, authResult, null);
}
/*
鉴权失败进行的操作,我们这里就返回 用户名或密码错误 的信息
*/
@Override
protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
handleResponse(request, response, null, failed);
}
private void handleResponse(HttpServletRequest request, HttpServletResponse response, Authentication authResult, AuthenticationException failed) throws IOException, ServletException {
ObjectMapper mapper = new ObjectMapper();
ResponseEntity responseEntity = new ResponseEntity();
response.setHeader(“Content-Type”, “application/json;charset=UTF-8”);
if (authResult != null) {
// 处理登入成功请求
User user = (User) authResult.getPrincipal();
String token = JwtUtil.sign(user.getUsername(), user.getPassword());
responseEntity.setStatus(HttpStatus.OK.value());
responseEntity.setMsg(“登入成功”);
responseEntity.setData("Bearer " + token);
response.setStatus(HttpStatus.OK.value());
response.getWriter().write(mapper.writeValueAsString(responseEntity));
} else {
// 处理登入失败请求
responseEntity.setStatus(HttpStatus.BAD_REQUEST.value());
responseEntity.setMsg(“用户名或密码错误”);
responseEntity.setData(null);
response.setStatus(HttpStatus.BAD_REQUEST.value());
response.getWriter().write(mapper.writeValueAsString(responseEntity));
}
}
}
private void handleResponse()
此处处理的方法不是很好,我的想法是跳转到控制器中进行处理,但是这样鉴权成功的 token 带不过去,所以先这么写了,有点复杂。
JwtAuthorizationFilter.java
这个过滤器处理每个请求鉴权,我们选择继承 BasicAuthenticationFilter
,考虑到 Basic 认证和 JWT 比较像,就选择了它。
public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
private UserDetailsService userDetailsService;
// 会从 Spring Security 配置文件那里传过来
public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserDetailsService userDetailsService) {
super(authenticationManager);
this.userDetailsService = userDetailsService;
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
// 判断是否有 token,并且进行认证
Authentication token = getAuthentication(request);
if (token == null) {
chain.doFilter(request, response);
return;
}
// 认证成功
SecurityContextHolder.getContext().setAuthentication(token);
chain.doFilter(request, response);
}
private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
String header = request.getHeader(“Authorization”);
if (header == null || ! header.startsWith("Bearer ")) {
return null;
}
String token = header.split(" ")[1];
String username = JwtUtil.getUsername(token);
UserDetails userDetails = null;
try {
userDetails = userDetailsService.loadUserByUsername(username);
} catch (UsernameNotFoundException e) {
return null;
}
if (! JwtUtil.verify(token, username, userDetails.getPassword())) {
return null;
}
return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
}
}
SecurityConfiguration.java
此处我们进行 Security 的配置,并且实现缓存功能。缓存这块我们使用官方现成的 CachingUserDetailsService
,唯独的缺点就是它没有 public 方法,我们不能正常实例化,需要曲线救国,下面代码也有详细说明。
// 开启 Security
@EnableWebSecurity
// 开启注解配置支持
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
@Autowired
private UserDetailsServiceImpl userDetailsServiceImpl;
// Spring Boot 的 CacheManager,这里我们使用 JCache
@Autowired
private CacheManager cacheManager;
@Override
protected void configure(HttpSecurity http) throws Exception {
// 开启跨域
http.cors()
.and()
// security 默认 csrf 是开启的,我们使用了 token ,这个也没有什么必要了
.csrf().disable()
.authorizeRequests()
// 默认所有请求通过,但是我们要在需要权限的方法加上安全注解,这样比写死配置灵活很多
.anyRequest().permitAll()
.and()
// 添加自己编写的两个过滤器
.addFilter(new JwtAuthenticationFilter(authenticationManager()))
.addFilter(new JwtAuthorizationFilter(authenticationManager(), cachingUserDetailsService(userDetailsServiceImpl)))
// 前后端分离是 STATELESS,故 session 使用该策略
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}
// 此处配置 AuthenticationManager,并且实现缓存
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
// 对自己编写的 UserDetailsServiceImpl 进一步包装,实现缓存
CachingUserDetailsService cachingUserDetailsService = cachingUserDetailsService(userDetailsServiceImpl);
// jwt-cache 我们在 ehcache.xml 配置文件中有声明
UserCache userCache = new SpringCacheBasedUserCache(cacheManager.getCache(“jwt-cache”));
cachingUserDetailsService.setUserCache(userCache);
/*
security 默认鉴权完成后会把密码抹除,但是这里我们使用用户的密码来作为 JWT 的生成密钥,
如果被抹除了,在对 JWT 进行签名的时候就拿不到用户密码了,故此处关闭了自动抹除密码。
*/
auth.eraseCredentials(false);
auth.userDetailsService(cachingUserDetailsService);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/*
此处我们实现缓存的时候,我们使用了官方现成的 CachingUserDetailsService ,但是这个类的构造方法不是 public 的,
我们不能够正常实例化,所以在这里进行曲线救国。
*/
private CachingUserDetailsService cachingUserDetailsService(UserDetailsServiceImpl delegate) {
Constructor ctor = null;
try {
ctor = CachingUserDetailsService.class.getDeclaredConstructor(UserDetailsService.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
Assert.notNull(ctor, “CachingUserDetailsService constructor is null”);
ctor.setAccessible(true);
return BeanUtils.instantiateClass(ctor, delegate);
}
}
Ehcache 配置
Ehcache 3 开始,统一使用了 JCache,就是 JSR107 标准,网上很多教程都是基于 Ehcache 2 的,所以大家可能在参照网上的教程会遇到很多坑。
JSR107:emm,其实 JSR107 是一种缓存标准,各个框架只要遵守这个标准,就是现实大一统。差不多就是我不需要更改系统代码,也能随意更换底层的缓存系统。
在 resources 目录下创建 ehcache.xml
文件:
<ehcache:config
xmlns:ehcache=“http://www.ehcache.org/v3”
xmlns:jcache=“http://www.ehcache.org/v3/jsr107”>
ehcache:cache alias=“jwt-cache”
ehcache:key-typejava.lang.String</ehcache:key-type>
ehcache:value-typeorg.springframework.security.core.userdetails.User</ehcache:value-type>
ehcache:expiry
ehcache:ttl unit="days"1</ehcache:ttl>
</ehcache:expiry>
ehcache:heap unit="entries"2000</ehcache:heap>
</ehcache:cache>
</ehcache:config>
在 application.properties
中开启缓存支持:
spring.cache.type=jcache
spring.cache.jcache.config=classpath:ehcache.xml
统一全局异常
我们要把异常的返回形式也统一了,这样才能方便前端的调用。
我们平常会使用 @RestControllerAdvice
来统一异常,但是它只能管理 Controller 层面抛出的异常。Security 中抛出的异常不会抵达 Controller,无法被 @RestControllerAdvice
捕获,故我们还要改造 ErrorController
。
@RestController
public class CustomErrorController implements ErrorController {
@Override
public String getErrorPath() {
return “/error”;
}
@RequestMapping(“/error”)
public ResponseEntity handleError(HttpServletRequest request, HttpServletResponse response) {
return new ResponseEntity(response.getStatus(), (String) request.getAttribute(“javax.servlet.error.message”), null);
}
}
测试
–
写个控制器试试,大家也可以参考我控制器里面获取用户信息的方式,推荐使用 @AuthenticationPrincipal
这个注解!!!
@RestController
public class MainController {
// 任何人都可以访问,在方法中判断用户是否合法
@GetMapping(“everyone”)
public ResponseEntity everyone() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (! (authentication instanceof AnonymousAuthenticationToken)) {
// 登入用户
return new ResponseEntity(HttpStatus.OK.value(), “You are already login”, authentication.getPrincipal());
} else {
return new ResponseEntity(HttpStatus.OK.value(), “You are anonymous”, null);
}
}
@GetMapping(“user”)
@PreAuthorize(“hasAuthority(‘ROLE_USER’)”)
public ResponseEntity user(@AuthenticationPrincipal UsernamePasswordAuthenticationToken token) {
return new ResponseEntity(HttpStatus.OK.value(), “You are user”, token);
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
最后
现在正是金三银四的春招高潮,前阵子小编一直在搭建自己的网站,并整理了全套的**【一线互联网大厂Java核心面试题库+解析】:包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
a工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!**
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。[外链图片转存中…(img-AquyVR5F-1712671080693)]
[外链图片转存中…(img-S2VjRuw4-1712671080694)]
[外链图片转存中…(img-3ikTAh8e-1712671080694)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
最后
现在正是金三银四的春招高潮,前阵子小编一直在搭建自己的网站,并整理了全套的**【一线互联网大厂Java核心面试题库+解析】:包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**
[外链图片转存中…(img-8HFY1n5f-1712671080695)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!