【shiro】springboot如何集成shiro中间件（案例）

别倒在黎明之前

已于 2023-08-26 23:24:10 修改

阅读量237

点赞数 1

文章标签： spring boot 中间件后端

于 2023-08-19 19:57:45 首次发布

本文链接：https://blog.csdn.net/c1390527393/article/details/132382967

版权

一、什么是shiro

二、shiro的使用结合项目案例

1、准备所需数据库

2、创建springboot项目并导入相关maven坐标

4、到此基本框架已完成接下来开始集成使用shiro框架

一、什么是shiro

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：

易于理解的 Java Security API；
简单的身份认证（登录），支持多种数据源（LDAP，JDBC 等）；
对角色的简单的签权（访问控制），也支持细粒度的鉴权；
支持一级缓存，以提升应用程序的性能；
内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
异构客户端会话访问； · 非常简单的加密 API；
不跟任何的框架或者容器捆绑，可以独立运行。

Shiro架构图

Subject

Subject主体，外部应用与subject进行交互，subject将用户作为当前操作的主体，这个主体：可以是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

SecurityManager

SecurityManager权限管理器，它是shiro的核心，负责对所有的subject进行安全管理。通过 SecurityManager可以完成subject的认证、授权等，SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口

Authenticator

Authenticator即认证器，对用户登录时进行身份认证

Authorizer

Authorizer授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

Realm（数据库读取+认证功能+授权功能实现）

Realm领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据

比如：

如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。

注意：

不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

SessionManager

SessionManager会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro 可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

SessionDAO

SessionDAO即会话dao，是对session会话操作的一套接口

比如:

可以通过jdbc将会话存储到数据库

也可以把session存储到缓存服务器

CacheManager

CacheManager缓存管理，将用户权限数据存储在缓存，这样可以提高性能

Cryptography

Cryptography密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能

基本流程

流程如下：

Shiro把用户的数据封装成标识token，token一般封装着用户名，密码等信息
使用Subject门面获取到封装着用户的数据的标识token
Subject把标识token交给SecurityManager，在SecurityManager安全中心中，SecurityManager 把标识token委托给认证器Authenticator进行身份验证。认证器的作用一般是用来指定如何验证，它规定本次认证用到哪些Realm
认证器Authenticator将传入的标识token，与数据源Realm对比，验证token是否合法

二、shiro的使用结合项目案例

1、准备所需数据库

数据已上传可直接下载

pe_user

pe_role

pe_user_role

pe_permission

pe_role_permission

数据表之间关系

2、创建springboot项目并导入相关maven坐标

<properties>
    <java.version>1.8</java.version>
    <!--shiro-->
    <shiro.version>1.3.2</shiro.version>
</properties>

<!--        mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

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

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.16</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
</dependency>

<!-- SECURITY begin -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>${shiro.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>${shiro.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-web</artifactId>
    <version>${shiro.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>${shiro.version}</version>
</dependency>
<!-- SECURITY end -->

3、创建基本三层结构完成基本查询功能

dao层

UserDao

/**
  * 用户数据访问接口
  */
@Repository
public interface UserDao {

    //按照姓名查询 基本信息
    @Select("select * from pe_user where username = #{username}")
    User findUserByName(String name);

    //级联查询（按照id查询）查询所有信息
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "username", property = "username"),
            @Result(column = "password", property = "password"),
            @Result(column = "salt", property = "salt"),
            @Result(column = "id", property = "roles",
                    many = @Many(select = "com.cc.shiro.dao.RoleDao.findRoleById"))
    })
    @Select("select * from pe_user where id = #{id}")
    User findUserById(String id);
}

RoleDao

@Repository
public interface RoleDao {

    //级联查询
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "name", property = "name"),
            @Result(column = "code", property = "code"),
            @Result(column = "description", property = "description"),
            @Result(column = "id", property = "permissions",
                    many = @Many(select = "com.cc.shiro.dao.PermissionDao.findPermissionById"))
    })
    @Select("select * from pe_role where id in (select role_id from pe_user_role where user_id = #{id})")
    Set<Role> findRoleById(String id);
}

PermissionDao

@Repository
public interface PermissionDao  {

    //级联查询
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "name", property = "name"),
            @Result(column = "code", property = "code"),
            @Result(column = "description", property = "description")
    })
    @Select("select * from pe_permission where id in (select permission_id from pe_role_permission where role_id = #{id})")
    Set<Permission> findPermissionById(String id);
}

service层

UserService

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    public User findByName(String name) {
        return userDao.findUserByName(name);
    }

    public User findAllById(String id){
        return userDao.findUserById(id);
    }


}

controller层

UserController

@RestController
public class UserController {

    @Autowired
    private UserService userService;


    /**
     * 使用shiro注解鉴权具有某中权限才能访问，实现两种方式:
     * 1.过滤器实现权限：如果权限信息不匹配setUnauthorizedUrl地址
     * 2.注解实现权限：如果权限信息不匹配，抛出异常(则使用异常处理器解决)
     *
     * @RequiresPermissions() -- 访问此方法必须具备的权限
     * @RequiresRoles() -- 访问此方法必须具备的角色
     */

    //个人主页
    @RequiresPermissions("user-home")
    @RequestMapping("/home")
    public String home() {
        return "访问个人主页成功";
    }

    //添加
    @RequiresPermissions("user-add")
    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public String add() {
        return "添加用户成功";
    }


    //查询
    @RequiresPermissions("user-find")
    @GetMapping("/user")
    public User find(String id) {
//        System.out.println(userService.findByName(name));
//        System.out.println(userService.findAllById());
        return userService.findAllById(id);
    }

    //更新
    @RequiresPermissions("user-update")
    @RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)
    public String update(@PathVariable String id) {
        return "更新用户成功";
    }

    //删除
    @RequiresPermissions("user-delete")
    @RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)
    public String delete(@PathVariable String id) {
        return "删除用户成功";
    }


    //用户登录
    @RequestMapping(value = "/login")
    public String login(User user) {
        try {
            //1.构造登录令牌
            UsernamePasswordToken upToken = new UsernamePasswordToken(user.getUsername(), user.getPassword());
            //2.获取subject
            Subject subject = SecurityUtils.getSubject();
            //3.调用subject进行登录
            subject.login(upToken);
            return "登录成功";

        } catch (Exception e) {
            return "用户名或密码错误";
        }
    }

    //未登陆与未授权页面
    @RequestMapping(value = "/autherror")
    public String autherror() {
        return "未登录";
    }

}

实体类

User

/**
 * 用户实体类
 */
@Getter
@Setter
@Data
public class User implements Serializable  {

    private String id;
    private String username;
    private String password;
    private String salt;


    private Set<Role> roles = new HashSet<Role>();//用户与角色   多对多


}

Role

@Getter
@Setter
@Data
public class Role implements Serializable {
    private static final long serialVersionUID = 594829320797158219L;
    private String id;
    private String name;
    private String code;
    private String description;

    //角色与权限  多对多
    private Set<Permission> permissions = new HashSet<Permission>(0);
}

Permission

@Getter
@Setter
@NoArgsConstructor
public class Permission implements Serializable {
    private static final long serialVersionUID = -4990810027542971546L;

    private String id;
    private String name;
    private String code;
    private String description;
}

yml文件

application.yml

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/shiro?serverTimezone=GMT
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  configuration:
    map-underscore-to-camel-case: true
  type-aliases-package: com.cc.domain

4、到此基本框架已完成接下来开始集成使用shiro框架

编码、散列算法工具类

DigestsUtil

public class DigestsUtil {

    public static final String SHA1 = "SHA-1";

    public static final Integer COUNTS =369;

    /**
     * @Description sha1方法
     * @param input 需要散列字符串
     * @param salt 盐字符串
     * @return
     */
    public static String show(String input, String salt) {
       return new SimpleHash(SHA1, input, salt,COUNTS).toString();
    }

    /**
     * @Description 随机获得salt字符串
     * @return
     */
    public static String generateSalt(){
        SecureRandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
        return randomNumberGenerator.nextBytes().toHex();
    }


    /**
     * @Description 生成密码字符密文和salt密文
     * @param
     * @return
     */
    public static Map<String,String> entryptPassword(String passwordPlain) {
       Map<String,String> map = new HashMap<>();
       String salt = generateSalt();
       String password =show(passwordPlain,salt);
       map.put("salt", salt);
       map.put("password", password);
       return map;
    }

    /**
     * 获取密文与盐值 用于存放数据库
     * @param args
     */
    public static void main(String[] args) {
        String name = "aa";
        String pwd = "123";
        Map map = entryptPassword(pwd);
        System.out.println(map.toString());


    }
}

自定义realm

MyRealm

/**
 * 自定义的realm
 */
public class MyRealm extends AuthorizingRealm {


    @Autowired
    private UserService userService;

    /**
     * 授权方法
     *      操作的时候，判断用户是否具有响应的权限
     *          一定先认证再授权
     *          先认证 -- 安全数据
     *          再授权 -- 根据安全数据获取用户具有的所有操作权限
     */
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //1.获取已认证的用户数据
        User user = (User) principalCollection.getPrimaryPrincipal();//得到唯一的安全数据
        User user1 = userService.findAllById(user.getId());
        //2.根据用户数据获取用户的权限信息（所有角色，所有权限）
        Set<String> roles = new HashSet<>();//所有角色
        Set<String> perms = new HashSet<>();//所有权限
        for (Role role : user1.getRoles()) {
            roles.add(role.getName());
            for (Permission perm : role.getPermissions()) {
                perms.add(perm.getCode());
            }
        }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(perms);
        info.setRoles(roles);
        return info;
    }


    /**
     * 认证方法
     *  参数：传递的用户名密码
     */
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取登录的用户名密码（token）
        UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
        String username = upToken.getUsername();//用户录入的账号
        //2.根据用户名查询数据库
        User user = userService.findByName(username);
        //3.判断用户是否存在或者密码是否一致
        if(user != null) {
            //4.如果一致返回安全数据
            //构造方法：安全数据，密码(匿名)，混淆字符串(salt),realm域名
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(), ByteSource.Util.bytes(user.getSalt()),"myRealm");
            return info;
        }
        //5.不一致，返回null（抛出异常）
        return null;
    }


    /**
     * @Description 自定义密码比较器
     * @param
     * @return
     * bean标签 init-method属性
     */
    @PostConstruct
    public void initCredentialsMatcher() {
        //指定密码算法
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher(DigestsUtil.SHA1);
        //指定迭代次数
        hashedCredentialsMatcher.setHashIterations(DigestsUtil.COUNTS);
        //生效密码比较器
        setCredentialsMatcher(hashedCredentialsMatcher);
    }



}

shiro配置类

ShiroConfiguration

@Configuration
public class ShiroConfiguration {

    /**
     * 1.创建shiro自带cookie对象
     */
    @Bean
    public SimpleCookie sessionIdCookie(){
        SimpleCookie simpleCookie = new SimpleCookie();
        simpleCookie.setName("ShiroSession");
        return simpleCookie;
    }

    //2.创建realm
    @Bean
    public MyRealm getRealm() {
        return new MyRealm();
    }

    /**
     * 3.创建会话管理器
     */
    @Bean
    public DefaultWebSessionManager sessionManager(){
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionValidationSchedulerEnabled(false);
        sessionManager.setSessionIdCookieEnabled(true);
        sessionManager.setSessionIdCookie(sessionIdCookie());
        sessionManager.setGlobalSessionTimeout(3600000);
        return sessionManager;
    }

    //4.创建安全管理器
    @Bean
    public SecurityManager defaultWebSecurityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(getRealm());
        securityManager.setSessionManager(sessionManager());
        return securityManager;
    }



    /**
     * 5.保证实现了Shiro内部lifecycle函数的bean执行
     */
    @Bean(name = "lifecycleBeanPostProcessor")
    public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 6.开启对shiro注解的支持
     *   AOP式方法级权限检查
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    /**
     * 7.配合DefaultAdvisorAutoProxyCreator事项注解权限校验
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor() {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(defaultWebSecurityManager());
        return authorizationAttributeSourceAdvisor;
    }




//    8.配置shiro的过滤器工厂再web程序中，shiro进行权限控制全部是通过一组过滤器集合进行控制
    @Bean
    public ShiroFilterFactoryBean shiroFilter() {
        //1.创建过滤器工厂
        ShiroFilterFactoryBean filterFactory = new ShiroFilterFactoryBean();
        //2.设置安全管理器
        filterFactory.setSecurityManager(defaultWebSecurityManager());
        //3.通用配置（跳转登录页面，为授权跳转的页面）
        filterFactory.setLoginUrl("/autherror");//跳转url地址
        //4.设置过滤器集合
        //key = 拦截的url地址
        //value = 过滤器类型
        Map<String,String> filterMap = new LinkedHashMap<>();
        //key：请求规则   value：过滤器名称
        filterMap.put("/login","anon");//当前请求地址可以匿名访问
        filterMap.put("/user/**","authc");//当前请求地址必须认证之后可以访问
        //在过滤器工程内设置系统过滤器
        filterFactory.setFilterChainDefinitionMap(filterMap);

        return filterFactory;
    }



}

自定义的公共异常处理器 handle

BaseExceptionHandle

/**
 * 自定义的公共异常处理器
 *      1.声明异常处理器
 *      2.对异常统一处理
 */
@ControllerAdvice
public class BaseExceptionHandler {

    @ExceptionHandler(value = AuthorizationException.class)
    @ResponseBody
    public String error(HttpServletRequest request, HttpServletResponse response, AuthorizationException e) {
        return "未授权-异常处理器实现";
    }
}

启动类

ShiroAppliction

@MapperScan("com.cc.shiro.dao")
@SpringBootApplication
public class ShiroApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShiroApplication.class, args);
    }

}

5、测试

使用明文密码登录成功数据库中该用户为普通员工只有访问主页权限

访问主业成功

访问添加失败没有权限

别倒在黎明之前

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【shiro】springboot如何集成shiro中间件（案例）

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。易于理解的 Java Security API；简单的身份认证（登录），支持多种数据源（LDAP，JDBC 等）；对角色的简单的签权（访问控制），也支持细粒度的鉴权；支持一级缓存，以提升应用程序的性能；
复制链接

扫一扫