shiro框架---shiro配置介绍（二）

接上一篇shiro框架—shiro配置介绍（一）

  项目已分享到GitHub上，如果需要的可以看下，springboot+shiro项目Git下载地址。

  关于shiro在springboot的配置，共有四个基本配置文件主要的文件有四个ShiroConfig 、RetryLimitHashedCredentialsMatcher 、UserRealm 、MShiroFilterFactoryBean。

  因为上一篇仅仅写完了shiroconfig 类的配置，虽然在上一篇最下边，我已经附上了所有文件的下载链接，但是我觉得还是要写一下剩下的三个配置文件，写一下我对shiro配置的理解。下边是剩余三个配置文件，即RetryLimitHashedCredentialsMatcher 、UserRealm 、MShiroFilterFactoryBean 的配置详情。

1.UserRealm 类的配置内容

具体代码如下：

package microservice.fpzj.shiro;
import java.util.HashSet;
import java.util.List;
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.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
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.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import microservice.fpzj.core.models.Permission;
import microservice.fpzj.core.models.Role;
import microservice.fpzj.core.models.User;
import microservice.fpzj.service.jwt.UserService;

/**
 * 验证用户登录
 * 
 * @author Administrator
 */
@Component("userRealm")
public class UserRealm extends AuthorizingRealm {   
    @Autowired
    private UserService userService;

    public UserRealm() {
        setName("UserRealm");
        // 采用MD5加密
        setCredentialsMatcher(new HashedCredentialsMatcher("md5"));
    }

    /**
    *权限资源角色配置，如果在jsp里加入了shiro的标签配置，将会在访问那个jsp页
    * 面的时候触发这个方法，这里先不考虑这个方法的逻辑。
    **/
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        User user = (User)principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        return info;
    }

    //登录验证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken upt = (UsernamePasswordToken) token;
        char[] passwords = upt.getPassword();
        String pwd = new String(passwords);
        if(!StringUtils.isEmpty(pwd)){ //如果密码不是空,表示是本地登录
            User user = this.userService.findUserByUserName(upt.getUsername());
            if(user == null){
                throw new AuthenticationException("no_user");
            }
            boolean res =true;
            for(Role r:user.getRoles()){
                if(r.getSiteid()==2){
                    res = false;
                    break;
                }
            }
            if(res){
                throw new AuthenticationException("no_permission");
            }
            if(user!=null  && !user.isDeleted()){
                SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
                        user, //用户对象
                        user.getPasswd(), //密码
                        ByteSource.Util.bytes(user.getUserid()+user.getUsername()),//salt=username+salt
                        getName());  //realm name
                return info;
            }       
            return null;//getAuthenticationInfoMethod(upt.getUsername());
        }else{
          /**
          *如果密码是空，表示是远程登录，从username位置获得token，
          *暂时不考虑这种情况，这里只走上边if里边
          **/
            String username = userService.getUsernameFromToken(upt.getUsername());
            return getAuthenticationInfoMethod(username);       
        }

    }
    public AuthenticationInfo getAuthenticationInfoMethod(String username){
        User user = userService.findUserByUserName(username);
        if(user == null){
            throw new AuthenticationException("no_user");
        }
        if(user != null){
            boolean res =true;
            for(Role r:user.getRoles()){
                if(r.getSiteid()==2){
                    res = false;
                    break;
                }
            }
            if(res){
                throw new AuthenticationException("no_permission");
            }

            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
                    user, //用户对象
                    user.getPasswd(), //密码
                    ByteSource.Util.bytes(user.getUserid()+user.getUsername()),//salt=username+salt
                    getName());  //realm name
            return info;
        }
        return null;
    }
}

  以上主要看登录验证方法doGetAuthenticationInfo 在该方法里，通过从自己写的userService 接口，先根据用户名查询出用户对象,即调用findUserByUserName 方法，获取用户对象下的角色roles，通过判断用户下的角色集合中，是否含有siteId 为2的，如果含有siteId 为2的，则让通过登录，如果没有当前siteId 的角色，则登录失败，站点siteId 表示系统类别，2在我们多系统里为业务系统，还有门户系统、后台系统等。
  siteId我在第一篇里已经写了，shiro框架—关于shiro框架的简单介绍及用户表的建立维护

2.RetryLimitHashedCredentialsMatcher 类的配置内容

  具体代码如下：

package microservice.fpzj.shiro;


import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import microservice.fpzj.core.models.User;
import microservice.fpzj.service.jwt.UserService;

/**
 * 
 * @author ZML
 *
 */
public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {
    @Autowired
    private UserService userService;

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        if(token instanceof UsernamePasswordToken){
            UsernamePasswordToken userToken = (UsernamePasswordToken) token;
            User user = userService.findUserByUserName(userToken.getUsername());
            char[] passwordchars =userToken.getPassword();
            String password = new String(passwordchars);
            if("".equals(password)){ //token字符串登录
                boolean flg = userService.verifyToken(userToken.getUsername());
                return flg;
            }else{ //账号密码登录
                boolean res = userService.passwordVerify(password,user.getPasswd(),user.getUserid()+user.getUsername());
                return res;
            }
        }
        return false;
    }
}

  上一篇已经说过，RetryLimitHashedCredentialsMatcher类，继承于HashedCredentialsMatcher 类，对于HashedCredentialsMatcher 类，你如果往上找，就会发现，其实就是实现了CredentialsMatcher 接口，最后又在shiroConfig 配置文件中，将该类注入到我们的spring容器中供UserRealm 调用，加入到shiro 框架里，这样就可以扩展我们自定义的这个RetryLimitHashedCredentialsMatcher 类，该类的功能主要是将用户输入的密码与查询到的密码进行比较，也就是密码比较器。
  上边方法doCredentialsMatch 的逻辑里，有verifyToken 这样的方法，其实这个是针对于那种没有账号密码，只有token 字符串的密钥登录的方式。这里先不说这一种。
  userService 里是我们自己提前写好的一系列针对于用户验证的接口，因为shiro 不会去维护用户、权限、角色这些东西，需要我们自己维护，关于建表的那些步骤，我在第一篇里已经写了，shiro框架—关于shiro框架的简单介绍及用户表的建立维护，比如这里的passwordVerify 方法 ，通过名字可以理解，是验证密码的接口，这些会在下一篇写出来。

3.MShiroFilterFactoryBean 类的配置内容

  还记得在上一篇文章shiro框架—shiro配置介绍（一） 里，提到过 MShiroFilterFactoryBean 继承于 ShiroFilterFactoryBean 类，是我们自己自定义的shiroFilter ,该类在shiroConfig 里注入到spring 容器中，另外，因为shiro 的拦截是对所有请求进行拦截，关于.js 、.css 、.html 、.png等静态资源的请求，应该是不要拦截的,所以我们需要在自定义shiroFilter 里对这些静态资源进行过滤，对我们项目来说，这就是这个MShiroFilterFactoryBean 的存在的意义。
  具体配置如下：

package microservice.fpzj.shiro;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.filter.mgt.FilterChainManager;
import org.apache.shiro.web.filter.mgt.FilterChainResolver;
import org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver;
import org.apache.shiro.web.mgt.WebSecurityManager;
import org.apache.shiro.web.servlet.AbstractShiroFilter;
import org.springframework.beans.factory.BeanInitializationException;
/**
 * 自定义shiro过滤规则
 * @author Administrator
 *
 */
public class MShiroFilterFactoryBean extends ShiroFilterFactoryBean{
//   对ShiroFilter来说，需要直接忽略的请求
    private Set<String> ignoreExt;
    public MShiroFilterFactoryBean() {
        super();
        ignoreExt = new HashSet<>();
        ignoreExt.add(".jsp");
//        ignoreExt.add(".png");
    }

    @Override
    protected AbstractShiroFilter createInstance() throws Exception {
        org.apache.shiro.mgt.SecurityManager securityManager = getSecurityManager();
        if (securityManager == null) {
            String msg = "SecurityManager property must be set.";
            throw new BeanInitializationException(msg);
        }

        if (!(securityManager instanceof WebSecurityManager)) {
            String msg = "The security manager does not implement the WebSecurityManager interface.";
            throw new BeanInitializationException(msg);
        }
        FilterChainManager manager = createFilterChainManager();
        PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
        chainResolver.setFilterChainManager(manager);
        return new MSpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
    }

    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();
            // 因为ShiroFilter 拦截所有请求（在上面我们配置了urlPattern 为 * ，当然你也可以在那里精确的添加要处理的路径，这样就不需要这个类了），而在每次请求里面都做了session的读取和更新访问时间等操作，这样在集群部署session共享的情况下，数量级的加大了处理量负载。
            // 所以我们这里将一些能忽略的请求忽略掉。
            // 当然如果你的集群系统使用了动静分离处理，静态资料的请求不会到Filter这个层面，便可以忽略。
            boolean flag = true;
            int idx = 0;
            if(( idx = str.indexOf(".")) > 0 ){
                str = str.substring(idx);
                /**
                *如果不是jsp则为false,即除了.jsp，其他的都不需要拦截
                **/
                if(!ignoreExt.contains(str.toLowerCase())){ 
                    flag = false;
                }
            }
            if(flag){
                super.doFilterInternal(servletRequest, servletResponse, chain);
            }else{
                chain.doFilter(servletRequest, servletResponse);
            }
        }

    }
}

  通过以上的配置，就会将所有不是.jsp 的又带有.资源全部放开，即,没有登录的情况下，可以访问到，其他带有. 的资源则全部被shiro拦截。

4.注意点

  以上的配置文件中，你会看到有很多的userService 中的方法，我没有贴出来，后边我也都会贴出来，但是，其实这样的逻辑基本都是数据库查询的逻辑。

比如：

  下面的这个是根据用户名获取用户对象的方法，因为用户名是唯一的，这个应该很容易写出来，就是根据用户名字段去匹配用户表的一条对象记录。

User user = userService.findUserByUserName(upt.getUsername())

  下面的这个是验证账号密码的方法。

boolean flag = userService.passwordVerify(password,user.getPasswd(),user.getUserid()+user.getUsername())

  下面的这个是根据token字符串获取用户名，token是一种jwt字符串，是一种很长的字符串，这里主要用于那种没有用户名，只有一个令牌token字符串，通过这个token字符串，来到后台验证的时候，需要通过这个字符串转换成用户名，然后再根据用户名，调用上边的方法获取用户对象。这里先不考虑这种的登录，只考虑正常的那种账号密码的登录方式。

String username = userService.getUsernameFromToken(upt.getUsername())

  下面的这个是验证客户端传入的token字符串是否有效的接口。同样这里不考虑这种的登录方式。

boolean flag = userService.verifyToken(userToken.getUsername())

下一篇文章shiro配置用户名和密码的注意