Shiro許可權控制
阿新 • • 發佈：2019-01-28
一 shiro簡介
apache shiro 是功能強大並且容易整合的開源許可權框架，它能夠完成認證、授權、加密、會話管理等功能。認證和授權為許可權控制的核心，簡單來說，“認證”就是證明“你是誰？” Web 應用程式一般做法是通過表單提交的使用者名稱及密碼達到認證目的。“授權”即是"你能做什麼?"，很多系統通過資源表的形式來完成使用者能做什麼
二 shiro和spring整合
我這裡用的是 SpringMvc + Mybatis + Shiro 整合,
shiro實現過程中的許可權等資訊會查詢資料庫, 使用的是Mybatis查詢, 實現方式參照上面連線,不再贅述
直接介紹Shiro和 Spring的整合
1 web.xml 配置
<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 2 在Spring配置檔案中新增Shiro的配置
我在springApplication.xml引入了shiro的單獨配置檔案
<import resource="classpath:config/aC-shiro.xml" shiro的配置檔案如下:
<?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:util="http://www.springframework.org/schema/util"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
default-lazy-init="true">
<description>Shiro安全配置</description>
<!-- 使用預設的WebSecurityManager -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="MyShiroDbRealm" />
<!-- cacheManager,集合spring快取工廠 -->
<!-- <property name="cacheManager" ref="shiroEhcacheManager" />-->
</bean>
<!-- 專案自定義的Realm, 所有accountService依賴的dao都需要用depends-on宣告 -->
<bean id="MyShiroDbRealm" class="com.ass.shiro.service.MyShiroDbRealm">
<!--
<property name="accountService" ref="accountService"/>
-->
</bean>
<!-- Shiro Filter
提示: org.apache.shiro.spring.web.ShiroFilterFactoryBean 的 id 名稱必須和 web.xml 的 filter-name 一致
-->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- shiro的核心安全介面 -->
<property name="securityManager" ref="securityManager" />
<!-- 要求登入時的連結 -->
<property name="loginUrl" value="/login.do" />
<!-- 登陸成功後要跳轉的連線 -->
<property name="successUrl" value="/"/>
<!-- 沒有許可權要跳轉的連結 -->
<property name="unauthorizedUrl" value="/unauthorized.do" />
<!-- shiro連線約束配置,在這裡使用自定義的 從資料庫中動態獲取資源 -->
<property name="filterChainDefinitionMap" ref="chainDefinitionSectionMetaSource" />
<!-- 上面的標籤從資料庫中取許可權資訊, 下面的標籤的許可權資訊就解除安裝xml檔案裡面,選擇一種使用即可 -->
<!-- [上行的配置的覆蓋下行的配置的]
<property name="filterChainDefinitions">
<value>
/login.do = authc
/favicon.ico = anon
/logout.do = logout
/images/** = anon
/css/** = anon
/common/system/index.jsp = authc
/common/ueditor/** = anon
/common/** = anon
/door/** = anon
/dwr/** = anon
/ = anon
/core/** = anon
/push/** = anon
/** = anon
</value>
</property> -->
</bean>
<!-- 自定義對 shiro的連線約束,結合shiroSecurityFilter實現從資料庫中動態獲取資源, 預設的連線配置 -->
<bean id="chainDefinitionSectionMetaSource" class="com.ass.shiro.service.ChainDefinitionSectionMetaSource">
<property name="filterChainDefinitions">
<value>
<!-- -->
/login.do = authc
/favicon.ico = anon
/logout.do = logout
/images/** = anon
/css/** = anon
/common/js/jquery-1.10.2.min.js = anon
/selectOption.do = roles[index]
/index.jsp = perms[index:index]
<!-- /** = authc -->
<!-- authc必須是驗證過的,不能是"remember me",
而user可以是"remember me",只要Subject包含principal就行。 -->
<!--
anon: 例子/admins/**=anon 沒有引數，表示可以匿名使用。
authc: 例如/admins/user/**=authc表示需要認證(登入)才能使用，沒有引數
authcBasic：例如/admins/user/**=authcBasic沒有引數表示httpBasic認證
user:例如/admins/user/**=user沒有引數表示必須存在使用者，當登入操作時不做檢查
roles：例子/admins/user/**=roles[admin],引數可以寫多個，多個時必須加上引號，並且引數之間用逗號分割，當有多個引數時，例如admins/user/**=roles["admin,guest"],每個引數通過才算通過，相當於hasAllRoles()方法。
perms：例子/admins/user/**=perms[user:add:*],引數可以寫多個，多個時必須加上引號，並且引數之間用逗號分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，當有多個引數時必須每個引數都通過才通過，想當於isPermitedAll()方法。
rest： 例子/admins/user/**=rest[user],根據請求的方法，相當於/admins/user/**=perms[user:method] ,其中method為post，get，delete等。
ssl:例子/admins/user/**=ssl沒有引數，表示安全的url請求，協議為https
port： 例子/admins/user/**=port[8081],當請求的url的埠不是8081是跳轉到schemal://serverName:8081?queryString,其中schmal是協議http或https等，serverName是你訪問的host,8081是url配置裡port的埠，queryString
是你訪問的url裡的？後面的引數。
注：anon，authcBasic，auchc，user是認證過濾器，
perms，roles，ssl，rest，port是授權過濾器
-->
</value>
</property>
</bean>
<!-- 使用者授權資訊Cache, 採用EhCache
<bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
<property name="cacheManagerConfigFile" value="/WEB-INF/config/ehcache/ehcache-shiro.xml"/>
</bean>
-->
<!-- 保證實現了Shiro內部lifecycle函式的bean執行 -->
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
<!-- 註解 使用方式，暫時為用到。下面方式沒有驗證。
<aop:aspectj-autoproxy proxy-target-class="true" />
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
-->
</beans>上面配置檔案中 的配置:
<bean id="chainDefinitionSectionMetaSource" class="com.ass.shiro.service.ChainDefinitionSectionMetaSource">會在專案啟動的時候從資料庫中載入許可權資訊.
許可權:
一個人擁有多個角色, 一個角色包含多個許可權,
人和角色1對多, 角色和許可權1對多
對應資料庫表:
t_user:使用者表
t_user_role:使用者 角色中間表
t_role: 角色表
t:role_permission: 角色許可權中間表
t_permission: 許可權表
com.ass.shiro.service.ChainDefinitionSectionMetaSource3類自動讀取資料庫中許可權資訊的實現方式如下
package com.ass.shiro.service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.shiro.config.Ini;
import org.apache.shiro.config.Ini.Section;
import org.apache.shiro.util.CollectionUtils;
import org.apache.shiro.web.config.IniFilterChainResolverFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ass.common.generated.dao.TPermissionMapper;
import com.ass.common.generated.model.TPermission;
import com.ass.common.generated.model.TPermissionExample;
import com.ass.common.utils.StringUtil;
/**
* 藉助spring {@link FactoryBean} 對apache shiro的premission進行動態建立 動態的從資料庫中讀取許可權資訊
*
* @author wangt
*
*/
@Component
public class ChainDefinitionSectionMetaSource implements
FactoryBean<Ini.Section> {
public static int i;
// shiro預設的連結定義 寫在xml上的。
private String filterChainDefinitions;
@Resource
private TPermissionMapper tPermissionMapper;
/**
* 通過filterChainDefinitions對預設的連結過濾定義
*
* @param filterChainDefinitions
* 預設的接過濾定義
*/
public void setFilterChainDefinitions(String filterChainDefinitions) {
this.filterChainDefinitions = filterChainDefinitions;
}
@Override
public Section getObject() throws BeansException {
Ini ini = new Ini();
// 載入預設的url
ini.load(filterChainDefinitions);
System.out.println(filterChainDefinitions);
/*1載入類似以下的資訊
/login.do = authc
/favicon.ico = anon
/logout.do = logout
/selectOption.do = roles[index]
/index.jsp = perms[index:index]
/testDwr.jsp = perms[index:testdwr]
2
迴圈資料庫資源的url
for (Resource resource : resourceDao.getAll()) {
if(StringUtils.isNotEmpty(resource.getValue()) && StringUtils.isNotEmpty(resource.getPermission())) {
section.put(resource.getValue(), resource.getPermission());
}
}
載入資料庫t_permission 的 value 和 permission組成類似1的格式 ，
若要這樣使用， permission 需要---> perms[permission]
*/
Ini.Section section = ini.getSection(Ini.DEFAULT_SECTION_NAME);
//查詢資料庫中所有的 路徑對應需要的許可權.
TPermissionExample example = new TPermissionExample();
example.createCriteria().andPermissionIsNotNull().andValueIsNotNull().andNameIsNotNull();
List<TPermission> lst = tPermissionMapper.selectByExample(example);
for(TPermission per : lst){
//訪問某一路徑，需要對應的許可權
if(StringUtil.isNotEmpty(per.getValue())&&StringUtil.isNotEmpty(per.getPermission()))
section.put(per.getValue(), "perms["+per.getPermission()+"]");
}
//section.put("/testDwr.jsp", "perms[index:testdwr]");///testDwr.jsp = perms[index:testdwr]
/*//因為順序原因, 把/**放到最後
* [上面的配置覆蓋下面的配置]
* 把("/**", "authc") 放在 ("/testDwr.jsp", "perms[index:testdwr]") 上面,
* /testDwr.jsp 就只需要登入, 不需要perms[index:testdwr]許可權了
*/
section.put("/**", "anon");
for(String s : section.keySet()){
System.out.println(s + "----"+ section.get(s)+"-----------section");
}
return section;
}
@Override
public Class<?> getObjectType() {
return Section.class;
}
@Override
public boolean isSingleton() {
return true;
}
}t_permission表的資料格式:
4 Shiro 認證 授權
在shiro的xml配置檔案有配置,認證授權的類:MyShiroDbRealm
package com.ass.shiro.service;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
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.apache.shiro.util.ByteSource;
import org.springframework.stereotype.Component;
import org.springside.modules.utils.Encodes;
import com.ass.common.generated.model.TUser;
import com.ass.common.service.AccountService;
import com.ass.common.service.AccountServiceImpl;
import com.ass.common.utils.StringUtil;
import com.ass.shiro.dto.CurUser;
/**
*
* @author wangt 2014年11月17日 下午6:06:41
*/
@Component
public class MyShiroDbRealm extends AuthorizingRealm {
protected final Log logger = LogFactory.getLog(getClass());
@Resource
protected AccountService accountService;
/**
* 認證回撥函式,登入時呼叫. 獲取認證資訊added by wangt
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
TUser tUser = accountService.findUserByLoginName(token.getUsername());
if (tUser != null) {
byte[] salt = Encodes.decodeHex(tUser.getSalt());
//設定同級，下級查詢許可權
boolean siblingQuery = accountService.haveSiblingQuery(tUser.getId());
boolean lowerQuery = accountService.haveLowerQuery(tUser.getId());
String queryLevel = "none";
if(siblingQuery == true && lowerQuery == true){
queryLevel = "all";
}
if(siblingQuery == true && lowerQuery == false){
queryLevel = "sibling";
}
if(siblingQuery == false && lowerQuery == true){
queryLevel = "lower";
}
SimpleAuthenticationInfo s = new SimpleAuthenticationInfo(new CurUser(tUser,queryLevel),tUser.getPassword(), ByteSource.Util.bytes(salt), getName());
return s;
} else {
return null;
}
}
/**
* 授權查詢回撥函式, 進行鑑權但快取中無使用者的授權資訊時呼叫. 獲取授權資訊 added by wangt
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
CurUser curUser = (CurUser) principals.getPrimaryPrincipal();
//此處獲取使用者許可權的List
List<String> lst = accountService.getPermissionsByUserid(curUser.getId());
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
// 設定使用者的許可權
info.addStringPermissions(lst);
//獲得使用者所有的角色
Set<String> roles = new HashSet<String>();
for(String str : lst){
if(StringUtil.isNotBlank(str)){
roles.add(StringUtil.split(str,":")[0]);
}
}
//設定角色 實際使用盡量用許可權。
info.addRoles(roles);
logger.info(curUser.getLoginName());
for(String s : roles){
logger.info("包含的role-->"+s);
}
for(String s : lst){
logger.info("包含的permission-->"+s);
}
return info;
}
/**
* 設定Password校驗的Hash演算法與迭代次數.
*/
@PostConstruct
public void initCredentialsMatcher() {
HashedCredentialsMatcher matcher = new HashedCredentialsMatcher(AccountServiceImpl.HASH_ALGORITHM);
matcher.setHashIterations(AccountServiceImpl.HASH_INTERATIONS);
setCredentialsMatcher(matcher);
}
}另外說明:
如果在jsp頁面上使用shiro的標籤,每一個標籤都會訪問一次shiro的授權函式,所以建議shiro的授權函式查詢的時候做一下快取,自己寫一個map就好.
getPermissionsByUserid(String id) 查詢許可權的方法
快取實現方式如下:
package com.ass.common.service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springside.modules.security.utils.Digests;
import org.springside.modules.utils.Encodes;
import com.ass.base.service.BaseServiceImpl;
import com.ass.common.generated.dao.TUserMapper;
import com.ass.common.generated.model.TUser;
import com.ass.common.generated.model.TUserExample;
import com.ass.common.utils.StringUtil;
import com.ass.log.service.UserLogService;
//Spring Service Bean的標識.
@Service
public class AccountServiceImpl extends BaseServiceImpl implements AccountService{
//@Resource
//private AuthorityService authorityService;
@Resource
private TUserMapper tUserMapper;
@Resource
private CommonService commonService;
@Resource
private UserLogService userLogService;
/** 加密策略 */
public static final String HASH_ALGORITHM = "SHA-1";
/** 迭代次數 */
public static final int HASH_INTERATIONS = 1024;
/** 鹽長 */
private static final int SALT_SIZE = 8;
/**
* 儲存新建使用者以及其角色
* @param tUser
* @param roles
* @author wangt 2014年11月27日 下午5:32:19
*/
public void saveUser(TUser tUser, String[] roles) {
// 設定安全的密碼，生成隨機的salt並經過1024次 sha-1 hash
if (StringUtil.isNotEmpty(tUser.getPassword())) {
encryptPassword(tUser);
}
//設定t_organization_code
String sql2 = "select code from t_organization where id = "+tUser.gettOrganizationId();
Map<String, Object> mp = commonService.selectOneBySql(sql2);
tUser.settOrganizationCode(StringUtil.getString(mp.get("code")));
tUserMapper.insertSelective(tUser);
//設定角色
if(null != roles){
for(String s : roles){
String sql = "insert into t_user_role set t_user_id = "+tUser.getId()+", t_role_id = "+ s;
commonService.insertBySql(sql);
}
}
//記錄日誌，暫不使用 TODO
//userLogService.addUser(tUser);
}
//更新密碼
@Override
public void updatePassword(TUser u){
if (StringUtil.isNotEmpty(u.getPassword())) {
encryptPassword(u);
}
tUserMapper.updateByPrimaryKeySelective(u);
}
/**
* 儲存編輯後的使用者資訊以及角色
* @param tUser
* @param roles
* @author wangt 2014年11月27日 下午5:32:44
*/
public void editUser(TUser tUser, String[] roles){
if (StringUtil.isNotEmpty(tUser.getPassword())) {
encryptPassword(tUser);
}
//記錄日誌 暫不使用 TODO
//userLogService.editUser(tUser);
//設定t_organization_code
String sql2 = "select code from t_organization where id = "+tUser.gettOrganizationId();
Map<String, Object> mp = commonService.selectOneBySql(sql2);
tUser.settOrganizationCode(StringUtil.getString(mp.get("code")));
tUserMapper.updateByPrimaryKeySelective(tUser);
String sqld = "delete from t_user_role where t_user_id = "+tUser.getId();
commonService.deleteBySql(sqld);
//設定角色
if(null !=roles){
for(String s : roles){
String sql = "insert into t_user_role set t_user_id = "+tUser.getId()+", t_role_id = "+ s;
commonService.insertBySql(sql);
}
}
}
private HashMap<Long, List<String>> permissionMaps = new HashMap<Long, List<String>>();
/**
* 獲得使用者的所有許可權 的permission
* 傳null為當前登入人
* @param id
* @return List<String>
*/
public List<String> getPermissionsByUserid(Long id) {
if(id == null){
id = this.getUser().getId();
}
//防止每次訪問這個方法都要查詢資料庫
if (!permissionMaps.containsKey(id) || permissionMaps.get(id) == null ) {
this.reloadPermissionMaps(id);
}
return this.permissionMaps.get(id);
}
private void reloadPermissionMaps(Long id){
//資料庫中存 admin:add,
String sql = "select distinct p.permission permission_ from t_user u "
+ " left join t_user_role ur on ur.t_user_id=u.id "
+ " left join t_role_permission rp on rp.t_role_id=ur.t_role_id "
+ " left join t_permission p on p.id = rp.t_permission_id "
+ " where p.pid!=0 and u.id = "+id;
List<Map<String, Object>> lst = commonService.selectBySql(sql);
List<String> ls = new ArrayList<String>();
for(int i=0; i<lst.size(); i++){
ls.add(StringUtil.getString(lst.get(i).get("permission_")));
}
this.permissionMaps.put(id, ls);
}
/**
* 獲得使用者的所有許可權 的id
* 傳null為當前登入人
* @param id
* @return
* @author wangt 2014年11月27日 下午9:44:03
*/
public List<String>
相關推薦
springmvc整合shiro許可權控制
一、什麼是Shiro
Apache Shiro是一個強大易用的Java安全框架，提供了認證、授權、加密和會話管理等功能：
認證 - 使用者身份識別，常被稱為使用者“登入”；
授權 - 訪問控制；
密碼加密 - 保護或隱藏資料防止被偷窺；
會話
Apache Shiro 許可權控制 使用自定義的JdbcRealm（3）
使用自定義的realm 時需要配置shiro.ini 檔案 以及建一個類 MyJdbcRealm 繼承自 AuthorizingRealm 重寫其中的兩個方法
&nbs
Apache Shiro 許可權控制（2）
Shiro的 /WEB-INF目錄下的shiro.ini 配置檔案url匹配方式：
① ？ 可以匹配一個字元
/admin? ---->可以匹配到/admin1 /admin12匹配不到
② *
javaEE shiro框架，許可權控制。基於Spring框架的shiro許可權控制
許可權控制的方式：
方式一：通過過濾器或Struts2的攔截器實現許可權控制
方式二：為Struts2的Action加入註解(標識),然後為Action建立代理物件;代理物件進行許可權校驗,校驗通過後通過反射呼叫目標方法。
shiro框架可以進行認證、授權、會話管理、加
關於Apache shiro許可權控制學習小結
第一種：URL 級別粗粒度許可權控制
配置 web.xml 的 shiroFilter 攔截 /*
在 spring 的 applicationContext*.xml 配置檔案中配置同名 bean，配置 filterChainDefinitions 攔截控制規則
x
Apache Shiro 許可權控制 使用自定義的JdbcRealm（3）
使用自定義的realm 時需要配置shiro.ini 檔案 以及建一個類 MyJdbcRealm 繼承自 AuthorizingRealm 重寫其中的兩個方法 /**
* 登入驗證
*/
@Override
protected Authenti
Apache Shiro許可權控制實戰，許可權控制SpringMVC + Mybatis + Shiro
Demo已經部署到線上，地址是http://shiro.itboy.net，
管理員帳號：admin，密碼：sojson.com 如果密碼錯誤，請用sojson。
PS：你可以註冊自己的帳號，然後用管理員賦許可權給你自己的帳號，但是，每20分鐘會把資料初始化一次。建議自己
shiro許可權控制+前後端分離+複雜請求(OPTIONS+POST)遇到的問題
我們知道，shiro做許可權控制，能夠對請求的url做控制，如果使用者未登陸，那麼對於有些請求，就會出現禁止訪問的情況。
對於前後端分離的專案，存在跨域的問題，shiro做許可權控制，也是有解決辦法的，就是讓前端的所有非同步ajax請求帶上cookie。比如：
通過xhrField
shiro許可權控制下的ehcache快取技術總結
shiro預設對ehcache快取技術的支援，因此不使用redis緩衝技術
---------------------------------------------------------------------------------------
ehcache配置步驟
springboot shiro許可權控制講解01 每天進步百分之一
許可權大體分兩種，操作許可權和資料許可權，以下主要講操作許可權的控制
操作許可權是一個管理系統的基本功能，最最簡單的就是驗證使用者的帳號和密碼了
那既然驗證，就有一張使用者表了，想起這個就想起的大學老師佈置做的學生管理系統了
第一天 學生登入檢視自己的基本
Shiro許可權控制
一 shiro簡介apache shiro 是功能強大並且容易整合的開源許可權框架，它能夠完成認證、授權、加密、會話管理等功能。認證和授權為許可權控制的核心，簡單來說，“認證”就是證明“你是誰？” Web 應用程式一般做法是通過表單提交的使用者名稱及密碼達到認證目的。“授權”
shiro許可權控制（一）：shiro介紹以及整合SSM框架
shiro安全框架是目前為止作為登入註冊最常用的框架，因為它十分的強大簡單，提供了認證、授權、加密和會話管理等功能 。 shiro能做什麼？ 認證：驗證使用者的身份 授權：對使用者執行訪問控制：判斷使用者是否被允許做某事 會話管理：在任
Apache Shiro 許可權控制的四種方式
第一種：URL 級別粗粒度許可權控制
配置 web.xml 的 shiroFilter 攔截 /*
在 spring 的 applicationContext*.xml 配置檔案中配置同名 bean，配置
filterChainDefinitions 攔截控制規則
Jeeplus框架SSM+shiro許可權控制中實現跳過登入驗證訪問介面資料
新專案中用的Jeeplus框架，裡面用的shiro許可權控制，特別好用，但是如果單獨寫介面的話，總是會有登入驗證，下面上思路實現一行程式碼讓任意介面跳過登入限制。
正常程式碼生成機生成的程式碼不管它，這是每個模組都會自動生成的專案目錄下的模組目錄。
下面這個假設是我們自
shiro許可權控制，會話超時跳轉登入頁面只有iframe跳轉，父頁面沒有跳轉
在使用Apache Shiro框架做許可權驗證時，因為我的頁面是使用iframe做了一個上左右的分層，上面上log，左側是選單，具體的內容則顯示在右側。
當我點選某選單，此時如果會話超時了，則登入頁面只會顯示到右側區域，看起來不是很友好，所以需要登入頁面顯示到整個瀏覽器
Shiro許可權控制 ---base64加密、MD5加密
在Java中也有MD5加密，現在咱們講的是Shiro許可權控制框架中自帶的加密方式，有base64加密、MD5加密
<span style="font-size:18px;">packa
Springboot+SpringMVC+Myabtis整合shiro許可權控制
最近也被這個難題搞的我頭都大了額。寫下此篇文章獻給自己和廣大朋友。如果有不懂的地方可以加企鵝號詢問哦。
企鵝號：2054861587，不一定會時時在，但如果有空的話就會給你回答
maven依賴:
<dependency>
<groupId>
Shiro許可權控制框架 ---SpringMVC+Spring+My batis+Mysql+Maven整合開發Web專案
在之前的博文簡單的介紹shiro許可權控制框架，現在我們接著講解使用 SpringMVC+Spring+My batis+Mysql+Maven整合開發Web專案
1.先由Maven選擇MavenProject建立一個Web專案（如果你還不會使用Maven的話可以去看
spring boot整合shiro 簡單許可權控制
package me.config;
import javax.annotation.Resource;
import me.domain.entity.CmsUser; import me.service.UserService; import me.utils.MD5Util
成長記錄貼之springboot+shiro（二） {完成一個完整的許可權控制，詳細步驟}
近一個月比較忙，公司接了一個新專案，領導要求用shiro進行安全管理，而且全公司只有我一個java，從專案搭建到具體介面全是一個人再弄。不過剛好前段時間大概學習了一下shiro的使用，還算順利。
&n