Shiro实现权限认证

发表于 | 更新于: | 分类于 | | 阅读次数:

♥♥哈哈哈我来了

今天我们来讲讲使用Shiro来实现用户登陆权限

简介：Shiro

介绍：
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

主要功能
三个核心组件：Subject, SecurityManager 和 Realms.
Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。
Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。
　SecurityManager：它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。
　Realm： Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
　从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
　Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

直接走上正题：

第一步：依旧是引入我们的Pom文件

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>3.2.2</version>
            <exclusions>
                <exclusion>
                    <groupId>com.puppycrawl.tools</groupId>
                    <artifactId>checkstyle</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

是不是感觉很熟悉啊，这些都是我们常用的Pom文件哦。。

第二步：application.yml文件就不用多少来吧。。还是上代码吧：

​ 启动端口

server:
    port: 8888
spring:
  application:
    name: demo-shiro

这也太简单了吧，使用SpringBoot开发就是这么好哦。。

第四步：注意了，开胃菜来了。。。。

创建User对象：（User）

package com.demo.shiro.entity;

import lombok.Data;

import java.util.Set;

@Data
public class User {

    /**
     * 用户Id
     */
    private Long userId;

    /**
     * 用户名称
     */
    private String userName;
    
    /**
     * 用户密码
     */
    private String userPassword;

    /**
     * 用户角色
     */
    private Set<String> role;

    /**
     * 用户权限
     */
    private Set<String> permission;

    /**
     * 构造器
     * @param userId
     * @param userName
     * @param userPassword
     * @param role
     * @param permission
     */
    public User(Long userId, String userName, String userPassword, Set<String> role, Set<String> permission) {
        this.userId = userId;
        this.userName = userName;
        this.userPassword = userPassword;
        this.role = role;
        this.permission = permission;
    }
}

创建数据响应：（Response）

package com.demo.shiro.entity;

import java.util.HashMap;
import java.util.Map;

/**
 * 响应数据
 */
public class Response extends HashMap<String, Object> {
/**
     * 信息
     * @param message
     * @return
     */
    public Response message(String message){

        this.put("message", message);

        return this;
    }

    /**
     * 数据
     * @param data
     * @return
     */
    public Response data(Object data){

        this.put("data", data);

        return this;
    }

    /**
     * 重新方法
     * @param key
     * @param value
     * @return
     */
    @Override
    public Object put(String key, Object value) {

        super.put(key, value);

        return this;
    }
}

创建我们自定义的异常（SystemException）

package com.demo.shiro.exception;

/**
 * 异常抛出
 */
public class SystemException extends Exception{

    public SystemException(String messgae){

        super(messgae);
    }
}

创建一个系统工具类类模拟数据信息：（SystemUtil）：

package com.demo.shiro;

import com.demo.shiro.entity.User;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import javax.lang.model.type.ArrayType;
import java.util.*;

/**
 * 模拟数据库数据
 */
public class SystemUtils {
 /**
     * 模拟数据库中两条数据
     *
     * @return
     */
    public static List<User> users() {
    
    List<User> users = new ArrayList<>();

        // 添加数据
        users.add(new User(
                1L,
                "admin",
                "123456",
                new HashSet<>(Collections.singleton("admin")),
                new HashSet<>(Arrays.asList("user:add", "user:delete"))));

        users.add(new User(
                2L,
                "register",
                "123456",
                new HashSet<>(Collections.singleton("register")),
                new HashSet<>(Arrays.asList("user:view"))));

        return users;
    }

    /**
     * 获取用户
     * @param username
     * @return
     */
    public static User getUser(String username){

        List<User> users = SystemUtils.users();

        return users.stream().filter(user ->

            StringUtils.equalsAnyIgnoreCase(username,user.getUserName())).findFirst().orElse(null);
    }
}

OK，到这里我们基本类就全部创建完成了，下面开始主角来了。。。

第五步：创建我们的Shiro相关配置信息

Shiro配置类：（ShiroConfig）

package com.demo.shiro.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.SessionListener;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.*;

@Configuration
public class ShiroConfig {

 @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        // 设置 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        return shiroFilterFactoryBean;
    }

    @Bean
    public SecurityManager securityManager(ShiroRealm shiroRealm) {

        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 配置 SecurityManager，并注入 shiroRealm
        securityManager.setRealm(shiroRealm);

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

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

    /**
     *  解决注解不生效的问题
     * @return
     */
    @Bean
    public static DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator(){
        return new DefaultAdvisorAutoProxyCreator();
    }
}

Shiro认证和授权类（ShiroRelam）：

package com.demo.shiro.config;

import com.demo.shiro.SystemUtils;
import com.demo.shiro.entity.User;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
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.stereotype.Component;

@Component
public class ShiroRealm extends AuthorizingRealm {

 /**
     * 登陆模块
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {

        // 获取用户名
        String username = (String) authenticationToken.getPrincipal();

        // 获取密码
        String password = new String((char[]) authenticationToken.getCredentials());

        // 根据用户名获取用户
        User user = SystemUtils.getUser(username);

        if (user == null || !StringUtils.equals(password, user.getUserPassword())){

            throw new IncorrectCredentialsException("用户名或密码错误");
        }

        // 登陆成功
        return new SimpleAuthenticationInfo(user, user.getUserPassword(), getName());
    }

    /**
     * 授权模块
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        User user = (User) SecurityUtils.getSubject().getPrincipal();

        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

        // 设置角色，模拟数据库
        simpleAuthorizationInfo.setRoles(user.getRole());

        // 设置权限
        simpleAuthorizationInfo.setStringPermissions(user.getPermission());

        return simpleAuthorizationInfo;
    }
}

是不是感觉很简单呢，是的，只需要配置这两个类就可以完Shiro了。。。。

####第六步：现在可以开始我们的测试了。。。你准备好了吗？

创建一个登陆页面：（login.html）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登陆测试</title>
</head>
<body>

<form action="/login" method="post">

    <input type="text" name="username">
    <br>

    <input type="password" name="password">

    <br>

    <input type="submit" value="登陆">

</form>
</body>
</html>

创建ViewController来访问我们的页面：

package com.demo.shiro.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 页面控制
 **/

@Controller
public class ViewController {

@RequestMapping("login.html")
    public String showLogin(){

        return "login";
    }
}

这里页面不用展示了，这也太简单了吧。。。。

创建我们的登陆Controller（LoginController）

package com.demo.shiro.controller;

import com.demo.shiro.entity.Response;
import com.demo.shiro.exception.SystemException;
import com.demo.shiro.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * 登陆Controller
 */
@Controller
public class LoginController {

    @Autowired(required = false)
    private LoginService loginService;

    /**
     * 登陆
     * @param username
     * @param password
     * @return
     */
    @PostMapping("login")
    public ResponseEntity<Response> login(@RequestParam("username") String username,
                                          @RequestParam("password") String password) throws SystemException {

        Response response = this.loginService.login(username, password);

        return ResponseEntity.ok(response);
    }
}

可能会有报错，不用慌张，是因为我们的LoginService没有创建。。。

创建我们的LoginService（LoginService）：

package com.demo.shiro.service;

import com.demo.shiro.entity.Response;
import com.demo.shiro.exception.SystemException;

public interface LoginService {

    // 登陆
    Response login(String username, String password) throws SystemException;
}

创建它的实现类（LoginServiceImpl）

package com.demo.shiro.service.impl;

import com.demo.shiro.SystemUtils;
import com.demo.shiro.entity.Response;
import com.demo.shiro.entity.User;
import com.demo.shiro.exception.SystemException;
import com.demo.shiro.service.LoginService;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Service;

/**
 * 登陆Service
 */
@Service
public class LoginServiceImpl implements LoginService {

 /**
     * 登陆操作
     * @param username
     * @param password
     * @return
     */
    @Override
    public Response login(String username, String password) throws SystemException {

        Subject subject = SecurityUtils.getSubject();
        
        // 判断是否存在
        if (StringUtils.isBlank(username) || StringUtils.isBlank(password)){

            throw new SystemException("请输入信息");
        }

        try {
            // 执行登陆
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);

            subject.login(usernamePasswordToken);

            User user = (User) subject.getPrincipal();

            return new Response().message("认证成功").data(user);

        } catch (AuthenticationException e) {

            e.printStackTrace();

            throw new SystemException("认证失败");
        }

    }
}

这里面的代码也很容易看懂吧，这代码质量太差了吧。。。。
哈哈哈，需要自己优化哦。。。

到这里，我们的登陆逻辑就完了。。。是不是感觉很容易呢。。。

接下来是我们的测试时间了，，Are you ready？

第七步：测试环境：

创建测试Controller（TestController）

package com.demo.shiro.controller;

import com.demo.shiro.entity.Response;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.security.RolesAllowed;

/**
 * 测试Controller
 */
@Controller
@RequestMapping("test")
public class TestController {

/**
     * 需要admin角色才能访问
     * @return
     */
    @GetMapping("admin")
    @RequiresRoles("admin")
    public ResponseEntity<Response> test1(){

        return ResponseEntity.ok(new Response().message("你是admin"));
    }
    
    /**
     * 拥有查看权限
     * @return
     */
    @GetMapping("view")
    @RequiresPermissions("admin:view")
    public ResponseEntity<Response> test2(){

        return ResponseEntity.ok(new Response().message("你有查看权限"));
    }
}

这里面有两个没有遇见过的注解吧，那么学习了这篇文章你就会了哦。。。。

这里只是实现了登陆，没有设置过滤器、拦截器这些。。。
我们需要登陆过后才能访问页面。。。有没有想过呢。。。
哈哈哈

目录截图：

测试截图：

登陆界面：

使用admin做测试登陆：
登陆成功后我们会看到以下信息

我相信看得懂吧，没错就是我们自己设置的模拟数据哦。。
接下来我们访问其他功能。。。
访问test/admin这个接口：

我们再访问test/view这个接口：

你是否看到这个页面很慌呢，不要慌，我们要稳住，仔细一看，原来我们没有这个权限，所以。。。。懂吧

OK，这里我们演示完了，还有个注册用户，我们可以自己测试。。。
GitHub地址：Shiro-demo
好啦，写了这么久终于写完了，，，，好累哦。。。
有问题欢迎在评论去评论，，，，感谢你的浏览。。。。么么哒