Shiro权限认证(授权)

andrew7676

浏览: 188419 次
性别:
来自: 北京

最近访客更多访客>>

权律二

xingming_03

dongcaoheneric

dongguangming88

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

2019-04 ( 38)
2019-03 ( 20)
2019-02 ( 34)
更多存档...

博客分类：

Shiro

Java Shiro

1. 权限认证核心要素

权限认证，也就是访问控制，即在应用中控制谁能访问哪些资源。
在权限认证中，最核心的三个要素是：权限，角色和用户。
权限：即操作资源的权利，比如访问某个页面，以及对某个模块的数据的添加，修改，删除，查看的权利；
角色：是权限的集合，一中角色可以包含多种权限；
用户：在Shiro中，代表访问系统的用户，即Subject；

2. 授权

2.1 编程式授权

pom.xml

<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>
  <groupId>com.andrew.shiro</groupId>
  <artifactId>Shrio03</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>Shiro03</name>
  <description>Shiro03 Project</description>
  
  <dependencies>
      <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.2.4</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.37</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
  </dependencies>
</project>

src/main/resources/jdbc_realm.ini

[main]
jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm
dataSource=com.mchange.v2.c3p0.ComboPooledDataSource
dataSource.driverClass=com.mysql.jdbc.Driver
dataSource.jdbcUrl=jdbc:mysql://localhost:3306/shiro
dataSource.user=root
dataSource.password=root
jdbcRealm.dataSource=$dataSource
securityManager.realms=$jdbcRealm

src/main/resources/log4j.properties

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
# General Apache libraries
log4j.logger.org.apache=WARN
# Spring
log4j.logger.org.springframework=WARN
# Default Shiro logging
log4j.logger.org.apache.shiro=TRACE\
# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

src/main/java/com/andrew/common/ShiroUtil.java

package com.andrew.common;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
public class ShiroUtil {
    public static Subject login(String configFile, String userName, String password) {
        // 读取配置文件，初始化SecurityManager工厂
        Factory<SecurityManager> factory = new IniSecurityManagerFactory(configFile);
        // 获取securityManager实例
        SecurityManager securityManager = factory.getInstance();
        // 把securityManager实例绑定到SecurityUtils
        SecurityUtils.setSecurityManager(securityManager);
        // 得到当前执行的用户
        Subject currentUser = SecurityUtils.getSubject();
        // 创建token令牌，用户名/密码
        UsernamePasswordToken token = new UsernamePasswordToken(userName, password);
        try {
            // 身份认证
            currentUser.login(token);
            System.out.println("身份认证成功！");
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("身份认证失败！");
        }
        return currentUser;
    }
}

2.1.1 基于角色的访问控制

src/main/resources/shiro_role.ini

[users]
andrew=123456,role1,role2
jack=123,role1

src/main/java/com/andrew/shiro/RoleTest.java

package com.andrew.shiro;
import java.util.Arrays;
import org.apache.shiro.subject.Subject;
import org.junit.Test;
import com.andrew.common.ShiroUtil;
public class RoleTest {
    @Test
    public void testHasRole() {
        Subject andrewUser = ShiroUtil.login("classpath:shiro_role.ini", "andrew", "123456");
        System.out.println(andrewUser.hasRole("role1") ? "andrew有role1这个角色" : "andrew没有role1这个角色");
        boolean[] results = andrewUser.hasRoles(Arrays.asList("role1", "role2", "role3"));
        System.out.println(results[0] ? "andrew有role1这个角色" : "andrew没有role1这个角色");
        System.out.println(results[1] ? "andrew有role2这个角色" : "andrew没有role2这个角色");
        System.out.println(results[2] ? "andrew有role3这个角色" : "andrew没有role3这个角色");
        System.out.println(andrewUser.hasAllRoles(Arrays.asList("role1", "role2")) ? "andrew role1,role2这两个角色都有" : "andrew role1,role2这个两个角色不全有");
        andrewUser.logout();
        Subject jackUser = ShiroUtil.login("classpath:shiro_role.ini", "jack", "123");
        System.out.println(jackUser.hasRole("role1") ? "jack有role1这个角色" : "jack没有role1这个角色");
        boolean[] results2 = jackUser.hasRoles(Arrays.asList("role1", "role2", "role3"));
        System.out.println(results2[0] ? "jack有role1这个角色" : "jack没有role1这个角色");
        System.out.println(results2[1] ? "jack有role2这个角色" : "jack没有role2这个角色");
        System.out.println(results2[2] ? "jack有role3这个角色" : "jack没有role3这个角色");
        System.out.println(jackUser.hasAllRoles(Arrays.asList("role1", "role2")) ? "jack role1,role2这两个角色都有" : "jack role1,role2这个两个角色不全有");
        jackUser.logout();
    }
    @Test
    public void testCheckRole() {
        Subject andrewUser = ShiroUtil.login("classpath:shiro_role.ini", "andrew", "123456");
        andrewUser.checkRole("role1");
        andrewUser.checkRoles(Arrays.asList("role1","role2"));
        andrewUser.checkRoles("role1","role2","role3");
        andrewUser.logout();
        Subject jackUser = ShiroUtil.login("classpath:shiro_role.ini", "jack", "123");
        jackUser.checkRole("role1");
        jackUser.checkRoles(Arrays.asList("role1","role2"));
        jackUser.checkRoles("role1","role2","role3");
        jackUser.logout();
    }
}

运行结果：
身份认证成功！
andrew有role1这个角色
andrew有role1这个角色
andrew有role2这个角色
andrew没有role3这个角色
andrew role1,role2这两个角色都有
身份认证成功！
jack有role1这个角色
jack有role1这个角色
jack没有role2这个角色
jack没有role3这个角色
jack role1,role2这个两个角色不全有

2.1.2 基于权限的访问控制

src/main/resources/shiro_permission.ini

[users]
andrew=123456,role1,role2
jack=123,role1
[roles]
role1=user:select
role2=user:add,user:update,user:delete

src/main/java/com/andrew/shiro/PermissionTest.java

package com.andrew.shiro;
import org.apache.shiro.subject.Subject;
import org.junit.Test;
import com.andrew.common.ShiroUtil;
public class PermissionTest {
    @Test
    public void testIsPermitted() {
        Subject andrewUser = ShiroUtil.login("classpath:shiro_permission.ini", "andrew", "123456");
        System.out.println(andrewUser.isPermitted("user:select") ? "andrew有user:select这个权限" : "andrew没有user:select这个权限");
        System.out.println(andrewUser.isPermitted("user:update") ? "andrew有user:update这个权限" : "andrew没有user:update这个权限");
        boolean results[] = andrewUser.isPermitted("user:select", "user:update", "user:delete");
        System.out.println(results[0] ? "andrew有user:select这个权限" : "andrew没有user:select这个权限");
        System.out.println(results[1] ? "andrew有user:update这个权限" : "andrew没有user:update这个权限");
        System.out.println(results[2] ? "andrew有user:delete这个权限" : "andrew没有user:delete这个权限");
        System.out.println(andrewUser.isPermittedAll("user:select", "user:update") ? "andrew有user:select,update这两个权限" : "andrew user:select,update这两个权限不全有");
        andrewUser.logout();
        Subject jackUser = ShiroUtil.login("classpath:shiro_permission.ini", "jack", "123");
        System.out.println(jackUser.isPermitted("user:select") ? "jack有user:select这个权限" : "jack没有user:select这个权限");
        System.out.println(jackUser.isPermitted("user:update") ? "jack有user:update这个权限" : "jack没有user:update这个权限");
        boolean results2[] = jackUser.isPermitted("user:select", "user:update", "user:delete");
        System.out.println(results2[0] ? "jack有user:select这个权限" : "jack没有user:select这个权限");
        System.out.println(results2[1] ? "jack有user:update这个权限" : "jack没有user:update这个权限");
        System.out.println(results2[2] ? "jack有user:delete这个权限" : "jack没有user:delete这个权限");
        System.out.println(jackUser.isPermittedAll("user:select", "user:update") ? "jack有user:select,update这两个权限" : "jack user:select,update这两个权限不全有");
        jackUser.logout();
    }
    @Test
    public void testCheckPermitted() {
        Subject andrewUser = ShiroUtil.login("classpath:shiro_permission.ini", "andrew", "123456");
        andrewUser.checkPermission("user:select");
        andrewUser.checkPermissions("user:select", "user:update", "user:delete");
        andrewUser.logout();
        Subject jackUser = ShiroUtil.login("classpath:shiro_permission.ini", "jack", "123");
        jackUser.checkPermission("user:select");
        jackUser.checkPermissions("user:select", "user:update", "user:delete");
        jackUser.logout();
    }
}

运行结果：
身份认证成功！
andrew有user:select这个权限
andrew有user:update这个权限
andrew有user:select这个权限
andrew有user:update这个权限
andrew有user:delete这个权限
andrew有user:select,update这两个权限
身份认证成功！
jack有user:select这个权限
jack没有user:update这个权限
jack有user:select这个权限
jack没有user:update这个权限
jack没有user:delete这个权限
jack user:select,update这两个权限不全有

2.2 注解式授权

@RequiresAuthentication要求当前Subject已经在当前的session中被验证通过才能被访问或调用。
@RequiresGuest要求当前的Subject是一个"guest"，也就是说，他们必须是在之前的session中没有被验证或被记住才能被访问或调用。
@RequiresPermissions("account:create")要求当前的Subject被允许一个或多个权限，以便执行注解的方法。
@RequiresRoles("administrator")要求当前的Subject拥有所有指定的角色。如果他们没有，则该方法将不会被执行，而且AuthorizationException异常将会被抛出。
@RequiresUserRequiresUser注解需要当前的Subject是一个应用程序用户才能被注解的类/实例/方法访问或调用。一个"应用程序用户"被定义为一个拥有已知身份，或在当前session中由于通过验证被确认，或者在之前session中的'RememberMe'服务被记住。

2.3 Jsp标签授权

<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags"%>
Guest标签：用户没有身份验证时显示相应信息，即游客访问信息；
User标签：用户已经身份验证/记住我登录后显示相应的信息；
Authenticated标签：用户已经身份验证通过，即Subject.login登录成功，不是记住我登录的。
notAuthenticated标签：用户没有身份验证通过，即没有调用Subject.login进行登录，包括记住我自动登录的也属于未进行身份验证。
principal标签显示用户身份信息，默认调用Subject.getPrincipal()获取，即Primary Principal。
hasRole标签如果当前Subject有角色将显示body体内容。
lacksRole标签如果当前Subject没有角色将显示body体内容。
hasAnyRoles标签如果当前Subject有任意一个角色（或的关系）将显示body体内容。
hasPermission标签如果当前Subject有权限将显示body体内容。
lacksPermission标签如果当前Subject没有权限将显示body体内容。

3. 权限分类

单个权限 query
单个资源多个权限 user:query user:add 多值 user:query,add
单个资源所有权限 user:query,add,update,delete user:*
所有资源某个权限 *:view
实例级别的权限控制
单个实例的单个权限 printer:query:lp7200 printer:print:epsoncolor
所有实例的单个权限 printer:print:*
所有实例的所有权限 printer:*:*
单个实例的所有权限 printer:*:lp7200
单个实例的多个权限 printer:query,print:lp7200

4. 授权流程