Spring boot 入门（四）：集成 Shiro 实现登录认证和权限管理

时间 2019-11-07

标签 spring boot 入门集成 shiro 实现登录认证权限管理栏目 Spring 繁體版

原文原文链接

本文是接着上篇博客写的：Spring boot 入门（三）：SpringBoot 集成结合 AdminLTE(Freemarker)，利用 generate 自动生成代码，利用 DataTable 和 PageHelper 进行分页显示。按照前面的博客，已经能够搭建一个简单的 Spring Boot 系统，本篇博客继续对此系统进行改造，主要集成了 Shiro 权限认证框架，关于 Shiro 部分，在本人以前的博客（认证与Shiro安全框架）有介绍到，这里就不作累赘的介绍。html

此系列的博客为实践部分，以代码和搭建系统的过程为主，如遇到专业名词，自行查找其含义。前端

1.Shiro 配置类

系统搭建到目前为止，主要用到了3个配置类，均与 Shiro 有关，后期随着项目的扩大，配置文件也会随之增多。java

FreeMarkerConfig：主要针对 FreeMarker 页面显示的配置，关于 Shiro 部分，为 Shiro 标签设置了共享变量，若是不设置此变量，FreeMarker 页面将不能识别 Shiro 的标签，其主要代码以下：

configuration.setSharedVariable("shiro", new ShiroTags());
复制代码

MShiroFilterFactoryBean：设置了过滤器，固然也能够在 Config 文件里面配置过滤器，其缺点是：在每次请求里面都作了 session 的读取和更新访问时间等操做，这样在集群部署 session 共享的状况下，数量级的加大了处理量负载。本项目后期将用到分布式，所以这里就直接将过滤器与 Config 配置文件分离，提升效率。

private final class MSpringShiroFilter extends AbstractShiroFilter {
        protected MSpringShiroFilter(WebSecurityManager webSecurityManager, FilterChainResolver resolver) {
            super();
            if (webSecurityManager == null) {
                throw new IllegalArgumentException("WebSecurityManager property cannot be null.");
            }
            setSecurityManager(webSecurityManager);
            if (resolver != null) {
                setFilterChainResolver(resolver);
            }
        }

        @Override
        protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse,
                                        FilterChain chain) throws ServletException, IOException {
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            String str = request.getRequestURI().toLowerCase();
            boolean flag = true;
            int idx = 0;
            if ((idx = str.indexOf(".")) > 0) {
                str = str.substring(idx);
                if (ignoreExt.contains(str.toLowerCase()))
                    flag = false;
            }
            if (flag) {
                super.doFilterInternal(servletRequest, servletResponse, chain);
            } else {
                chain.doFilter(servletRequest, servletResponse);
            }
        }

    }
复制代码

ShiroConfiguration：通用配置文件，此配置文件为 Shiro 的基础通用配置文件，只要是集成 Shiro，必有此文件，主要配置 Shiro 的登陆认证相关的信息，其代码以下：

/**
     * 设置shiro的缓存，缓存参数均配置在xml文件中
     * @return
     */
    @Bean
    public EhCacheManager getEhCacheManager() {
        EhCacheManager em = new EhCacheManager();
        em.setCacheManagerConfigFile("classpath:ehcache/ehcache-shiro.xml");  
        return em;  
    }
    /**
     * 凭证匹配器
     * （因为咱们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
     *  因此咱们须要修改下doGetAuthenticationInfo中的代码;
     * ）
     * @return
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher(){
       HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
       hashedCredentialsMatcher.setHashAlgorithmName("md5");//散列算法:这里使用MD5算法;
       hashedCredentialsMatcher.setHashIterations(1);//散列的次数，好比散列两次，至关于 md5(md5(""));
       return hashedCredentialsMatcher;
    }
    /**
     * 
     * 主文件
     */
    @Bean(name = "myShiroRealm")
    public UserRealm myShiroRealm(EhCacheManager cacheManager) {
        UserRealm realm = new UserRealm(); 
        realm.setCacheManager(cacheManager);
        realm.setCredentialsMatcher(hashedCredentialsMatcher());
        return realm;
    }
   //会话ID生成器
    @Bean(name = "sessionIdGenerator")
    public JavaUuidSessionIdGenerator javaUuidSessionIdGenerator(){
    	JavaUuidSessionIdGenerator javaUuidSessionIdGenerator = new JavaUuidSessionIdGenerator();
    	return javaUuidSessionIdGenerator;
    }
    @Bean(name = "sessionIdCookie")
    public SimpleCookie getSessionIdCookie(){
    	SimpleCookie sessionIdCookie = new SimpleCookie("sid");
    	sessionIdCookie.setHttpOnly(true);
    	sessionIdCookie.setMaxAge(-1);
    	return sessionIdCookie;
    	
    }
    /*<!-- 会话DAO -->*/
    @Bean(name = "sessionDAO")
    public EnterpriseCacheSessionDAO enterpriseCacheSessionDAO(){
    	EnterpriseCacheSessionDAO sessionDao = new EnterpriseCacheSessionDAO();
    	sessionDao.setSessionIdGenerator(javaUuidSessionIdGenerator());
    	sessionDao.setActiveSessionsCacheName("shiro-activeSessionCache");
    	return sessionDao;
    }
	@Bean(name = "sessionValidationScheduler")
	public ExecutorServiceSessionValidationScheduler getExecutorServiceSessionValidationScheduler() {
		ExecutorServiceSessionValidationScheduler scheduler = new ExecutorServiceSessionValidationScheduler();
		scheduler.setInterval(1800000);
		return scheduler;
	}
    @Bean(name = "sessionManager")
    public DefaultWebSessionManager sessionManager(EnterpriseCacheSessionDAO sessionDAO){
    	DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    	sessionManager.setGlobalSessionTimeout(1800000);
    	sessionManager.setDeleteInvalidSessions(true);
    	sessionManager.setSessionValidationSchedulerEnabled(true);
    	sessionManager.setSessionValidationScheduler(getExecutorServiceSessionValidationScheduler());
    	sessionManager.setSessionDAO(sessionDAO);
    	sessionManager.setSessionIdCookieEnabled(true);
    	sessionManager.setSessionIdCookie(getSessionIdCookie());
    	return sessionManager;
    }
    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }
    @Bean
    public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator();
        daap.setProxyTargetClass(true);
        return daap;
    }
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(UserRealm myShiroRealm, DefaultWebSessionManager sessionManager) {
        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
        dwsm.setRealm(myShiroRealm);
//      <!-- 用户受权/认证信息Cache, 采用EhCache 缓存 --> 
        dwsm.setCacheManager(getEhCacheManager());
        dwsm.setSessionManager(sessionManager);
        return dwsm;
    }
    /**
     *  开启shiro aop注解支持.
     *  使用代理方式;因此须要开启代码支持;
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(securityManager);
        return aasa;
    }
    /**
     * ShiroFilter<br/>
     * 注意这里参数中的 StudentService 和 IScoreDao 只是一个例子，由于咱们在这里能够用这样的方式获取到相关访问数据库的对象，
     * 而后读取数据库相关配置，配置到 shiroFilterFactoryBean 的访问规则中。实际项目中，请使用本身的Service来处理业务逻辑。
     *
     */
    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new MShiroFilterFactoryBean();
        // 必须设置 SecurityManager  
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 若是不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登陆成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/certification");
        //shiroFilterFactoryBean.setSuccessUrl("/index");
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
        loadShiroFilterChain(shiroFilterFactoryBean);
        return shiroFilterFactoryBean;
    }
    /**
     * 加载shiroFilter权限控制规则（从数据库读取而后配置）
     *
     */
    private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean){
        /////////////////////// 下面这些规则配置最好配置到配置文件中 ///////////////////////
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        // authc：该过滤器下的页面必须验证后才能访问，它是Shiro内置的一个拦截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter
        filterChainDefinitionMap.put("/login", "authc");
        filterChainDefinitionMap.put("/logout", "logout");
        // anon：它对应的过滤器里面是空的,什么都没作
        logger.info("##################从数据库读取权限规则，加载到shiroFilter中##################");
//        filterChainDefinitionMap.put("/user/edit/**", "authc,perms[user:edit]");// 这里为了测试，固定写死的值，也能够从数据库或其余配置中读取
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
    }
复制代码

2.登陆认证与权限管理

主要重写了 Realm域，完成权限认证和权限管理：web

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		//若是没有作权限验证，此处只须要return null便可
		SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
		String userName = (String) principals.getPrimaryPrincipal();
		Result<TUser> list = userService.getUserByUsername(userName);
		if(list.isStatus()) {
			//获取该用户所属的角色
			Result<List<TRole>> resultRole = roleService.getRoleByUserId(list.getResultData().getUserId());
			if(resultRole.isStatus()) {
				HashSet<String> role = new HashSet<String>();
				for(TRole tRole : resultRole.getResultData()) {
					role.add(tRole.getRoleId()+"");
				}
				//获取该角色拥有的权限
				Result<List<TPermission>> resultPermission = permissionService.getPermissionsByRoleId(role);
				if(resultPermission.isStatus()) {
					HashSet<String> permissions = new HashSet<String>();
					for(TPermission tPermission : resultPermission.getResultData()) {
						permissions.add(tPermission.getPermissionsValue());
					}
					System.out.println("权限："+permissions);
					authorizationInfo.setStringPermissions(permissions);
				}
			}
		}
		//return null;
		return authorizationInfo;
	}

	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
		//认证登陆
		String username = (String) authenticationToken.getPrincipal();
		//String password = new String((char[]) authenticationToken.getCredentials());
		Result<TUser> result = userService.getUserByUsername(username);
		if (result.isStatus()) {
			TUser user = result.getResultData();
			return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
		}
		//return new SimpleAuthenticationInfo(user., "123456", getName());
		return null;
	}
}
复制代码

2.1.登陆认证

首先建立一个前端登陆界面，作一个简单的登陆 Form 表单算法

点击登陆即想后台发送一个请求， 必须是Post请求，不然Shiro不能识别，认证部分主要在 Ream 中完成，新建一个类，继承 AuthorizingRealm ，而后在重写 doGetAuthenticationInfo 方法：

只须要经过界面上的用户名查找到数据库存储的相关信息便可，具体的认证是 Shiro 内部本身完成的，咱们只须要传入数据库中存储的用户名和密码个认证函数便可（ new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName())），咱们能够本身从新定义密码比较器，密码比较器的写法较多，在认证与Shiro安全框架中，直接将密码比较器写入到Ream中，耦合度过高，本项目经过配置的方式重写密码比较器，具体代码请参考参考ShiroConfiguration配置类：

在具体的 Login 方法中，写入一些登陆失败的异常便可，主要用户将此失败结果存入 Session，并显示在页面上：数据库

@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String postLogin(RedirectAttributes redirectAttributes, HttpServletRequest request, HttpSession session) {
		// 登陆失败从request中获取shiro处理的异常信息。
		// shiroLoginFailure:就是shiro异常类的全类名.
		String exception = (String) request.getAttribute("shiroLoginFailure");

		System.out.println("exception=" + exception);
		String msg = "";
		if (exception != null) {
			if (UnknownAccountException.class.getName().equals(exception)) {
				System.out.println("UnknownAccountException -- > 帐号不存在：");
				msg = "用户不存在！";
			} else if (IncorrectCredentialsException.class.getName().equals(exception)) {
				System.out.println("IncorrectCredentialsException -- > 密码不正确：");
				msg = "密码不正确！";
			} else if ("kaptchaValidateFailed".equals(exception)) {
				System.out.println("kaptchaValidateFailed -- > 验证码错误");
				msg = "验证码错误!";
			} else {
				//msg = "else >> "+exception;
				msg = "密码不正确！";
				System.out.println("else -- >" + exception);
			}
		}
		redirectAttributes.addFlashAttribute("msg", msg);
		session.setAttribute("msg", msg);
		//return redirect("/login");
		return "redirect:login";
		//return msg;
	}
复制代码

此时登陆认证部门已经完成：一个页面+后台2个函数（1个认证函数+1个Login函数）apache

2.2.权限管理

整体来讲，权限管理只须要在界面增长 Shiro 的权限标签便可，可使用角色的标签，也可使用权限的标签，通常状况下2种标签配合使用，效果最好 <@shiro.hasPermission name="xtgl-yhgl:read"> <@shiro.hasRolen name="xtgl-yhgl:read">缓存

此外，在 Realm 中，须要重写权限认证的业务逻辑，一般状况下经过用户 ID 找到该用户所属的角色，而后经过角色 ID 找到该角色拥有的权限，并将角色或者权限写入的 Shiro 中便可： authorizationInfo.setStringPermissions(permissions); authorizationInfo.setRoles(role);

本项目也是经过此逻辑完成权限管理的安全

上面2张截图表示的是一个函数。

到此，Spring Boot集成Shiro框架的权限认证已经搭建完毕，能够实现简单的权限管理。bash

3.新增文件

较上一篇博客，Shiro 部分新增长的文件