SpringBoot整合Shiro流程

已于 2024-05-31 10:04:57 修改
阅读量243 收藏
点赞数 1
分类专栏： springboot 文章标签： spring boot java 后端
于 2024-05-31 09:56:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67727883/article/details/139343204
版权

1.pom.xml导入shiro相关jar包

<dependency>
	<groupId>org.apache.shiro</groupId>
	<artifactId>shiro-spring</artifactId>
	<version>1.4.0</version>
</dependency>
<dependency>
	<groupId>org.apache.shiro</groupId>
	<artifactId>shiro-ehcache</artifactId>
	<version>1.4.0</version>
</dependency>

2.封装Shiro配置类

在配置类中Realm，DefaultWebSecurityManager,ShiroFilterFactoryBean这三个Bean必须要配置的。

@Configuration
public class ShiroConfiguration {
	@Bean
	public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
		ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
		shiroFilterFactoryBean.setSecurityManager(securityManager);

		shiroFilterFactoryBean.setLoginUrl("/login");

		Map<String, Filter> filters = new LinkedHashMap<>();
		filters.put("authc", new JwtFilter());

		shiroFilterFactoryBean.setFilters(filters);
		Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
		// 登录接口排除
		filterChainDefinitionMap.put("/login", "anon");
		// 退出登录接口排除
		filterChainDefinitionMap.put("/logout", "anon");
		// 图形验证码接口排除
		filterChainDefinitionMap.put("/captcha", "anon");

		anon(filterChainDefinitionMap);
		filterChainDefinitionMap.put("/**", "authc");
		shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
		return shiroFilterFactoryBean;
	}

	private void anon(Map<String, String> filterChainDefinitionMap) {
		filterChainDefinitionMap.put("/", "anon");
		filterChainDefinitionMap.put("/*.html", "anon");
		filterChainDefinitionMap.put("/favicon.ico", "anon");
		filterChainDefinitionMap.put("/css/**", "anon");
		filterChainDefinitionMap.put("/js/**", "anon");
		filterChainDefinitionMap.put("/beta/**", "anon");
		filterChainDefinitionMap.put("/fonts/**", "anon");
		filterChainDefinitionMap.put("/layui/**", "anon");
		filterChainDefinitionMap.put("/img/**", "anon");
		filterChainDefinitionMap.put("/v2/api-docs/**", "anon");
		filterChainDefinitionMap.put("/swagger-resources/**", "anon");
		filterChainDefinitionMap.put("/webjars/**", "anon");
		filterChainDefinitionMap.put("/pages/**", "anon");
		filterChainDefinitionMap.put("/druid/**", "anon");
		filterChainDefinitionMap.put("/statics/**", "anon");
	}

	@Bean
	public DefaultWebSecurityManager securityManager() {
		DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
		// 多realm
		Set<Realm> realms = new HashSet<>(MediaConstants.DEFAULT_COLLECTION_SIZE);
		realms.add(adminRealm());
		securityManager.setRealms(realms);
		// 关闭session
		DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
		DefaultSessionStorageEvaluator sessionStorageEvaluator = new DefaultSessionStorageEvaluator();
		sessionStorageEvaluator.setSessionStorageEnabled(false);
		subjectDAO.setSessionStorageEvaluator(sessionStorageEvaluator);
		securityManager.setSubjectDAO(subjectDAO);
		securityManager.setAuthenticator(authenticator());
		return securityManager;
	}

	@Bean
	public Authenticator authenticator() {
		ModularRealm modularRealm = new ModularRealm();
		modularRealm.setRealms(Arrays.asList(adminRealm()));
		modularRealm.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
		return modularRealm;
	}

	@Bean
	public AdminShiroRealm adminRealm() {
		AdminShiroRealm mobileRealm = new AdminShiroRealm();
		mobileRealm.setName(LoginAdminTypeEnums.ADMIN_USER.value);
		return mobileRealm;
	}


	@Bean
	@DependsOn("lifecycleBeanPostProcessor")
	public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
		DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
		defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
		return defaultAdvisorAutoProxyCreator;
	}

	@Bean
	public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
		return new LifecycleBeanPostProcessor();
	}

	@Bean
	public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
			DefaultWebSecurityManager securityManager) {
		AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
		advisor.setSecurityManager(securityManager);
		return advisor;
	}

}

3.配置Realm

Realm中主要涉及用户身份验证和授权策略信息的设置

@Data
public class AdminShiroRealm extends AuthorizingRealm {

    @Autowired
    private UserAuthService userAuthMgr;

    /**
     * 使用JWT替代原生Token
     *
     * @param token
     * @return
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    private static final String ADMIN_USER_LOGIN_TYPE = LoginAdminTypeEnums.ADMIN_USER.value;

    {
        // 设置realm的名字，非常重要
        super.setName(ADMIN_USER_LOGIN_TYPE);
    }

    /**
     * 功能： 获取用户权限信息，包括角色以及权限。只有当触发检测用户权限时才会调用此方法，例如checkRole,checkPermission
     *
     * @return AuthorizationInfo 权限信息
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String sid = JwtUtil.getSid(principals.toString());
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        // 查询用户权限
        List<String> userAuthList = userAuthMgr.getAuthority(sid);
        if (!CollectionUtils.isEmpty(userAuthList)) {
            Set<String> userAuthorities = new HashSet<>(userAuthList);
            authorizationInfo.setStringPermissions(userAuthorities);
        }

        return authorizationInfo;
    }

    /**
     * 功能： 用来进行身份认证，也就是说验证用户输入的账号和密码是否正确，获取身份验证信息，错误抛出异常
     *
     * @return 返回封装了用户信息的 AuthenticationInfo 实例
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        String token = (String) auth.getCredentials();
        if (StringUtils.isEmpty(token)) {
            throw new AuthenticationException("token非法无效!");
        }
        String loginAccount = JwtUtil.getLoginAccount(token);
        String loginType = JwtUtil.getLoginType(token);
        if (loginAccount == null || loginType == null) {
            throw new AuthenticationException("token非法无效!");
        }
        if (!JwtUtil.verify(token, loginAccount)) {
            throw new AuthenticationException("token失效，请重新登录!");
        }
        return new SimpleAuthenticationInfo(token, token, getName());
    }
}

4.涉及到的工具类

/**
 * 鉴权登录拦截器
 *
 *
 */
public class JwtFilter extends BasicHttpAuthenticationFilter {

	private static final Logger logger = LoggerFactory.getLogger(JwtFilter.class);
	private static String AUTHORIZATION = "Authorization";
	
	@Override
	protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
		HttpServletRequest httpServletRequest = (HttpServletRequest) request;
		String token = httpServletRequest.getHeader(AUTHORIZATION);
		String loginType = JwtUtil.getLoginType(token);
		JwtToken jwtToken = new JwtToken(token,loginType);
		 // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        getSubject(request, response).login(jwtToken);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;
	}
	
	

	@Override
	protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
		if (isLoginRequest(request, response)) {
			try {
				return super.onAccessDenied(request, response);
			} catch (Exception e) {
				logger.error("onAccessDenied Exception", e);
				return false;
			}
		}
        try {
    		// 接口需要登录
			return executeLogin(request, response);
		} catch (Exception e) {
			return false;
		}
	}

	@Override
	protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
		//访问拒绝的逻辑
		if (isLoginRequest(request, response)) {
			return false;
		} 
		// 未登录
		Subject subject = getSubject(request, response);
		if (subject == null || subject.getPrincipal() == null) {
			WebUtils.responseJsonText(response, ApiResponse.of("401", "un login"));
			return false;
		}
		return super.onAccessDenied(request, response);
	}

	@Override
	protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request,
			ServletResponse response) {
		logger.warn("onLoginFailure AuthenticationToken={},AuthenticationException={}", token);
		try {
			WebUtils.responseJsonText(response, ApiResponse.of("500", e.getMessage()));
		} catch (IOException e1) {
			logger.error("response error", e);
			return false;
		}
		return false;
	}

	@Override
	protected String getHost(ServletRequest request) {
		return WebUtils.getHost(request);
	}

}
public class JwtUtil {

	public static final String SID = "sid"; 
	
	public static final String LOGIN_ACCOUNT = "loginAccount";
	/**
	 * 机构id
	 */
	public static final String ORGANIZATION_ID = "organizationId"; 
	/**
	 * 登录类型
	 */
	public static final String LOGIN_TYPE = "loginType";

	/**
	 * 登录昵称
	 */
	public static final String LOGIN_NICKNAME = "loginNickname";

	/**
	 * 校验token是否正确
	 * 
	 * @param token  密钥
	 * @param loginAccount 登录账号
	 * @return 是否正确
	 */
	public static boolean verify(String token, String loginAccount) {
		try {
			Long userId = getUserId(token);
			Algorithm algorithm = Algorithm.HMAC256(Md5Utils.md5Hex(userId.toString()));
			JWTVerifier verifier = JWT.require(algorithm).withClaim(LOGIN_ACCOUNT, loginAccount).build();
			verifier.verify(token);
			return true;
		} catch (Exception exception) {
			return false;
		}
	}

	/**
	 * 获得token中的信息无需secret解密也能获得
	 * 
	 * @return token中包含的用户名
	 */
	public static String getLoginAccount(String token) {
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim(LOGIN_ACCOUNT).asString();
		} catch (JWTDecodeException e) {
			return null;
		}
	}

	/**
	 * 获得token中的信息无需secret解密也能获得
	 *
	 * @return token中包含的用户名
	 */
	public static String getLoginNickname(String token) {
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim(LOGIN_NICKNAME).asString();
		} catch (JWTDecodeException e) {
			return null;
		}
	}

	public static Long getUserId(String token) {
		if(StringUtils.isEmpty(token)) {
			return null;
		}
		try {
			DecodedJWT jwt = JWT.decode(token);
			return Long.parseLong(jwt.getSubject());
		} catch (JWTDecodeException e) {
			return null;
		}
	}
	
	public static String getSid(String token) {
		if(StringUtils.isEmpty(token)) {
			return null;
		}
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim(SID).asString();
		} catch (JWTDecodeException e) {
			return null;
		}
	}

	/**
	 * 后台管理员生成签名
	 * @param loginAccount 用户名
	 * @return 加密的token
	 */
	public static String signAdmin(String loginAccount,Long userId,String sid,String loginType,String nickName) {
		try {
			loginAccount = StringUtils.lowerCase(loginAccount);
			Algorithm algorithm = Algorithm.HMAC256(Md5Utils.md5Hex(userId.toString()));
			return JWT.create()
					.withClaim(LOGIN_ACCOUNT, loginAccount)
					.withClaim(SID, sid)
					.withClaim(LOGIN_TYPE, loginType)
					.withClaim(LOGIN_NICKNAME,nickName)
					.withSubject(String.valueOf(userId))
					.withExpiresAt(new Date(System.currentTimeMillis() + CacheExpiresTime.ADMIN_EXPIRE_TIME_MILLISECOND))
					.sign(algorithm);
		} catch (Exception e) {
			return null;
		}
	}
	
	
	public static String getLoginType(String token) {
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim(LOGIN_TYPE).asString();
		} catch (JWTDecodeException e) {
			return null;
		}
	}
	
	/**
	 * 
	 * title: 获取当前登录用户的机构id
	 * @param token
	 * @return
	 */
	public static Long getOrganizationId(String token) {
		if(StringUtils.isEmpty(token)) {
			return null;
		}
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim(ORGANIZATION_ID).asLong();
		} catch (JWTDecodeException e) {
			return null;
		}
	}

}

窗台绿萝
关注
专栏目录
Shiro教程（二）：Springboot整合Shiro全网最全教程
WwLK123的博客
07-12 1576
Apache Shiro是一个Java的安全权限框架。Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。- Shiro可以完成认证、授权、加密、会话管理、Web集成、缓存等。这里是SpringBoot整合Shiro最完整最详细教程。
SpringBoot整合Shiro验证Jwt
m0_51382710的博客
11-14 355
使用SpringBoot整合Shiro对token进行校验
SpringBoot整合shiro流程
huahualongxiu的博客
07-13 193
万事还是先导依赖参考案例(https://www.cnblogs.com/wushaopei/p/11681408.html): <!--shiro 核心--> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <vers
springboot整合shiro
akego的博客
10-27 1413
Subject(用户):当前的操作用户 获取当前用户Subject currentUser = SecurityUtils.getSubject()SecurityManager（安全管理器）:Shiro的核心,负责与其他组件进行交互,实现 subject 委托的各种功能。Realms（数据源） :Realm会查找相关数据源,充当与安全管理间的桥梁,经过Realm找到数据源进行认证,授权等操作。数据库5张表：用户表 角色表 权限表 用户与角色的中间表 角色与权限的中间表。
springboot整合shiro的步骤
weixin_42847626的博客
12-17 424
1.引入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4.1</version> </dependency> 2.在yml文件配...
Spring Boot-自动配置问题
Flying_Fish_roe的博客
09-16 1435
Spring Boot 的自动配置在简化开发的同时，也带来了不少问题，尤其是在复杂的企业级应用中，自动配置可能引发 Bean 冲突、性能问题或者不必要的依赖。不过，了解其工作机制以及常见的配置排除与调试手段，可以有效避免这些问题。
Spring boot启动过程详解
chyohn的博客
09-05 1762
本篇主要介绍spring boot在启动过程中都做了哪些工作，重点介绍在spring容器ApplicationContext刷新前都做了哪些准备，本篇以源码解释为主，示例为辅进行梳理其过程。Spring boot整个启动过程分为3部分，分别是1.准备环境配置，2. 准备Spring容器并刷新容器，3. 容器刷新后处理。每个部分又有如下图所示的步骤，本篇详细讲解这些步骤。
Spring Boot-版本兼容性问题
Flying_Fish_roe的博客
09-14 1248
Spring Boot 作为一个高度集成的框架，其版本兼容性涉及到多个方面，包括与 Spring Framework、JDK、第三方库、Spring Cloud 及开发工具之间的兼容性问题。在实际项目开发中，版本不兼容是常见问题，容易导致功能异常、编译错误甚至系统崩溃。尽量使用 Spring Boot 官方推荐的依赖版本，避免手动管理依赖版本。定期检查和升级项目中的依赖库，并在升级前充分测试。使用 Spring Boot 和 Spring Cloud 的 BOM 管理依赖，以确保版本兼容性。
Spring Boot- 配置文件问题
Flying_Fish_roe的博客
09-16 1145
Spring Boot 提供了强大的配置文件机制，帮助开发者灵活管理应用的配置。然而，随着项目复杂度的增加，配置文件也会带来一些问题，如配置未生效、敏感信息管理、复杂配置管理等。通过了解 Spring Boot 配置文件的加载顺序、配置优先级，以及借助外部化配置和动态刷新等机制，开发者可以更好地管理和优化项目的配置文件。总之，Spring Boot 的配置文件机制极大地简化了配置管理的复杂性，但在使用过程中需要根据项目需求合理设计配置策略，避免配置文件的混乱和冗余，确保应用的安全性和可维护性。
Spring Boot-应用启动问题
最新发布
Flying_Fish_roe的博客
09-16 1225
Spring Boot 应用启动失败通常表现为以下几种情况： - **应用启动卡顿或超时**：应用启动过程中长时间没有响应，最终超时或抛出异常。 - **启动过程中出现异常**：在控制台或日志文件中打印出详细的异常堆栈信息，提示某个模块加载失败。 - **端口冲突**：当应用启动时，提示无法绑定到特定端口，导致启动失败。 - **Bean 初始化失败**：启动过程中，Bean 初始化出现问题，抛出 `BeanCreationException`。 - **外部资源加载失败**：在启动过程中无法成功加载所需的
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
weixin_48278764的博客
09-14 1189
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
Spring Boot：现代化Java应用开发的艺术
2302_78593467的博客
09-09 2357
Spring Boot是Pivotal团队（现为VMware的一部分）提供的一套快速开发Spring应用的脚手架。它基于Spring框架，通过提供一系列的“Starters”和自动配置，简化了Spring应用的初始搭建和开发过程。Spring Boot的目标是让你尽可能快地运行和部署Spring应用。Spring Boot通过提供一系列的Starters、自动配置和简化的部署流程，极大地提高了Java应用的开发效率。
使用Spring Boot集成Nacos进行配置管理
心猿意码
09-14 1066
Nacos是一个易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它旨在帮助开发者更轻松地构建、部署微服务应用，并且可以与Spring Cloud、Dubbo等生态无缝集成。动态服务发现：自动发现服务及其实例，支持健康检查。配置管理：集中化、外部化和动态化的配置管理能力。服务及其元数据管理：提供丰富的元数据来描述服务，如版本、环境、标签等。安全性和授权：支持基于角色的访问控制和安全通信。分布式会话管理：包括选举、锁、广义状态机等。
Spring Boot-跨服务事务管理问题
Flying_Fish_roe的博客
09-15 1457
Spring Boot 在跨服务事务管理上提供了多种解决方案，从传统的两阶段提交到基于消息的最终一致性和 SAGA 模式。每种方案都有其优缺点，开发者应根据系统需求和性能考量选择合。
Spring Boot-Session管理问题
Flying_Fish_roe的博客
09-15 1223
Session 管理是 Spring Boot 应用中的一个重要组成部分，尤其在用户身份验证、购物车等功能中起着至关重要的作用。然而，在实际开发中，Session 共享、数据丢失、并发访问等问题时常发生。通过合理的配置和优化，开发者可以有效解决这些问题，提高系统的稳定性和安全性。使用 Redis 或数据库进行分布式 Session 管理、优化 Session 存储和访问、增强会话安全性，都是解决 Session 管理问题的有效策略。
Spring Boot校园管理系统：技术选型与架构设计
2401_85341950的博客
09-13 890
Java语言具有很好的面向对象性，可以符合人的思维模式进行设计，封装是将对象的属性和方法尽可能地隐藏起来，使得外界并不知道是如何实现的，外界能通过接口进行访问，继承是指每个类都会有一个父类，所有的子类都有父类的方法，可以进行继承，但是只有final修饰的类不能被继承，通过继承可以使得代码得到重新利用，能够提高软件的开发效率，也是多态的前提。该框架使用特定的配置方法，无需开发人员定义样板配置。通过对功能的测试，校园管理系统的基本功能都是可行的，不管是系统里面的功能，还是界面的设计都是可值得推广宣传的。
Spring Boot- 数据库相关问题
Flying_Fish_roe的博客
09-16 1503
Spring Boot与数据库的集成虽然简化了开发工作，但依然存在许多潜在问题。通过合理配置数据库连接池、优化SQL查询、避免常见性能陷阱、管理事务以及使用数据库迁移工具，开发者可以有效避免或解决这些问题。良好的数据库设计与调优方案不仅能够提升应用的性能和稳定性，还能为日后的扩展和维护提供保障。
Guns后台管理系统教程：SpringBoot整合Shiro与Mybatis-Plus
Guns的设计目标是简化后端管理系统的开发工作，通过整合一系列成熟的技术栈，如SpringMVC、Shiro、Mybatis-Plus、Beetl以及Flowable，为开发者提供了高效便捷的开发环境。 首先，让我们深入理解Guns的核心特性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值