Shiro學習筆記（3）——授權（Authorization）

阿新 • • 發佈：2019-01-04

1.什麼是授權

授權，就是訪問控制，控制某個使用者在應用程式中是否有許可權做某件事

2.授權三要素

角色

通常代表一組行為或職責.這些行為演化為你在一個軟體應用中能或者不能做的事情。角色通常是分配給使用者帳戶的，因此，通過分配，使用者能夠“做”的事情可以歸屬於各種角色
- 隱式角色：一個角色代表著一系列的操作，當需要對某一操作進行授權驗證時，只需判斷是否是該角色即可。這種角色許可權相對簡單、模糊，不利於擴充套件
- 顯式角色：一個角色擁有一個許可權的集合。授權驗證時，需要判斷當前角色是否擁有該許可權。這種角色許可權可以對該角色進行詳細的許可權描述，適合更復雜的許可權設計。 Shiro官方推薦使用這種方式。
使用者

通常我們將一系列的許可權分配給角色，一個使用者可以擁有多個角色。這樣我們就能控制使用者擁有哪些許可權

3.Shiro的三種授權方式

3.1 編碼方式授權

現在再寫一次

建立java工程，新增需要的jar包
自定義Realm，給使用者分配一個許可權和角色

package com.shiro.realm;


import java.util.HashSet;
import java.util.Set;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import 
 org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import 
 org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyRealm1 extends AuthorizingRealm{

    private static final transient Logger log = LoggerFactory.getLogger(Main.class);

    /**
     * 獲取身份資訊，我們可以在這個方法中，從資料庫獲取該使用者的許可權和角色資訊
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        log.info("----------doGetAuthorizationInfo方法被呼叫----------");
        String username = (String) getAvailablePrincipal(principals);
        //通過使用者名稱從資料庫獲取許可權字串
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //許可權
        Set<String> s = new HashSet<String>();
        s.add("printer:print");
        s.add("printer:query");
        info.setStringPermissions(s);
        //角色
        Set<String> r = new HashSet<String>();
        r.add("role1");
        info.setRoles(r);

        return info;
    }
    /**
     * 在這個方法中，進行身份驗證
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {
        //使用者名稱
        String username = (String) token.getPrincipal();
        log.info("username:"+username);
        //密碼
        String password = new String((char[])token.getCredentials());
        log.info("password:"+password);
        //從資料庫獲取使用者名稱密碼進行匹配，這裡為了方面，省略資料庫操作
        if(!"admin".equals(username)){
            throw new UnknownAccountException();
        }
        if(!"123".equals(password)){
            throw new IncorrectCredentialsException();
        }
        //身份驗證通過,返回一個身份資訊
        AuthenticationInfo aInfo = new SimpleAuthenticationInfo(username,password,getName());

        return aInfo;
    }

}

配置檔案（shiro-realm.ini）

#宣告一個realm  
MyRealm1=com.shiro.realm.MyRealm1 
#指定securityManager的realms實現  
securityManager.realms=$MyRealm1

驗證許可權和角色

package com.shiro.realm;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {

    private static final transient Logger log = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        //獲取SecurityManager的例項
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");
        SecurityManager securityManager = factory.getInstance();

        SecurityUtils.setSecurityManager(securityManager);

        Subject currenUser = SecurityUtils.getSubject();

        //如果還未認證
        if(!currenUser.isAuthenticated()){
            UsernamePasswordToken token = new UsernamePasswordToken("admin","123");
            token.setRememberMe(true);
            try {
                currenUser.login(token);
            } catch (UnknownAccountException uae) {
                log.info("沒有該使用者： " + token.getPrincipal());
            } catch (IncorrectCredentialsException ice) {
                log.info( token.getPrincipal() + " 的密碼不正確!");
            } catch (LockedAccountException lae) {
                log.info( token.getPrincipal() + " 被鎖定 ，請聯絡管理員");
            }catch (AuthenticationException ae) {
                //其他未知的異常
            }
        }

        if(currenUser.isAuthenticated())
            log.info("使用者 "+currenUser.getPrincipal() +" 登入成功");
        //=====================使用編碼方式進行許可權和角色的驗證==================
        //是否有role1這個角色
        if(currenUser.hasRole("role1")){
            log.info("有角色role1");
        }else{
            log.info("沒有角色role1");
        }
        //是否有對印表機進行列印操作的許可權
        if(currenUser.isPermitted("printer:print")){
            log.info("可以對印表機進行列印操作");
        }else {
            log.info("不可以對印表機進行列印操作");
        }
    }

}

除了上面用到的hasRole和isPermitted，還有其他api可以驗證授權

—————————————————-角色————————————————–

方法	返回
hasRole(String roleName)	返回true 如果Subject 被分配了指定的角色
hasRoles(`List<String>` roleNames)	返回一個與方法引數中目錄一致的hasRole結果的陣列
hasAllRoles(`Collection<String>` roleNames)	返回true 如果Subject 被分配了所有的角色
checkRole(String roleName)	成功，不返回任何值，程式繼續執行；失敗時，將丟擲異常資訊
checkRoles(`Collection<String>` roleNames)	成功，不返回任何值，程式繼續執行；失敗時，將丟擲異常資訊
checkRole(String… roleNames)	成功，不返回任何值，程式繼續執行；失敗時，將丟擲異常資訊

—————————————————-許可權————————————————–

方法
isPermitted(String perm)
isPermitted(String… perms)
checkPermission(Permission p)
checkPermissions(`Collection<Permission>` perms)

許可權和角色的方法都差不多，就不再詳細說明了

3.2 基於註解的授權

基於註解的授權，需要有AOP的支援，我們這裡使用spring，你也可以使用AspectJ或者 Guice

建立一個java工程（注意，不是web工程，兩者的配置有一些差別）
自定義Realm（這一步和上面的MyRealm1一模一樣，複製一份即可）
在src下建立spring配置檔案（applicationContext.xml）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.shiro.anno"></context:component-scan>


    <!-- 配置Realm -->
    <bean id="MyRealm1" class="com.shiro.anno.MyRealm1"></bean>

    <!-- 配置securityManager -->
    <bean id="securityManager" class="org.apache.shiro.mgt.DefaultSecurityManager">
        <property name="realm" ref="MyRealm1" />
    </bean>
    <!-- 生命週期 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />

    <!-- 啟用shiro註解 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
    <bean
        class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <!-- 
        讓securityManager這個bean成為靜態單例的bean
        注意：在web應用中，不要配置這個
    -->
    <bean
        class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="staticMethod"
            value="org.apache.shiro.SecurityUtils.setSecurityManager" />
        <property name="arguments" ref="securityManager" />
    </bean>

</beans>

寫一個類用於註解授權

package com.shiro.anno;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Service;

@Service
public class HelloAnno {

    public void login(){

        Subject currenUser = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken("admin","123");
        token.setRememberMe(true);
        currenUser.login(token);
    }
    /**
     * 有printer:print許可權才能呼叫該方法
     * 否則拋異常
     */
    @RequiresPermissions({"printer:print"})
    public void testAnnotation(){
        System.out.println("使用註解方式。。。");
    }
}

測試

package com.shiro.anno;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Main {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloAnno helloAnno = (HelloAnno)ctx.getBean("helloAnno");

        helloAnno.login();
        //有許可權時，該方法才正常呼叫，否則拋異常
        helloAnno.testAnnotation();

    }

}

當有許可權時，正常呼叫，沒有許可權時，結果如下
還有其他的註解

註解	說明
@RequiresAuthentication	要求當前Subject 已經在當前的session 中被驗證通過才能被註解的類/例項/方法訪問或呼叫
@RequiresGues	要求當前的Subject 是一個“guest”，也就是他們必須是在之前的session中沒有被驗證或記住才能被註解的類/例項/方法訪問或呼叫
@RequiresPermissions	要求當前的Subject 被允許一個或多個許可權，以便執行註解的方法，比如：@RequiresPermissions(“account:create”)
@RequiresRoles	要求當前的Subject 擁有所有指定的角色。如果他們沒有，則該方法將不會被執行，而且AuthorizationException 異常將會被丟擲。比如：@RequiresRoles(“administrator”)
@RequiresUser	需要當前的Subject 是一個應用程式使用者才能被註解的類/例項/方法訪問或呼叫。要麼是通過驗證被確認，或者在之前session 中的’RememberMe’服務被記住

3.3 JSP標籤授權

1.上面使用的是普通的java工程結合spring進行註解方式的授權，jsp標籤授權就必須使用web專案了。
2.我們這次使用springmvc+spring+shiro

springmvc和spring相關配置，我直接貼出來，就不進行說明了

建立web專案
建立HelloAnno.java和MyRealm1.java（和上面一模一樣，複製即可）
在src下建立springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.shiro.controller"></context:component-scan>

    <mvc:annotation-driven></mvc:annotation-driven>
    <mvc:default-servlet-handler/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <property name="prefix" value="/WEB-INF/views/"></property>  
        <property name="suffix" value=".jsp"></property>  
    </bean>  

</beans>

在src下建立applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.shiro.annotation"></context:component-scan>

    <!-- shiro過濾器bean，id要和web.xml中filter-name一致 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />

        <property name="filterChainDefinitions">
            <value>
                #這裡相當於ini配置檔案中的[urls]
                #url=攔截器[引數]，攔截器
                # some example chain definitions:
                /admin/** = authc, roles[admin]
                /docs/** = authc, perms[document:read]
                # 當訪問login時，不用進行認證（anon表示匿名）
                /login = anon
                /** = authc
                # more URL-to-FilterChain definitions here
            </value>
        </property>
    </bean>

    <!-- 配置securityManager -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
        <property name="realm" ref="myRealm" />
        <!-- <property name="sessionMode" value="native"/> -->
    </bean>
    <!-- 生命週期 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />

    <!-- 配置Realm: -->
    <bean id="myRealm" class="com.shiro.annotation.MyRealm1"></bean>

    <!-- 啟用shiro註解 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    <!-- ============一般情況還要配置 資料來源，事務 等等=============== -->
</beans>

其實在spring配置檔案中，只使用到了spring的IOC容器，其他的配置都是在配置shiro

web.xml中配置，讓spring，springmvc，shiro過濾器起作用

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>shiro2</display-name>



  <!-- name要和 applicationContext.xml中的對應的bean的id一致 -->
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping> 

    <!-- 配置啟動 Spring IOC 容器的 Listener -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- Bootstraps the root web application context before servlet initialization -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- springmvc.xml -->
    <servlet>  
        <servlet-name>dispatcherServlet</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:springmvc.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>  
      </servlet>  

      <servlet-mapping>  
        <servlet-name>dispatcherServlet</servlet-name>  
        <url-pattern>/</url-pattern>  
      </servlet-mapping> 

</web-app>

在web目錄下建立login.jsp登入介面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h1>login</h1>
    <form action="login">
        <label>username:</label>
        <input type="text" name="username"/>
        <label>password:</label>
        <input type="text" name="password"/>
        <input type="submit" value="submit"/>
    </form>
</body>
</html>

對應的處理登入請求的controller

package com.shiro.controller;

import org.apache.shiro.SecurityUtils;
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.web.bind.annotation.RequestMapping;

import com.shiro.annotation.HelloAnno;

@Controller
public class TestController {

    @Autowired
    private HelloAnno helloAnno;

    @RequestMapping("/login")
    public String test(String username,String password){
        System.out.println("username:"+username);
        System.out.println("password"+password);

        //登入
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        Subject currentUser = SecurityUtils.getSubject();
        //如果登入失敗，會拋異常，應該要捕捉異常
        currentUser.login(token);

        if(currentUser.isAuthenticated()){
            System.out.println("認證成功");
            //有許可權才能呼叫該方法，沒許可權將拋異常
            helloAnno.testAnnotation();
        }

        return "success";
    }
}

在這裡，我們使用到了上面講過的基於註解的授權

最後返回success.jsp頁面，在該頁面中，我們使用jsp標籤授權

在WEB-INF/views下建立success.jsp（要匯入標籤庫）

<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h1>successful</h1>
    <!-- 如果當前使用者有printer:print許可權，標籤內的內容才顯示 -->
    <shiro:hasPermission name="printer:print">
        我有印表機的列印許可權
    </shiro:hasPermission>
    <shiro:hasPermission name="printer:query">
        我有印表機的查詢許可權
    </shiro:hasPermission>
    <shiro:hasPermission name="printer:delete">
        我有印表機的刪除許可權
    </shiro:hasPermission>
</body>
</html>

在我們自定義的Realm中，我們給了該使用者兩個許可權（printer:print和printer:query），因此success.jsp頁面應該打印出有查詢和列印兩個許可權，我們來看看結果是否與我們預期

在登入介面輸入使用者名稱密碼
提交後，跳轉到成功頁面

達到預期效果

jsp標籤除了有shiro:hasPermission之外，還有很多 <shiro:guest/>，<shiro:hasRole/> 等

Shiro學習筆記——資料庫讀取許可權資訊（不使用硬編碼的方式）

在ShiroFilterFactoryBean初始化的過程中，會執行一個setFilterChainDefinitionMap方法，傳入了一個Map，該Map就是URL與許可權的對應關係。編寫一個例

shiro學習筆記（3）--自定義realm、授權

一：自定義Realm 1、繼承AuthorizingRealm（因為該類中有認證、授權的抽象方法，實現簡單） public class MyRealm1 extends AuthorizingRealm{ @Override public String getName(

Shiro學習筆記（3）——授權（Authorization）

1.什麼是授權授權，就是訪問控制，控制某個使用者在應用程式中是否有許可權做某件事 2.授權三要素角色通常代表一組行為或職責.這些行為演化為你在一個軟體應用中能或者不能做的事情。角色通常是分配給使用者帳戶的，因此，通過分配，使

Shiro學習筆記（一）--- 認證與授權

一、簡介 Apache Shiro是一個強大且易用的Java安全框架,執行身份驗證、授權、密碼和會話管理。使用Shiro的易於理解的API,您可以快速、輕鬆地獲得任何應用程式,從最小的移動應用程式到最大的網路和企業應用程式。主要功能三個核心元件：Subject, Security

Python學習筆記__4.3章匿名函數（簡潔函數）

編程語言 Python # 這是學習廖雪峰老師python教程的學習筆記1、概覽關鍵字lambda表示匿名函數list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # 列表生成式中的 lambda 實際就是def f(x): return

python的學習筆記/002-3（2018-5-20）

列表（list）的常見操作群集類型群集類型列表元組字典集合 list tuple dict set 1.列表列表的類型是list,特點為有序，具備索引，內容與長度可以變動。要創建列表，可以使用[]直接表示法，列表中每個元素使用逗號分隔開。列表的常見操作(1) 元素的切片

shiro學習筆記（7）--cacheManager、sessionManager、rememberMe配置

1、授權：在自定義realm的doGetAuthorizationInfo方法中讀取使用者許可權並授權 @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection pri

shiro學習筆記（6）--spring整合及可能遇到的問題小結

上篇spring整合shiro後續… spring整合shiro主要是org.apache.shiro.web.filter.authc.FormAuthenticationFilter類。 1、controller @Controller public class HelloSsm {

shiro學習筆記（5）--spring整合

spring整合shiro（1） 1、jar <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</art

shiro學習筆記（4）--加密

一：加密 1、ini配置說明：（1）CredentialsMatcher在AuthenticatingRealm中注入（2）配置HashedCredentialsMatcher加密是因為此類中引數配置方便 #自定義realm 資料加密 [main] credentialsMatc

shiro學習筆記（2）--認證策略

一：shiro認證策略 1、三種認證策略的實現，可根據需要選擇 2、認證策略配置在ModularRealmAuthenticator中；我畫了一個簡單的流程圖，粗淺理解一下說明：（1）subject通過實現類DelegatingSubject呼叫login（）方法；（2）委託Sec

shiro學習筆記（1）--基礎定義

一：shiro基礎（學習地址：https://www.w3cschool.cn/shiro/andc1if0.html） 1、核心概念 Authentication：認證 Authorization：授權 SessionManageMent：session管理 Cryptography：

Shiro學習筆記（四）--- CustomRealm

一、簡介 CustomRealm（自定義Realm）是通過仿造JdbcRealm，繼承AuthrizingRealm，重寫doGetAuthenticationInfo(AuthenticationToken token)【認證】和 doGetAuthorizationInfo(Pri

Shiro學習筆記（三）--- JdbcRealm

一、簡介 JDBCRealm是對接資料庫資料作使用者，角色，許可權查詢的Realm 若使用者不提供查詢語句，則預設從users、user_roles、roles_permissions這三張表中查詢。下面是它的部分原始碼 public class JdbcRealm exten

Shiro學習筆記（二）--- IniRealm

一、簡介不同於上一章的simpleRealm，這一章用的是iniRealm。區別在於iniRealm是讀取於配置檔案xxx.ini 來獲取使用者資訊，角色資訊和許可權資訊。二、配置檔案 idea中，可以把配置檔案放在resource下 ini檔案遇

Esper學習筆記五：EPL語法（3）

1.Aggregation 類似於SQL中的聚合函式，EPL中聚合函式格式如下： aggregate_function([all|distinct] expression) aggregate_function就是聚合函式的名字，比如avg，sum等。expression通常是事件

《組合語言（第3版）（王爽著）》學習筆記一：基礎知識（1）

組合語言是直接在硬體之上工作的程式語言，我們首先要了解硬體系統的結構，才能有效地應用匯編語言對其程式設計。彙編課程的研究重點放在如何利用硬體系統的程式設計結構和指令集有效靈活地控制系統進行工作。

《組合語言（第3版）（王爽著）》學習筆記二：基礎知識（2）

1.7 CPU 對儲存器的讀寫以上講到，儲存器被劃分成多個儲存單元，儲存單元從零開始編號。這些編號可以看作儲存單元在儲存器中的地址。就想一條街，每個房子都有門牌號碼。 CPU 要從記憶體中讀資料，

《組合語言（第3版）（王爽著）》學習筆記三：基礎知識（3）

1.11 記憶體地址空間（概述）什麼是記憶體地址空間呢？舉例來講，一個 CPU 的地址匯流排寬度為 10，那麼可以定址 1024 個記憶體單元，這 1024 個可尋到的記憶體單元就構成這個 CPU

Shiro學習筆記（1）——shiro入門

1.建立一個簡單shiro專案建立一個java工程加入shiro需要的jar包在src下建立log4j配置檔案（非必需步驟，可以跳過）## Licensed to the Apache Software Foundation (ASF) under one# or

Shiro學習筆記（3）——授權（Authorization）

1.什麼是授權

2.授權三要素

3.Shiro的三種授權方式

3.1 編碼方式授權

3.2 基於註解的授權

3.3 JSP標籤授權

相關推薦