常规操作之安全框架Shiro

最新推荐文章于 2023-12-13 23:02:57 发布

GKTDSR

最新推荐文章于 2023-12-13 23:02:57 发布

阅读量313

点赞数

分类专栏：技术

本文链接：https://blog.csdn.net/GKTDSR/article/details/104327996

版权

技术专栏收录该内容

27 篇文章 0 订阅

订阅专栏

简介

shiro提供了：认证、授权、加密、会话管理、与web集成、缓存等模块。和spring Securte相比shiro更简单提供的成品逻辑很完善，只需实现和集成相应的接口和类即可实现特有的逻辑，例如AuthorizingRealm(数据源)，Filter(自定义拦截器)等等

Shiro结构

因为shiro默认进行session认证的，通过SessionManager(会话管理器)来控制请求的每次会话是否已经授权。

Shiro 认证主要结构

Subject(主体)：当前用户，不一定指当前访问人是指当前与应用交互的任何东西都被称为Subject。所有的Subject都会交给SecurityManager进行管理。
SecurityManager(安全管理器):Sbuject所有和安全相关的操作都会交给SecurityManager来进行操作，就像是Spring里面的DispatcherServlet一样负责和和各个组件进行交互。
Realm(安全数据源)：SecurityManager验证时的数据提供者，shiro从Realm中获取需要的信息来验证。通过自定义Realm可以看出其实就是DataSource的作用，提供一个安全的数据源。

Shiro内部结构示意图

所有结构

Subject：主体，可以看到主体可以是任何与应用交互的“用户”。
SecurityManager：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的FilterDispatcher。它是 Shiro 的核心，所有具体的交互都通过 SecurityManager 进行控制。它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。
Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得 Shiro 默认的不好，我们可以自定义实现。其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了。
Authrizer：授权器，或者访问控制器。它用来决定主体是否有权限进行相应的操作，即控制着用户能访问应用中的哪些功能。
Realm：可以有1个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的。它可以是 JDBC 实现，也可以是 LDAP 实现，或者内存实现等。
SessionManager：如果写过 Servlet 就应该知道 Session 的概念，Session 需要有人去管理它的生命周期，这个组件就是 SessionManager。而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境。
SessionDAO：DAO 大家都用过，数据访问对象，用于会话的 CRUD。我们可以自定义 SessionDAO 的实现，控制 session 存储的位置。如通过 JDBC 写到数据库或通过 jedis 写入 redis 中。另外 SessionDAO 中可以使用 Cache 进行缓存，以提高性能。
CacheManager：缓存管理器。它来管理如用户、角色、权限等的缓存的。因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能。
Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密/解密的。
Filter: 拦截器，集成Web的时候需要对特定的请求进行拦截，相当于Spring中的Interrupt ，拦截器类型：anon(匿名访问)、authc(授权后才允许访问)、authcBasic（需要HttpBasic认证）……拦截器支持自定义并在Shiro配置中加入就可使用自定义配置来拦截URL。

代码范例

自定义安全数据源

// 集成AuthorizingRealm因为
public class ShiroRealm extends AuthorizingRealm  {

    @Autowired
    private UsersService usersService;


    /**
     * 必须重写此方法，不然Shiro会报错
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }


    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        if(principalCollection == null){
            throw new AuthenticationException("PrincipalCollection参数不能为空。");
        }
        Users user = (Users) getAvailablePrincipal(principalCollection);
        if(ObjectUtils.isEmpty(user)){
            throw new AuthenticationException("用户不存在");
        }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //在token中还没有集成角色权限相关信息所以先暂时注释掉
//        if(ObjectUtils.isEmpty(user.getRole())){
//            info.setRoles(new HashSet<String>(){{add("public");}});
//        }else{
//            info.setRoles(new HashSet<String>(){{add(user.getRole());}});
//        }
        return info;
    }

//获取授权所需要的相关信息
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) authenticationToken;

        if(StringUtils.isEmpty(jwtToken.getToken())){
            throw new AuthenticationException("无效Token");
        }
        String username = JWTUtil.getUsername(jwtToken.getToken());
        if(StringUtils.isEmpty(username)){
            throw new AuthenticationException("无效Token");
        }
        Users user = usersService.fetchByUserName(username);
        if(ObjectUtils.isEmpty(user)){
            throw new AuthenticationException("用户不存在");
        }
        if(!JWTUtil.verify(jwtToken.getToken(),user.getUsername(),user.getPassword())){
            throw new AuthenticationException("无效Token");
        }
//        if(user.getDisabled()){
//            throw new LockedAccountException();
//        }

//        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),ByteSource.Util.bytes(user.getSalt()),getName());
        return new SimpleAuthenticationInfo(jwtToken.getToken(),jwtToken.getToken(),"zbyRealm");
    }

自定义拦截器

public class JwtFilter extends BasicHttpAuthenticationFilter  {


    /**
     * 执行登录认证
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            executeLogin(request, response);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     */
    @Override
    // 实际上可以对请求进行封装以及对授权后的各种错误进行处理
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("api_key");

        JwtToken jwtToken = new JwtToken(token);
        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        getSubject(request, response).login(jwtToken);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;
    }

Shiro 配置

@Configuration
public class ShiroConfig {



    @Bean(value = "securityManager")
     public DefaultWebSecurityManager securityManager(@Qualifier("zbyRealm") Realm realm){

        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);

        /*
         * 关闭shiro自带的session，详情见文档
         * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);

        return securityManager;
    }

    @Bean(value = "zbyRealm")
    public Realm zbyRealm(@Qualifier("credentialsMatcher") SimpleCredentialsMatcher credentialsMatcher){
        ShiroRealm shiroRealm = new ShiroRealm();
        shiroRealm.setCredentialsMatcher(credentialsMatcher);
        return shiroRealm;
    }

    /**
     * 凭证匹配器
     * （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
     * 所以我们需要修改下doGetAuthenticationInfo中的代码;
     * ）
     *
     * @return
     */
    @Bean(name = "credentialsMatcher")
    public CredentialsMatcher credentialsMatcher() {
        return new CredentialsMatcher();
    }


    /**
     * URL 拦截配置
     * @param manager
     * @return
     */
    @Bean(name="shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") DefaultWebSecurityManager manager) {
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        bean.setSecurityManager(manager);
        //配置登录的url和登录成功的url以及验证失败的url
        bean.setLoginUrl("/v1/auth/loginFail");
//        bean.setSuccessUrl("/home");
        bean.setUnauthorizedUrl("/v1/auth/loginFail");

        //设置自定义Filter
        Map<String, Filter> filterLinkedMap = new HashMap<>();
        JwtFilter jwtFilter = new JwtFilter();

        filterLinkedMap.put("jwt", (Filter) jwtFilter);
        bean.setFilters(filterLinkedMap);

        //配置访问权限
        LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        //登录放过拦截
        filterChainDefinitionMap.put("/v1/auth/login", "anon");
        filterChainDefinitionMap.put("/v1/auth/logout", "anon");
        //未授权URL
        filterChainDefinitionMap.put("/v1/test/loginFail", "anon");
        //过滤SwaggerUI相关URL
        filterChainDefinitionMap.put("/swagger-resources/**", "anon");
        filterChainDefinitionMap.put("/v2/api-docs*", "anon");
        filterChainDefinitionMap.put("/swagger-ui.html", "anon");
        filterChainDefinitionMap.put("/favicon.ico", "anon");
        filterChainDefinitionMap.put("/webjars/**", "anon");
//        filterChainDefinitionMap.put("/swagger-resources.**", "anon");

        //拦截所有URL
        filterChainDefinitionMap.put("/**", "jwt");
        bean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return bean;
    }



    }

自定义Token


public class JwtToken implements AuthenticationToken  {

    private String token;

    public JwtToken(String token){
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return null;
    }

    @Override
    public Object getCredentials() {
        return null;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }
}

GKTDSR

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常规操作之安全框架Shiro

简介shiro提供了：认证、授权、加密、会话管理、与web集成、缓存等模块。和spring Securte相比shiro更简单提供的成品逻辑很完善，只需实现和集成相应的接口和类即可实现特有的逻辑，例如AuthorizingRealm(数据源)，Filter(自定义拦截器)等等Shiro结构因为shiro默认进行session认证的，通过SessionManager(会话管理器)来控制请求...
复制链接

扫一扫