shiro框架配置文件（shiro框架 ***** shiro在哪）

：暂无数据 2026-04-21 21:00:03 ：0

上一篇文章我们介绍了shiro框架配置文件的基础，今天我们将深入其核心环节——shiro框架 ***** shiro在哪，看看它如何承前启后。

本文目录

shiro框架 ***** shiro在哪
shiro 如何配置到tomcat应用上
spring mvc整合shiro无法访问***是什么问题
【Shiro】一步步的看Shiro 【Shiro与Spring Security区别】
如何正确的使用shiro
若依权限框架 Shiro
shiro记住我cookie无法添加按照网上的说法把配置文件中所有的配置都写了 javabea
spring中如何配置shiro和quartz的问题
springMvc+shiro做权限管理，页面上的静态资源，样式图片等没有出现，用几种方式过滤试过，还是不行

shiro框架 ***** shiro在哪

*****和shiro没关系哦。

推荐一套完整的Shiro Demo，免费的。

***隐藏网址***
***隐藏网址***

管理员帐号：admin，密码：***** 如果密码错误，请用sojson。
PS：你可以注册自己的帐号，然后用管理员赋权限给你自己的帐号，但是，每20分钟会把数据初始化一次。建议自己下载源码，让Demo跑起来，然后跑的更快。

1 、首先创建一个项目名(mail)的文件夹, 在项目文件夹下创建一个存放JS脚本的文件夹，创建一个存放images(图片)的文件夹，创建一个存放CSS样式的文件夹等。

2、然后在项目文件夹下创建一个WEB-INF的目录文件，J**A类、jar包、WEB应用的配置文件都存在这个目录下。WEB-INF目录下存放了一些文件，有classes目录(编译好的类库)、lib目录，每一个WEB应用程序的访问都需要一个配置文件，*****文件，所以在WEB-INF *****文件。

3、在所创建的项目mail文件夹下创建一个HTML文件,*****。在HTML文件中一些内容。

4、在tomcat目录文件夹下的conf文件的Catalina\*****的项目文件，在这个文件中代码，写一个Context的配置的路径如：
《?xml version=’1.0’ encoding=’utf-8’?》
《Context docBase=”C:\mail”/》

5、最后重新启动Comcat就可以了。

spring mvc整合shiro无法访问***是什么问题

　　1.概述
　　现在的项目使用的权限控制系统是spring security 3.因为项目的框架使用spring，就顺便使用了。最近研究了一下spring
side4，推荐使用shiro。照着示例做了一遍。在原有的spring web工程中。步骤如下。
　　2.引进包,maven设置
　　 view plaincopy
　　*****
　　shiro-all
　　1.2.1
　　jar
　　compile
　　3.实现Controller层
　　主要是**url和几个掩饰url
　　 view plaincopy
　　@Controller
　　public class AdminController {
　　@RequestMapping(value = "/admin/index", method = *****)
　　public String index(Model model) {
　　return "admin/index";
　　}
　　@RequestMapping(value = "/admin/login", method = *****)
　　public String login(Model model) {
　　*****("login get");
　　return "admin/login";
　　}
　　@RequestMapping(value = "/admin/login", method = *****)
　　public String doLogin(Model model) {
　　*****("login post");
　　return "admin/login";
　　}
　　@RequiresRoles("user")
　　@RequestMapping(value = "/admin/user", method = *****)
　　public String shiroUser(Model model) {
　　return "admin/index";
　　}
　　@RequiresRoles("admin")
　　@RequestMapping(value = "/admin/admin", method = *****)
　　public String shiroAdmin(Model model) {
　　return "admin/index";
　　}
　　Logger logger = *****(*****);
　　}
　　4.实现权限验证
　　继承shiro的AuthorizingRealm
　　 view plaincopy
　　public class ShiroDbRealm extends AuthorizingRealm {
　　protected AccountService accountService;
　　@Autowired
　　public void setAccountService(AccountService accountService) {
　　***** = accountService;
　　}
　　/**
　　* 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用.
　　*/
　　@SuppressWarnings("unused")
　　@Override
　　protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection p)
{
　　*****("授权认证：" + *****());
　　ShiroUser shiroUser = (ShiroUser) *****();
　　&nbsnbspUser user =
*****(*****);
　　SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
　　for (Role role : *****()) {
　　//基于Role的权限信息
　　*****(*****());
　　//基于Permission的权限信息
　　*****(********());
　　}
　　return info;
　　}
　　/**
　　* 认证回调函数,登录时调用.
　　*/
　　@Override
　　protected AuthenticationInfo doGetAuthenticationInfo(
　　AuthenticationToken authcToken) throws AuthenticationException {
　　*****("authc pass:");
　　UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
　　*****("authc name:" + *****());
　　User user = *****(*****());
　　if (user != null) {
　　if (*****().equals("disabled")) {
　　throw new DisabledAccountException();
　　}
　　*****("authc name:" + *****() + " user:"
　　+ *****() + " pwd:" + *****()
　　+ "getname:" + getName());
　　// byte salt = *****(*****());
　　return new SimpleAuthenticationInfo(new ShiroUser(*****(),
*****()),
　　*****(), getName());
　　}
　　return null;
　　}
　　/**
　　* 自定义Authentication对象，使得Subject除了携带用户的登录名外还可以携带更多信息.
　　*/
　　public static class ShiroUser implements Serializable {
　　private static final long serialVersionUID = -1373760761780840081L;
　　public String loginName;
　　public String name;
　　public ShiroUser(String loginName, String name) {
　　***** = loginName;
　　***** = name;
　　}
　　public String getName() {
　　return loginName;
　　}
　　/**
　　* 本函数输出将作为默认的输出.
　　*/
　　@Override
　　public String toString() {
　　return loginName;
　　}
　　/**
　　* 重载hashCode,只计算loginName;
　　*/
　　@Override
　　public int hashCode() {
　　return *****(loginName);
　　}
　　/**
　　* 重载equals,只计算loginName;
　　*/
　　@Override
　　public boolean equals(Object obj) {
　　if (this == obj)
　　return true;
　　if (obj == null)
　　return false;
　　if (getClass() != *****())
　　return false;
　　ShiroUser other = (ShiroUser) obj;
　　if (loginName == null) {
　　if (***** != null)
　　return false;
　　} else if (!*****(*****))
　　return false;
　　return true;
　　}
　　}
　　Logger logger = *****(*****);
　　}
　　自定义的类ShiroUser是为了，可以多传输一些内容，供后面验证时使用，例子中只用了一个loginName，一般可以用String
传输就够了。
　　**时用doGetAuthenticationInfo（）函数获得相关信息。
　　**后访问url 使用doGetAuthorizationInfo()获得用户的权限。
　　5.配置文件shiro部分
　　将controller的url纳入权限验证范围。
　　 view plaincopy
***隐藏网址***
***隐藏网址***
***隐藏网址***
***隐藏网址***
　　default-lazy-init="true"》
　　Shiro安全配置
　　/admin/login = authc
　　/admin/logout = logout
　　/static/** = anon
　　/admin/** = authc
　　主要内容是shiroFilter的定义。
　　loginUrl：**页面，用户**不成功，自动返回此页面。
　　successUrl：**成功后跳转此页面
　　unauthorizedUrl：用户访问无权限的链接时跳转此页面
　　filterChainDefiniti***：设置url的访问权限。anon表示不用验证，都可以访问。anthc：authc filter
**，不**不能访问。logout：logout filter**。没有列出的常用配置：perms ：需要角色romote
和权限invoke才能访问。roles需要角色admin才能访问。设置可用“,”隔开，如：
　　/admin/test = authc,roles
　　关于filter的列表：
　　Filter NameClass
　　*****
　　*****
　　*****
　　********AuthorizationFilter
　　*****
　　*****
　　*****
　　*****
　　*****

【Shiro】一步步的看Shiro 【Shiro与Spring Security区别】

Apache Shiro 是 Java 的一个安全框架。目前，使用 Apache Shiro 的人越来越多，因为它相
当简单，Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在
JavaEE 环境。Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与 Web 集成、缓
存等

Spring Security是一个提供身份验证、授权和防范常见攻击的框架。它对命令式应用程序和响应式应用程序都提供了一流的支持，是保护基于spring的应用程序的事实上的标准

OAuth for Spring Security为Spring Security提供了一个OAuth实现。支持OAuth提供者和OAuth消费者的实现。支持OAuth 2.0

完美撒花~，下面我会根据Shiro的具体内容结合不同场景的进行讲述以及配置。

有需要讨论Shiro和Spring Security有什么区别或者有什么不同看法的，欢迎留言_{大家共同学习}

如何正确的使用shiro

从来没接触过shiro Java安全框架，突然有一天需要要用用户**验证和用户角色权限的任务，而且是针对shiro 进行整合，开始收到任务，心都有点凉凉的。经过一轮的搜索，感觉没多大的收获。很多用户的角色都是写在xml配置文件中。觉得太不人性化了，想换个用户角色还得改xml?我觉得这么强大的框架应该不可能这么狗血的存在。然后认真的看文档，发现真的是可以直接读取数据库的。我把我搭建的流程发布在此。有问题的可以交流交流。我写的也并不是正确的，只能参考参考。
*****的配置
《listener》
《listener-class》*****《/listener-class》
《/listener》
《filter》
《filter-name》shiroFilter《/filter-name》
《filter-class》*****《/filter-class》
《/filter》
《filter-mapping》
《filter-name》shiroFilter《/filter-name》
《url-pattern》/*《/url-pattern》
《/filter-mapping》
*****配置
#自定义realm
shiroAuthorizingRealm = *****
***** = $shiroAuthorizingRealm
# 声明一个自定义的用户校验拦截器
customFormAuthenticationFilter = *****
# 声明一个自定义的用户角色权限拦截器
customPermissi***AuthorizationFilter = ********AuthorizationFilter
#cache
shiroCacheManager = *****
***** = classpath:*****
***** = $shiroCacheManager
#session
sessionDAO = *****
sessionManager = *****
***** = $sessionDAO
***** = $sessionManager
***** = 1800000
securityManager = *****
/admin/user/login = anon
/admin/user/logout = anon
/admin/user/registered = anon
/admin/** = customFormAuthenticationFilter,customPermissi***AuthorizationFilter
*****配置中可以看出，需要三个文件，*****(realm文件)，*****(自定义用户**验证文件)，CustomPermissi***AuthorizationFilter(自定义用户角色权限文件);
在urls配置中可以看出不需要拦截的url后面加上anon便可，但有先后顺序。
缓存是使用ehcache
*****配置
《cache name="defaultCache" maxElementsInMemory="500"
maxElementsOnDisk="10000000" eternal="true" overflowToDisk="true"
diskSpoolBufferSizeMB="50" /》
《cache name="shiro-activeSessionCache" maxElementsInMemory="500"
maxElementsOnDisk="10000000" eternal="true" overflowToDisk="true"
diskSpoolBufferSizeMB="50" /》
《cache name="*****" maxElementsInMemory="500"
maxElementsOnDisk="10000000" eternal="true" overflowToDisk="true"
diskSpoolBufferSizeMB="50" /》
《cache name="authorization" maxElementsInMemory="500"
timeToLiveSeconds="3600" eternal="false" overflowToDisk="false" /》
*****
public class ShiroAuthorizingRealm extends AuthorizingRealm {
private AuthorityService authorityService = *****(*****);
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
*****("=======doGetAuthenticationInfo=======");
UsernamePasswordToken userToken = (UsernamePasswordToken) token;
String username = *****();
String password = *****(*****());
User user = *****("select * from m_user where account = ?", username);
if (user != null) {//下面可以做一些**的操作，密码错误，用户状态等等
if(*****(password, *****())==false){
throw new UnknownAccountException();
}
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, getName());
return info;
} else {
return null;
}
}
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
*****("=======doGetAuthorizationInfo=======");
User user = (User) *****();
if(user!=null){//从数据库中读取用户的角色权限，
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
List《String》 perms = *****(user);
if(perms!=null&&*****()》0){//调用addStringPermissi***方法把用户的权限信息添加到info中，可以addRoles方法把用户的角色添加到了info中
********(perms);
}
return info;
}
return null;
}
}
*****
public class CustomFormAuthenticationFilter extends FormAuthenticationFilter {
private final static Logger log = *****(*****);
private static final String contentType = "application/json; charset=UTF-8";
protected boolean onAccessDenied(ServletRequest request, ServletResp***e resp***e) throws Exception {
***隐藏网址***
***隐藏网址***
if (isLoginRequest(request, resp***e)) {
if (isLoginSubmission(request, resp***e)) {
if (*****()) {
*****("Login submission detected. Attempting to execute login.");
}
return executeLogin(request, resp***e);
} else {
if (*****()) {
*****("Login page view.");
}
return true;
}
} else {
Result《Object》 result = new Result《Object》(false, "401", "没有授权，请先登录", null);
***隐藏网址***
return false;
}
}
private void renderJson(HttpServletResp***e resp***e, Object object) {
String jsonText = *****(object);
PrintWriter writer = null;
try {
resp********("Pragma", "no-cache"); // HTTP/1.0 caches might not implement Cache-Control and might only implement Pragma: no-cache
resp********("Cache-Control", "no-cache");
resp********("Expires", 0);
resp********(contentType);
writer = resp********();
*****(jsonText);
*****();
} catch (IOException e) {
throw new RenderException(e);
}
finally {
if (writer != null) {
*****();
}
}
}
}
*************
public class CustomPermissi***AuthorizationFilter extends Permissi***AuthorizationFilter {
private static final String contentType = "application/json; charset=UTF-8";
private AuthorityService authorityService = *****(*****);
@Override
public boolean isAccessAllowed(ServletRequest request, ServletResp***e resp***e, Object mappedValue) throws IOException {
if(getMappedValue(request)!=null){
return *****(request, resp***e, getMappedValue(request));
}
return false;
}
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResp***e resp***e) throws IOException {
// TODO Auto-generated method stub
***隐藏网址***
***隐藏网址***
***隐藏网址***
Subject subject = getSubject(request, resp***e);
if (*****(path)) {
return true;
} else {
Result《Object》 result = new Result《Object》(false, "401", "抱歉，您没有该权限！", null);
***隐藏网址***
return false;
}
}
/**
* 得到mappedValue，相当于perms中的“user:add”
* @param path
* @return
*/
public String getMappedValue(ServletRequest request) {
HttpServletRequest req = (HttpServletRequest) request;
String path = *****();
String code = getCodesByPath(path);
if(null == code) {
return null;
}
return new String{code};
}
/**
* 根据访问路径获取权限代码
* @param path
* @return
*/
public String getCodesByPath(String path) {
User user = (User) *****().getPrincipal();
String pers = *****(path,user);
return *****(pers).orElse(null);
}
private void renderJson(HttpServletResp***e resp***e, Object object) {
String jsonText = *****(object);
PrintWriter writer = null;
try {
resp********("Pragma", "no-cache"); // HTTP/1.0 caches might not implement Cache-Control and might only implement Pragma: no-cache
resp********("Cache-Control", "no-cache");
resp********("Expires", 0);
resp********(contentType);
writer = resp********();
*****(jsonText);
*****();
} catch (IOException e) {
throw new RenderException(e);
}
finally {
if (writer != null) {
*****();
}
}
}
}
7.用户**入口
public void login() {
String account = getPara("account");
String password = getPara("password");
Subject subject = *****();
UsernamePasswordToken tokens = new UsernamePasswordToken(account, password);
*****(false);
try {
*****(tokens);
User user = (User) *****();
loginSuccess(user);
UserVo userVo = convertToUserVO(user);
renderSucessResult(userVo);
} catch (UnknownAccountException ue) {
*****();
renderFailedResult("登录失败！无效的账号或密码！");
} catch (IncorrectCredentialsException ie) {
*****();
renderFailedResult("用户已注销！");
} catch(LockedAccountException le){
*****();
renderFailedResult("账号被锁定！");
} catch (RuntimeException re) {
*****();
*****();
renderFailedResult("登录失败！");
}
}
数据库可以自己去设计，这里就不提供了。
参照上面的去整合框架，便可以使用了，这样搭建适合多种框架的整合。

若依权限框架 Shiro

1. shiro中的重要概念

要理解shiro，先要理解框架的几个概念：

1) Subject : 代表当前**或者访问的用户；

2） Principals ：一般指用户名等，唯一表明Subject身份也就是当前用户身份的东西；

3） Credentials ：凭证，一般指密码，对当前**用户进行验证；

4） Realms： 域，一般是指存储用户信息（用户名，密码，权限，角色）的数据库，也就是保存用户权限等信息的数据源；

5） SecurityManager ：shiro安全管理的**对象。它集合或者说调用所有其它相关组件，负责所有安全和权限相关处理过程，就像一个中央集权政府；

2. shiro的子系统

上面我们说到shiro的主要功能有：认证，授权，加密，session管理等。而每一个主要功能对应于shiro的一个子系统，下面分别介绍。

3. Authentication认证子系统

认证子系统，就是处理用户登录，验证用户登录。

一般我们new一个UsernamePasswordToken的对象：UsernamePasswordToken token = new UsernamePasswordToken("xxxusername", "xxxpassword");,

然后 *****(token); 就前去登录。相关代码一般如下：

Authentication 子系统会将password加密，然后使用username和加密之后的password和从Realm(一般是数据库)中根据usename获得的密码进行比较，相同就登录成功，不相同同就登录失败，或者用户名不存在也登录失败。就怎么简单。当然从Realm中根据用户名查找用户的过程是需要我们自己编码实现的。该功能的实现代码如下。

4. Authorization 授权子系统(访问控制，权限控制)

在需要判断用户是否有某权限或者角色时，代码如下：

我们看到 doGetAuthorizationInfo 方法中使用了 SimpleAuthorizationInfo 类封装 Role 和 ***** 和 stringPermissi*** 都是 String 类型的 Set, 也就是说，它们都是使用字符串来表示你拥有某个角色或者拥有某个权限的。

1) 两种访问控制方式：

SimpleAuthorizationInfo 封装了角色和权限，其实这也说明了实现“访问控制”两种方式：一是 “ 基于角色的访问控制 ” ；而是“ 基于资源的访问控制 ”。所谓的访问控制，是指对于某个资源，当前用户是否有访问的权限。基于角色的访问控制是一种比较粗粒度的访问控制方式，只要你具有了某个或某几个角色，那么你就可以访问某资源。而基于资源的访问控制，是判断你针对该资源是否有某权限，有才能访问，粒度更细，你是否有某权限，可以根据你有哪些角色，然后改角色有哪些权限来判断的，当然也可以不引入角色的概念，直接判断你是否拥有某些权限。当然两种访问方式可以单独使用，也可以混合使用。比如对于比较简单的权限控制，你可以仅仅只使用基于角色的访问控制，仅仅引入角色表，不需要权限表都可以。混合使用是指，你可以同时要求用户具有某角色并且具有某些权限，才能访问某资源。所以shiro的权限控制时极其灵活的(当然也可以不引入角色表，仅仅引入权限表)。

2）权限的字符串表示方式

上面说到角色和权限都是使用字符串来表示的，其实 shiro 提供了一套比较强大有点复杂的权限字符串表示格式(分为:分割的三个部分)：“ 资源：操作：对象实例ID ” 表示：对那个资源的哪个实例可以进行哪些操作，支持通配符。多个操作需要使用 “,” 逗号分割，而 “*” 放在三个位置上，分别表示：任意资源，任意操作，任意实例。比如："user:delete:1" 就表示对user表的id等于1对应的数据或者对象，可以进行删除操作。其实资源表现实现可以是对象，其实最终是对应到数据库表中的记录。再比如："user:update,delete" 就表示对user表(的任意实例)进行更新和删除操作。"user:update,delete" 其实就等价于 “user:update,delete:*”所以 shiro 的访问控制可以控制到具体实例，或者说具体哪条数据库记录，也可以在表级别控制。如果省略掉对象实例ID部分，就是在表级别控制。

3）权限相关表的设计

1》如果对于简单的情况，可以只使用“基于角色的访问控制”粗粒度方式，不涉及到权限，仅仅只通过判断是否有某角色来判断访问控制，那么就只需要增加一个角色表(roles) 和一个角色(roles)和用户(user)的多对多的一个中间表——用户角色表(user_role)。

2》如果仅仅使用权限来控制访问，那么就可以仅仅只增加一个权限表(priv)和一个用户和权限的多对多的一个中间表——用户权限表(user_priv).

3》如果既要用到角色，又要用到权限(权限根据角色推算出来)，那么就要增加：角色表，用户角色表，权限表，角色权限表。

4》其实还有一种情况：就是角色和权限没有关系，那么就可以增加：角色表，用户角色表，权限表，用户权限表。不过这种方式不同符合常规。

其他的如 Cryptography 加密子系统和 Session Management会话管理子系统这里不做介绍。

shiro记住我cookie无法添加按照网上的说法把配置文件中所有的配置都写了 javabea

ie11下查看cookie：1:IE11=》F12打开开发人员工具2：开发人员工具=》网络F5启用网络流量捕获3：IE11=》输入和访问相关网址4：开发人员工具=》网络=》详细信息=》Cookie如果你只在java后台写的cookie，前端浏览器当然看不到

spring中如何配置shiro和quartz的问题

楼主我给你发下我配置的qurzte吧
《!-- 要调用的工作类 --》
《bean id="quartzJob" class="*****"》
《property name="udao" ref="ushDao"》《/property》
《/bean》
《!-- 定义调用对象和调用对象的方法 --》
《bean id="jobtask"
class="**************"》
《!-- 调用的类 --》
《property name="targetObject"》
《ref bean="quartzJob" /》
《/property》
《!-- 调用类中的方法 --》
《property name="targetMethod"》
《value》AutoUpdateByTime《/value》
《/property》
《/bean》
《!-- 定义触发时间 --》
《bean id="doTime"
class="**************"》
《property name="jobDetail"》
《ref bean="jobtask" /》
《/property》
《!-- cron表达式 --》
《property name="cronExpression"》
《value》0 0 */1 * * ?《/value》
《/property》
《/bean》
《!-- 总管理类如果将lazy-init=’false’那么容器启动就会执行调度程序 --》
《bean id="startQuertz" lazy-init="false"
class="**************"》
《property name="triggers"》
《list》
《ref bean="doTime" /》
《/list》
《/property》
《/bean》