|
依赖：
org.apache.shiro
shiro-spring-boot-web-starter
1.4.1
1.自定义token继承UsernamePasswordToken
public class JwtToken extends UsernamePasswordToken {
private String token;
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public JwtToken(String username, String password) {
super(username, password);
}
}
注意 ：继承 UsernamePasswordToken 类后，账号跟密码使用了 UsernamePasswordToken 类的构造方法
2.自定义Realm
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class CustomerRealm extends AuthorizingRealm {
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JwtToken;
}
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
/*
常见的方法：
addRole(String role)：向授权信息中添加角色。
addRoles(Collection roles)：向授权信息中添加多个角色。
addStringPermission(String permission)：向授权信息中添加权限（字符串形式）。
addStringPermissions(Collection permissions)：向授权信息中添加多个权限（字符串形式）。
setRoles(Set roles)：设置授权信息的角色集合。
setStringPermissions(Set permissions)：设置授权信息的权限集合。
getRoles()：获取授权信息中的角色集合。
getStringPermissions()：获取授权信息中的权限集合。
*/
// 在这里只是设置权限了一个普通的权限：字符串
authorizationInfo.addStringPermission("user:add:*");
return authorizationInfo;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
JwtToken jwtToken = (JwtToken) authenticationToken;
return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
}
}
自定义Realm注意的点：
第一点：
在 doGetAuthenticationInfo 方法里面，他的返回值：
return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
SimpleAuthenticationInfo 对象是要重点说一下的：
第一个参数是验证成功之后保存的用户数据，是一个Object类型，第二个参数传递的是要做密码比较的参数：
首先来看下这个图，这个是我模拟登录时候的代码，可以看到我把账号跟密码传递给了 JwtToken：
而 JwtToken 继承了 UsernamePasswordToken 类，继续点进源码：
可以看到在 UsernamePasswordToken 类中获取账号跟密码相对应的方法，然后我在登录的controller中，继续调用以下方法进行登录：
Subject subject = SecurityUtils.getSubject();
subject.login(token);
以上代码执行之后，会进入 doGetAuthenticationInfo 这个方法里面，进行登录认证（拿账号密码去数据库里面查询）成功之后，如果SimpleAuthenticationInfo 的第二个参数跟我传递给 new JwtToken("123456789","147258369") 的第二个参数不一样的话，就会认证失败，个人觉得 SimpleAuthenticationInfo 的第二个参数类型是：
而在登录的时候，传递进来的 JwtToken 继承的 UsernamePasswordToken类的密码：
命名一样，所以我觉得会做比较，如果不一致，会报错异常：（个人猜测）
如果登录的时候，认证失败：会返回：IncorrectCredentialsException 异常
第二点（进入doGetAuthorizationInfo 方法的时机）：
doGetAuthorizationInfo方法不是主动调用的，而是被动调用的，当请求的接口上有类似这种 RequiresPermissions 注解的时候，就会去执行方法，判断是否有对应的权限
执行流程（请求设置了拦截路径的接口）：在过滤器中使用 shrio 的登录方法，进入doGetAuthenticationInfo 方法中进行认证，认证成功之后会请求接口，如果接口上有shiro的权限或者角色注解，那么就会进入 doGetAuthorizationInfo 方法中获取相对应的权限或者角色，然后就会再返回接口中，如果有权限就执行接口的方法
第三点：我在测试的时候，发现加入了AOP依赖之后，对于放行路径，过滤器一样会进行拦截，目前这个我还没找到解决方法，只能无奈把AOP依赖去掉了（这个不知道你们会不会这样） 第四点：
3.设置shrio的配置类
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class shiroConfig {
//创建shirofilter,负责拦截所有请求
@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
Map filters = new HashMap();
filters.put("auth", new MyFilter());
shiroFilterFactoryBean.setFilters(filters);
//配置系统受限资源
//配置系统公共资源
Map map = new LinkedHashMap();
// 在这里，我放行请求的的是我的登录接口
map.put("/user/login","anon");
// 其余接口我都要进行拦截 ，拦截器是 new MyFilter()
map.put("/**","auth");
shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
return shiroFilterFactoryBean;
}
//创建shiro安全管理器
@Bean
public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
//关闭shiro自带的session
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
defaultWebSecurityManager.setSubjectDAO(subjectDAO);
//配置realm
defaultWebSecurityManager.setRealm(realm);
return defaultWebSecurityManager;
}
//创建自定义realm
@Bean
public Realm getRealm(){
CustomerRealm customerRealm = new CustomerRealm();
//设置缓存管理器
customerRealm.setCachingEnabled(false);
customerRealm.setAuthenticationCachingEnabled(true);
customerRealm.setAuthenticationCacheName("AuthenticationCache");
customerRealm.setAuthorizationCachingEnabled(true);
customerRealm.setAuthorizationCacheName("AuthorizationCache");
return customerRealm;
}
}
配置类要注意的点：
在配置拦截放行路径的时候，一定不能使用 hashmap，而是使用 LinkedHashMap ，然后配置路径的时候，不用拦截的请求放在前面，一般 /** 是放在最后的：
4.配置过滤器：
package com.example.mp_pring.config.shiro;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class MyFilter extends BasicHttpAuthenticationFilter {
/**
* 执行登录认证
*
* @param request
* @param response
* @param mappedValue
* @return
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
try {
return executeLogin(request, response);
} catch (Exception e) {
System.out.println("JwtFilter过滤认证失败!");
return false;
}
}
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
// token 一般都是放在请求头中
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader("Token");
// 假设已经拿到token，并校验token了，如果校验不通过就直接 return false;
// token校验成功，拿到账号跟密码
JwtToken jwtToken = new JwtToken("123456789","147258369");
try {
// 提交给realm进行登入，如果错误他会抛出异常并被捕获
Subject subject = SecurityUtils.getSubject();
subject.login(jwtToken);
// 如果没有抛出异常则代表登入成功，返回true
return true;
} catch (AuthenticationException e) {
response.setCharacterEncoding("utf-8");
response.getWriter().print("error");
return false;
}
}
/**
* 对跨域提供支持
* @param request
* @param response
* @return
* @throws Exception
*/
@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
httpServletResponse.setStatus(HttpStatus.OK.value());
return false;
}
return super.preHandle(request, response);
}
}
5.演示：
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletResponse;
/**
* @Description:
* @Author sk
* @Date: 2023/4/4 18:40
*/
@Controller
@RequestMapping("/user")
public class UserControllerabc {
@RequestMapping("/login")
@ResponseBody
public String login() throws Exception {
JwtToken token = new JwtToken("123456789","147258369");
try {
Subject subject = SecurityUtils.getSubject();
subject.login(token);
System.out.println("认证成功");
}catch (Exception e){
e.printStackTrace();
System.out.println("认证失败");
}
return "success";
}
@RequestMapping("/test")
@ResponseBody
@RequiresPermissions("user:add:*")
public String test() {
Subject subject = SecurityUtils.getSubject();
Object principal = subject.getPrincipal();
PrincipalCollection principals = subject.getPrincipals();
return "success:验证成功：user:add:*";
}
@RequestMapping("/test1")
@ResponseBody
@RequiresPermissions("user:add:a")
public String test1() {
return "success:验证成功：user:add:a";
}
}
登录：http://localhost:8080/user/login
进入要权限的接口：http://localhost:8080/user/test ，http://localhost:8080/user/test1
这两个接口需要权限为 user:add:* 和 user:add:a 才能访问，在本案例中：
设置的权限就是 user:add:* ，所以按道理来说，test跟test1接口都能访问，* 代表的通配符
可以看到，都访问成功了
修改权限
我在这里把权限设置为了 user:add:a ，所以无法访问test接口，尝试一波：
可以看到，如果没有权限，会直接报错
6.演示文件：
本项目已经上传到本博客，需要的可自行下载，可直接使用
7.注意！！！！！：
我用了shrio之后，在controller层直接使用了事务的注解，导致这个controller里面的接口全报404了（但是这个在我另外一个项目里面没有出现），查了一下，是 shrio 跟 Transactional 的aop 执行时间有关系：可以参考一下别人的博客： 在Controller上使用@Transactional注解导致的接口404_@transactional controller_木子的木木的博客-CSDN博客
|