Springboot2集成Shiro框架（三）自定义Realm

1、realm的作用

Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
　　从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
　　Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

2、数据库设计

下图是一个简单的权限关系库，主要是有三个表，用户、角色、权限，为了容易管理，用户只关联角色，而不同的角色对应不同的权限，shiro框架允许我们随意配置权限粗细度，可以精确到角色，也可以细微至某个权限（比如：用户添加权限等），我们需要了解的是用户和角色是一对多的关系（一个用户对应多个角色），而权限和角色关系亦是一对多的关系。

3、创建自定义realm

即使shiro提供了如jdbcrealm，jndiRealm，和使用配置文件的realm，但是实际开发中，大部分情况仍需要我们根据实际情况定制适合自己项目的realm处理器，shiro提供了 AuthorizingRealm 抽象类，创建 MyShiroRealm 类继承 AuthorizingRealm 抽象类，重写 doGetAuthorizationInfo 方法，和 doGetAuthenticationInfo 方法，完成自定义realm，下面是我配置的realm。

需要注意的是，doGetAuthenticationInfo 是每次登录会调用，而 doGetAuthorizationInfo 方法则是访问到需要权限、角色的接口的时候才会调用！

import java.util.Set;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

import cn.junengxiong.bean.User;
import cn.junengxiong.service.UserService;

/**
 * 自定义登录权限认证
 * 
 * @ClassName: MyShiroRealm
 * @Description TODO
 * @version
 * @author jh
 * @date 2019年8月27日 下午4:12:40
 */

public class MyShiroRealm extends AuthorizingRealm {
    @Autowired
    UserService userService;

    /**
     * 权限设置
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入自定义权限设置方法！");
        String username = (String) principals.getPrimaryPrincipal();
        // 从数据库或换村中获取用户角色信息
        User user = userService.findByUsername(username);
        // 获取用户角色
        Set<String> roles = user.getRole();
        // 获取用户权限
        Set<String> permissions = user.getPermission();
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 设置权限
        simpleAuthorizationInfo.setStringPermissions(permissions);
        // 设置角色
        simpleAuthorizationInfo.setRoles(roles);

        return simpleAuthorizationInfo;
    }

   /**
     * 身份验证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("进入自定义登录验证方法！");
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        // 通过username从数据库中查找 User对象，如果找到，没找到.
        // 实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        String username = usernamePasswordToken.getUsername();
        String pwd = String.valueOf(usernamePasswordToken.getPassword());// 获取用户输入的密码
        User user = userService.findByUsername(username);
        if (user == null) {
            throw new UnknownAccountException();// 用户不存在
        }
        String password = user.getPassword();// 数据库获取的密码
        // 此处对用户输入密码进行加密，对比数据库查询出来加密后的密码，自定义加密方式
        // ............................
        // password = new SimpleHash("MD5", password, username, 1024).toString();
        if (!password.equals(pwd)) {
            throw new IncorrectCredentialsException();// 凭证错误
        }
        // 主要的（可以使用户名，也可以是用户对象），资格证书(数据库获取的密码)，区域名称（当前realm名称）
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username, password, getName());
        // 加盐,使用每个用户各自的用户名加盐，保证密码相同时但是加密后密码仍然不同,如果不适用shiro自带凭证比较器，或者自定义凭证比较器，可以不设置加盐
        // simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username));
        return simpleAuthenticationInfo;
    }


}

3.1 userService为null问题

1. 可以查看此文章，若解决则无需使用下面方式
2. 解决service事务失效问题

因为springboot的bean注入机制，会导致在此realm生成的时候userService不会被注入，所有需要我们手动把UserService注入进来，用到了SpringBeanFactoryUtil工具类：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
 * 
 * @ClassName:  SpringBeanFactoryUtil   
 * @Description 手动bean注入工具类，用于解决filter中注入service为null问题
 * @version 
 * @author jh
 * @date 2019年8月28日 上午10:29:37
 */
@Component
public class SpringBeanFactoryUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringBeanFactoryUtil.applicationContext == null) {
            SpringBeanFactoryUtil.applicationContext = applicationContext;
        }
    }

    private SpringBeanFactoryUtil() {
        // TODO Auto-generated constructor stub
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    // 根据名称-------@Resource 注解
    public static Object getBeanByName(String name) {
        return getApplicationContext().getBean(name);
    }

    // 根据类型-------@Autowired 注解
    public static <T> T getBeanByType(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    // 根据名称和类型--------@Autowired+@Qualifier
    public static <T> T getBeanByNameAndType(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

4、把自定义的Realm交给SecurityManager

我们声明好了自定义的realm后，需要把它交给SecurityManager来管理，需要在ShiroConfig类中，添加如下代码

• 返回自定义realm，放入SecurityManager

    /**
     * 自定义身份认证 realm;
     * 

     * 必须写这个类，并加上 @Bean 注解，目的是注入 MyShiroRealm， 否则会影响 MyShiroRealm类 中其他类的依赖注入
     */
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        return myShiroRealm;
    }

• SecurityManager 配置

    /**
     * 注入 securityManager
     */
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

5、user类

上面已经讲过了，一个用户对应着多个角色，而一个角色对应多个权限，
为了方便，不进行数据库的操作，在service中伪造三个用户，而每个用户拥有n个角色和n个权限，我们用set集合表示，可以根据情况随意拓展。

import java.util.Set;

public class User {
    private String username;
    private String password;
    private Set<String> role;
    private Set<String> permission;
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Set<String> getRole() {
        return role;
    }

    public void setRole(Set<String> role) {
        this.role = role;
    }

    public Set<String> getPermission() {
        return permission;
    }

    public void setPermission(Set<String> permission) {
        this.permission = permission;
    }

    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + ", role=" + role + ", permission=" + permission
                + "]";
    }


}

6、 业务层

6.1service

public interface UserService {
    User findByUsername(String username);
}

6.2serviceImpl

import java.util.HashSet;
import java.util.Set;

import org.springframework.stereotype.Service;

import cn.junengxiong.bean.User;
import cn.junengxiong.service.UserService;

@Service
public class UserServiceImpl implements UserService {

    @Override
    public User findByUsername(String username) {
        User user = new User();
        user.setUsername(username);
        Set<String> roleList = new HashSet<>();
        Set<String> permissionsList = new HashSet<>();
        switch (username) {
        case "admin":
            roleList.add("admin");
            user.setPassword("admin");
            permissionsList.add("user:add");
            permissionsList.add("user:delete");
            break;
        case "consumer":
            roleList.add("consumer");
            user.setPassword("consumer");
            permissionsList.add("consumer:modify");
            break;
        default:
            roleList.add("guest");
            user.setPassword("guest");
            break;
        }
        user.setRole(roleList);
        user.setPermission(permissionsList);
        return user;
    }

}

7、controller

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.ExcessiveAttemptsException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.junengxiong.bean.ReturnMap;

@RestController
public class ShiroController {

    @RequestMapping("/consumer/{str}")
    @RequiresRoles(value = { "admin", "consumer" }, logical = Logical.OR)
    public ReturnMap getMessage(@PathVariable(value = "str") String str) {
        return new ReturnMap().success().data(str);
    }

    @RequestMapping("/admin/{str}")
    @RequiresRoles("admin")
    public ReturnMap getMessageAdmin(@PathVariable(value = "str") String str) {
        return new ReturnMap().success().data(str);
    }

    @RequestMapping("/guest/{str}")
    public ReturnMap getMessageGuest(@PathVariable(value = "str") String str) {
        return new ReturnMap().success().data(str);
    }

    @RequestMapping("/login")
    public ReturnMap login(String username, Boolean rememberMe, String password) {
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        if (rememberMe != null) {
            token.setRememberMe(rememberMe);
        }
        try {
            // 登录
            subject.login(token);
        } catch (UnknownAccountException uae) {
            // 用户名未知...
            return new ReturnMap().fail().message("用户不存在！");
        } catch (IncorrectCredentialsException ice) {
            // 凭据不正确，例如密码不正确 ...
            return new ReturnMap().fail().message("密码不正确！");
        } catch (LockedAccountException lae) {
            // 用户被锁定，例如管理员把某个用户禁用...
            return new ReturnMap().fail().message("用户被锁定！");
        } catch (ExcessiveAttemptsException eae) {
            // 尝试认证次数多余系统指定次数 ...
            return new ReturnMap().fail().message("尝试认证次数过多，请稍后重试！");
        } catch (AuthenticationException ae) {
            // 其他未指定异常
            return new ReturnMap().fail().message("未知异常！");
        }
        return new ReturnMap().success().data("登录成功！");
    }

    @RequestMapping("/loginout")
    public ReturnMap getMessageGuest() {
        Subject subject = SecurityUtils.getSubject();
        // 登出
        subject.logout();
        return new ReturnMap().success().message("登出成功！");
    }

    /**
     * 无权限访问时
     * 
     * @return
     */
    @RequestMapping("/unauthorized")
    public ReturnMap unauthorized() {
        return new ReturnMap().invalid();
    }
}

8、添加对权限注解支持

这一步卡了我一些时间，刚开始接触shiro框架，但是加入权限控制注解，每次只会在登录的时候调用登录验证接口，但是访问有权限的接口时，并不会进入自定义realm中的 doGetAuthorizationInfo 方法，经查询，该方法只会在用户访问到需要权限的接口的时候才会调用，如果未使用缓存，则每次访问权限接口均会调用一次 doGetAuthorizationInfo 方法，另外权限注解需要加入两个配置项来支持，在shiroConfig配置类中添加如下代码，启动对权限注解的支持。

class ShiroConfig
....................
 /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * 
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    /**
     * 开启aop注解支持
     * 
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

9、补充

在学习shiro中查看了很多资料，博客，发现一些教学中会在ShiroConfig配置中添加如下配置

    /**
     * 配置Shiro生命周期处理器
     * 
     * @return
     */
//    @Bean(name = "lifecycleBeanPostProcessor")
//    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
//        return new LifecycleBeanPostProcessor();
//    }

但是，如果配合spring食用时，是无需配置此项的，可以查看
* shiro-spring-config.ShiroBeanConfiguration文件，此配置已经帮我们配置好了

10、测试页面

<html>
<head>
<meta charset="UTF-8">
<title>登录title>
head>

<body>
	<table>
		<tr>
			<td>请输入姓名td>
			<td><input type="text" name="username" id="username" />td>
		tr>
		<tr>
			<td>请输入密码td>
			<td><input type="password" name="password" id="password" />td>
		tr>
		<tr>
			<td>记住我td>
			<td><input type="checkbox" name="rememberMe" id="rememberMe" />td>
		tr>
	table>
	<button type="button" onclick="login()">登录button>
	<button type="button" onclick="loginout()">登出button>
	<table>
		<tr>
		  <td><button onclick="authority('/admin/可以访问admin')">admin 管理员接口button>td>
		  <td><button onclick="authority('/consumer/可以访问consumer')">consumer 用户接口button>td>
		  <td><button onclick="authority('/guest/可以访问guest')">guest 访客接口button>td>
		tr>
	table>
	<textarea rows="5" cols="60" id="textarea">textarea>
	<script src="https://cdn.bootcss.com/jquery/3.1.1/jquery.min.js">script>
body>
<script type="text/javascript">
	function login() {//登录
		var username = $('#username').val();
		var password = $('#password').val();
		var flag = $('#rememberMe').prop('checked');
		console.log(flag)
		$.ajax({
			url : '/login',
			data : {
				'username' : username,
				'password' : password,
				'rememberMe' : flag
			},
			success : function(res) {
				console.log(res)
				$('#textarea').val(JSON.stringify(res));
			}
		})
	}
	function loginout() {//登出
		$.ajax({
			url : '/loginout',
			success : function(res) {
				$('#textarea').val(JSON.stringify(res));
			}
		})
	}
	//权限测试
	function authority(url){
		$.ajax({
            url : url,
            success : function(res) {
                $('#textarea').val(JSON.stringify(res));
            }
        })
	}
script>
html>

11、进行测试

下面是这次的controller配置，可以看到

• admin可以访问所有接口
• consumer可以访问本身和guest接口
• guest只可以访问自己的接口
  

11.1测试结果

1.admin登录，进入登录认证方法，登录成功！

2. 测试管理员接口，进入权限验证方法，权限验证通过
3. consumer接口测试，可以看到，因为此接口设置了允许两种角色访问，shiro访问了两次权限认证方法
4. guest接口测试，可以看到，在没有加权限注解时，shiro是不会访问权限认证方法的
5. 换一个角色尝试一下，首先登录成功！
6. 访问admin接口，得到无权限访问，可以看到后台进行权限验证后抛出了 org.apache.shiro.authz.UnauthorizedException: Subject does not have role [admin] 权限验证异常：缺少角色admin，成功拦截访问！
7. 访问自己的consumer接口，可以访问，并且仍然进行了两次权限认证方法，即使我在注解上面填写所需角色为or关系也不行，有点像 非短路与 的意思，这里猜想如果填写三个是不是访问三次。。。。。。
8. 马上更改代码尝试，在consumer接口新增可访问角色‘superman’，直接点击访问执行了三次权限认证，猜想成功！

12、源码

如果需要源码可以在下面地址得到，如果帮助到了你可以

      ."`".
  .-./ _=_ \.-.
 {  (,(oYo),) }}
 {{ |   "   |} }
 { { \(---)/  }}
 {{  }'-=-'{ } }
 { { }._:_.{  }}
 {{  } -:- { } }
 {_{ }`===`{  _}
((((\)     (/))))

springboot 整合Shiro