Apache shiro例子

最新推荐文章于 2022-03-07 23:39:10 发布
最新推荐文章于 2022-03-07 23:39:10 发布
阅读量204 收藏
点赞数
分类专栏： java 文章标签： shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/plazyj/article/details/101799095
版权
apache shiro例子
闲来无事看到之前写的shiro例子，传上来，

之前在一家公司接触过一个项目用到了shiro，不过那个项目是公司买来的，前后端封装的比较厉害，用着不是并那么方便，简单学习shiro后，写了个小demo。
shiro相比spring的安全框架上手要友好的多。

这是基本结构。
在这里插入图片描述
我使用的是spring boot ，这样方便配置，简单的写了个登陆过程。采用spring的thymeleaf。spring data jpa读取数据库中用户信息作权限判断
启动类就不贴了，会spring boot的都没问题

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.1.4.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>org.zhengyj</groupId>
   <artifactId>springboot-shiro</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>springboot-shiro</name>
   <description>Demo project for Spring Boot</description>

   <properties>
       <java.version>1.8</java.version>
   </properties>

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

       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.47</version>
       </dependency>
       <dependency>
           <groupId>org.apache.shiro</groupId>
           <artifactId>shiro-spring</artifactId>
           <version>1.3.2</version>
       </dependency>
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid</artifactId>
           <version>1.1.6</version>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

</project>
application.yml
server:
  port: 8081
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_shiro?useUnicode=true&amp;characterEncoding=UTF-8&useSSL=true
    username: root
    password: root123
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
  http:
    encoding:
      charset: utf-8
      enabled: true
  thymeleaf:
    prefix: classpath:/templates/
login.html
<!DOCTYPE html>
<html xmlns:th="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
<form action="/loginsave">
    用户名：<input name="name" type="text"/><br>
    密码：<input name="password" type="text"/><br>
    <input type="submit" value="登录系统"/>
</form>
<p th:text="${hello}"></p>
</body>
</html>
controller
package org.zhengyj.springbootshiro.controller;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.zhengyj.springbootshiro.entity.User;
import org.zhengyj.springbootshiro.service.LoginService;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;

/**
 *
 * @Author zhengyj
 * @Description ：登录控制层
 * @Date 2019/4/17
 **/

@Controller
public class LoginController {


    /**
     * 首页
     * @return
     */
    @RequestMapping(value = "/index")
    public String index(){
        return "index";
    }
    /**
     * 登录
     * @return
     */
    @RequestMapping(value = "/login")
    public String login(){
        return "login";
    }
	/**
	* 此处做权限跳转处理，返回不同页面
	*/
    @RequestMapping(value = "/loginsave")
    public String loginSave(User user){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(user.getName(),user.getPassword());
        try{
            subject.login(token);
            //这个index页面就是随便写点什么标注下就行
            return "index";
        }catch(UnknownAccountException e){
            return "login";
        }catch(IncorrectCredentialsException i){
            return "login";
        }
    }

}
User类(这个可以用lombok，有点懒了)
package org.zhengyj.springbootshiro.entity;
import javax.persistence.*;
import java.util.List;

/**
     *
     * @Author zhengyingjun
     * @Description ：shiro 用户类
     * @Date 2019/4/17
     **/
    @Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Long id;

        @Column(unique = true)
        private String name;

        private String password;
        @OneToMany(cascade = CascadeType.ALL,mappedBy = "user")
        private List<Role> roles;

        public List<Role> getRoles() {
            return roles;
        }

        public void setRoles(List<Role> roles) {
            this.roles = roles;
        }

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
}
Role
package org.zhengyj.springbootshiro.entity;

import javax.persistence.*;
import java.util.List;

/**
 *
 * @Author zhengyingjun
 * @Description ：shiro 角色类
 * @Date 2019/4/17
 **/

@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String roleName;
    @ManyToOne(fetch = FetchType.EAGER)
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public List<Permission> getPermissions() {
        return permissions;
    }

    public void setPermissions(List<Permission> permissions) {
        this.permissions = permissions;
    }

    @OneToMany(cascade = CascadeType.ALL,mappedBy = "role")
    private List<Permission> permissions;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}
Permission
package org.zhengyj.springbootshiro.entity;

import javax.persistence.*;

/**
 *
 * @Author zhengyingjun
 * @Description ： shiro 权限类
 * @Date 2019/4/17
 **/
@Entity
public class Permission {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String permission;

    @ManyToOne(fetch = FetchType.EAGER)
    private Role role;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getPermission() {
        return permission;
    }

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

    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }
}
RoleRepository(使用的Spring Data JPA)
package org.zhengyj.springbootshiro.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.zhengyj.springbootshiro.entity.Role;
/**
 *
 * @Author zhengyingjun
 * @Description ：角色
 * @Date 2019/4/17
 **/

public interface RoleRepository extends JpaRepository<Role,Long> {
}
UserRepository
package org.zhengyj.springbootshiro.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.zhengyj.springbootshiro.entity.User;
/**
 *
 * @Author zhengyingjun
 * @Description ：用户
 * @Date 2019/4/17
 **/
public interface UserRepository extends JpaRepository<User,Long> {
    /**
     *自定义查询
     * @param name
     * @return
     */
    User findByName(String name);
}
service接口（有些好像是没用上）
package org.zhengyj.springbootshiro.service;
import org.zhengyj.springbootshiro.entity.Role;
import org.zhengyj.springbootshiro.entity.User;
/**
 *
 * @Author zhengyingjun
 * @Description ：业务
 * @Date 2019/4/17
 **/

public interface LoginService {

    User addUser(User user);

    Role addRole(User user,String rolename);

    User findByName(String name);
}
service实现类
package org.zhengyj.springbootshiro.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.zhengyj.springbootshiro.entity.Permission;
import org.zhengyj.springbootshiro.entity.Role;
import org.zhengyj.springbootshiro.entity.User;
import org.zhengyj.springbootshiro.repository.RoleRepository;
import org.zhengyj.springbootshiro.repository.UserRepository;
import org.zhengyj.springbootshiro.service.LoginService;
import java.util.ArrayList;
import java.util.List;
/**
 *
 * @Author zhengyingjun
 * @Description ：具体实现
 * @Date 2019/4/17
 **/

@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RoleRepository roleRepository;

    @Override
    public User addUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public Role addRole(User user,String rolename) {
        Role role = new Role();
        role.setRoleName(rolename);
        role.setUser(user);
        Permission permission1 = new Permission();
        permission1.setPermission("create");
        permission1.setRole(role);
        Permission permission2 = new Permission();
        permission2.setPermission("update");
        permission2.setRole(role);
        List<Permission> list = new ArrayList<>();
        list.add(permission1);
        list.add(permission2);
        //放入role统一保存
        role.setPermissions(list);
        roleRepository.save(role);
        return role;
    }
    @Override
    public User findByName(String name) {
        return userRepository.findByName(name);
    }
}

接下来就是最重要的配置了
这个简要说明下，用到哪个页面就配置哪个

package org.zhengyj.springbootshiro.config;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

/**
 *
 * @Author zhengyingjun
 * @Description ：shiro 过滤配置
 * @Date 2019/4/17
 **/
@Configuration
public class ShiroConfiguration {
    /**
     * 加入注解
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    @Bean(name = "myShiroRealm")
    public MyShiroRealm myShiroRealm(){
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        return myShiroRealm;
    }

    /**
     * 权限管理
     * @return
     */
    @Bean(name = "defaultWebSecurityManager")
    public DefaultWebSecurityManager defaultWebSecurityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String,String> map = new HashMap<>();
        //登录
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首页
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //报错页
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");
        //退出
        map.put("/logout","logout");
        map.put("/login","anon");
        map.put("/loginsave","anon");
        //对所有用户认证
        map.put("/**","authc");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }
}

认证与校验

package org.zhengyj.springbootshiro.config;
import lombok.extern.slf4j.Slf4j;
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.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 org.zhengyj.springbootshiro.entity.Permission;
import org.zhengyj.springbootshiro.entity.Role;
import org.zhengyj.springbootshiro.entity.User;
import org.zhengyj.springbootshiro.service.LoginService;

@Slf4j
public class MyShiroRealm extends AuthorizingRealm {

    @Autowired
    private LoginService service;
    /**
     * 添加权限
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        log.info("授权");
        User user = (User) principalCollection.getPrimaryPrincipal();
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (Role role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //添加权限
            for (Permission permission : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permission.getPermission());
            }
        }
        return simpleAuthorizationInfo;
    }

    /**
     * 认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        log.info("认证");
        //??先进行认证？
        if (authenticationToken.getPrincipal() == null) {
            return null;
        }
       String name = (String)authenticationToken.getPrincipal();
        User user = service.findByName(name);
        //空值校验
        if (user == null) {
            return null;
        } else {
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(user.getName(), user.getPassword(), getName());
            return simpleAuthenticationInfo;
        }
    }
}
navyzhengyj
关注
专栏目录
Java Apache Shiro 入门指南
java专栏
08-20 372
我们将在上面的基础上添加权限控制的功能。以下是修改后的shiro.ini[main]# 指定 Realm# 设置默认的登录 URL# 设置未授权的 URL[users]# 用户名: 密码: 角色[roles]# 角色: 权限[urls]通过以上的步骤，我们已经了解了如何使用 Apache Shiro 来实现用户登录和权限控制。Shiro 是一个非常强大的工具，支持多种复杂的安全功能。你可以根据需要添加更多的安全机制，以满足各种安全需求。
Apache_Shiro_使用手册（一）Shiro架构介绍
03-06
### Apache Shiro 使用手册（一）Shiro架构介绍 #### 一、Shiro简介 Apache Shiro 是一款功能强大且易于使用的 Java 安全框架，它提供了多种安全相关的功能和服务，包括但不限于认证、授权、加密和会话管理。相较...
apache shiro 实例
03-15
apache shiro 实例 apache shiro 实例
Apache Shiro 授权例子
热门推荐
王浩的技术博客
01-22 1万+
概述 在本例中使用Apache Shiro进行授权控制，基于事先定义好的角色控制用户的操作权限。 基于Apache Shiro 提供的标签库，在JSP页面上根据用户的授权状态来控制不同的操作行为。 业务逻辑 定义两种角色：administrator，common。administrator代表管理员，可查看，修改，删除用户； common代表普通用户，可查看用户，只能修改自己，不能删除用
Apache Shiro 示例
iteye_9972的博客
04-14 108
第一个Apache Shiro程序 如果你是初次接触Apache Shiro，该文章将指导你创建一个初级的非常简单的使用Apache Shiro进行安全认证的程序，同时我们将讨论Shiro的核心理念以帮助你熟悉Shiro的设计方式和API。 如果你确实不想按照该示例一步一步地编写代码，你可以从下面地址下载一个基本上完全相同的程序作为参考，选择下载位置： 在Apache Shiro的...
Apache shiro示例
sjhuangx的专栏
03-09 367
参考教程: https://shiro.apache.org/tutorial.htmlApache Shiro是一个权限管理框架，本文是一个简单的示例新建一个maven功能，加入shiro依赖 &lt;dependency&gt; &lt;groupId&gt;org.apache.shiro&lt;/groupId&gt; &lt;...
Apache Shiro简单示例
weixin_34009794的博客
07-12 122
2019独角兽企业重金招聘Python工程师标准>>> ...
一个简单的shiro例子
10-29
标题"一个简单的shiro例子"表明这是一个关于Apache Shiro的实践案例，Shiro是一个强大且易用的Java安全框架，用于处理认证、授权、加密和会话管理。 描述中的"一个简单的SSM框架"指的是Spring、Spring MVC和MyBatis...
apache-shiro教程完整版.7z
06-04
Apache Shiro 是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可以非常轻松地开发出足够安全的应用。张开涛的《跟我学Shiro》是一本深入浅出的教程，旨在帮助读者快速掌握Shiro的核心概念...
Apache Shiro 身份认证例子-源码
01-17
本资源包含了一个 Apache Shiro 的身份认证例子的源码，这对于理解和实践 Shiro 的核心功能非常有帮助。 身份认证是安全领域中的基础概念，它涉及到验证用户的身份是否合法。在 Shiro 中，这个过程通常分为几个步骤...
Apache Shiro 身份认证例子- Web应用
01-17
可直接拷贝到Tomcat下运行，默认用户名/口令：admin/admin
java shiro实例_Apache Shiro入门实例
weixin_42519985的博客
02-13 172
Shiro是一个强大灵活的开源安全框架，提供身份验证、授权、会话管理、密码体系。1.先创建一个Maven项目2.配置pomhttp://maven.apache.org/xsd/maven-4.0.0.xsd">4.0.0cn.edu.stushiro-test0.0.1-SNAPSHOTorg.apache.shiroshiro-core1.3.0org.slf4jslf4j-log4j1...
Shiro —— 从一个简单的例子开始
weixin_30908649的博客
09-19 119
一、Shiro是用来做权限的。 二、权限 1.基本概念： （1）安全实体：要保护的数据。 （2）权限：是否有能力去操作（查看、修改、删除 ）保护的数据。 2、权限的两个特性 （1）权限的继承性：A 包含 B，B无权限，但A有权限，此时B 的权限即为 A 的权限。如大厦里有公共厕所，进出大厦需要门禁，所以公共厕所的权限就是大厦的门禁权限。 （2）最近路劲匹配：如大厦某层有卫生间，要想到...
apache shiro简单经典例子
weixin_34248023的博客
05-03 102
注：大部分内容摘录Apache shiro使用手册 importorg.apache.shiro.SecurityUtils; importorg.apache.shiro.authc.*; importorg.apache.shiro.config.IniSecurityManagerFactory; importorg.apache.shiro...
shiro实战案例
ITzhongzi的博客
03-07 1136
结构 概念介绍 Subject 我们把用户或者程序称为主体（如用户，第三方服务，cron作业），主体去访问系统或者资源 SecurityManager 安全管理器，Subject的认证和授权都要在安全管理器下进行 Authenticator 认证器，主要负责Subject的认证 Realm 数据域，Shiro和安全数据的连接器，好比jdbc连接数据库； 通过realm获取认证授权相关信息 Authorizer 授权器，主要负责Subject的授权, 控制subject拥有的角色或者权限
[shiro学习笔记]第三节 使用myeclipse导入apache shiro中的QuikStart example例子
weixin_30633949的博客
10-16 179
本文地址：http://blog.csdn.net/sushengmiyan/article/details/40149131shiro官网:http://shiro.apache.org/shiro中文手册：http://wenku.baidu.com/link?url=ZnnwOHFP20LTyX5ILKpd_P94hICe9Ga154KLj_3cCDXpJWhw5Evxt7sfr0B5...
Apache Shiro安全框架单独实例
qq_35557801的博客
02-25 304
一、什么是Shiro安全框架 shrio是一个强大而灵活的开源安全框架，它主要处理身份验证，授权，会话管理和加密。 身份验证：有时称为“登录”，即验证用户的身份。 授权：访问控制的过程，即确定“谁”有权访问“什么”。 会话管理：即使在非Web或EJB应用程序中，也可以管理用户特定的会话。 加密：使用加密算法保持数据安全，同时仍然易于使用。 ...
Apache Shiro 身份认证例子
Flyer的后花园
06-23 877
在本例子中使用Apache Shiro在Web应用中实现身份认证，将Shiro与spring进行集成，使用内嵌的derby数据库存储用户信息。 持久层为hibernate，数据库连接池为alibaba druid。 2. 准备 创建一个内嵌的derby数据库，本例使用的是db-derby-10.10.1.1。 2.1 建表 Create table users(
Apache Shiro入门与自定义Realm详解
"这篇文档介绍了Apache Shiro框架的使用规范，特别是如何进行简单扩展，以及Shiro的主要功能和组件。" 在Apache Shiro框架中，`三简单扩展-shiro使用规范`这部分内容主要讲述了如何自定义 Realm。Realm 是Shiro中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值