Shiro总结一架构，动态权限配置，登陆认证明现
首先说明一点,我没有删除和shiro无关的不少代码，主要是但愿你们能更清楚的看到完整项目中的配置，其次，下面文中的使用不会采用shiro配置文件的方式，而是采用实际web项目中动态配置权限认证的方式。若是须要了解文件配置的方式能够参考 https://www.w3cschool.cn/shiro/andc1if0.htmlcss
完整的项目地址 https://gitee.com/jiansin/ssmhtml
简单介绍
Apache Shiro 是 Java 的一个安全框架。目前，使用 Apache Shiro 的人愈来愈多，由于它至关简单，对比 Spring Security，可能没有 Spring Security 作的功能强大，可是在实际工做时可能并不须要那么复杂的东西，因此使用小而简单的 Shiro 就足够了。前端
基本功能
Authentication：身份认证 / 登陆，验证用户是否是拥有相应的身份；java
Authorization：受权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能作事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具备某个权限；git
Session Manager：会话管理，即用户登陆后就是一次会话，在没有退出以前，它的全部信息都在会话中；会话能够是普通 JavaSE 环境的，也能够是如 Web 环境的；web
Session Manager：会话管理，即用户登陆后就是一次会话，在没有退出以前，它的全部信息都在会话中；会话能够是普通 JavaSE 环境的，也能够是如 Web 环境的；redis
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；spring
Web Support：Web 支持，能够很是容易的集成到 Web 环境；数据库
Caching：缓存，好比用户登陆后，其用户信息、拥有的角色 / 权限没必要每次去查，这样能够提升效率；apache
Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另外一个线程，能把权限自动传播过去；
Testing：提供测试支持；
Run As：容许一个用户伪装为另外一个用户（若是他们容许）的身份进行访问；
Remember Me：记住我，这个是很是常见的功能，即一次登陆后，下次再来的话不用登陆了。
Shiro 不会去维护用户、维护权限；这些须要咱们本身去设计 / 提供；而后经过相应的接口注入给 Shiro 便可。
外部看Shiro
应用代码直接交互的对象是 Subject，也就是说 Shiro 的对外 API 核心就是 Subject；其每一个 API 的含义：
Subject：主体，表明了当前 “用户”，这个用户不必定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；全部 Subject 都绑定到 SecurityManager，与 Subject 的全部交互都会委托给 SecurityManager；能够把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；
SecurityManager:安全管理器；即全部与安全有关的操做都会与 SecurityManager 交互；且它管理着全部 Subject；能够看出它是 Shiro 的核心，它负责与后边介绍的其余组件进行交互，若是学习过 SpringMVC，你能够把它当作 DispatcherServlet 前端控制器；
Realm：域，Shiro 从从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它须要从 Realm 获取相应的用户进行比较以肯定用户身份是否合法；也须要从 Realm 获得用户相应的角色 / 权限进行验证用户是否能进行操做；能够把 Realm 当作 DataSource，即安全数据源。
Shiro架构
Subject：主体，能够看到主体能够是任何能够与应用交互的 “用户”；
SecurityManager：至关于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的 FilterDispatcher；是 Shiro 的心脏；全部具体的交互都经过 SecurityManager 进行控制；它管理着全部 Subject、且负责进行认证和受权、及会话、缓存的管理。
Authenticator：认证器，负责主体认证的，这是一个扩展点，若是用户以为 Shiro 默认的很差，能够自定义实现；其须要认证策略（Authentication Strategy），即什么状况下算用户认证经过了；
Authrizer：受权器，或者访问控制器，用来决定主体是否有权限进行相应的操做；即控制着用户能访问应用中的哪些功能；
Realm：能够有 1 个或多个 Realm，能够认为是安全实体数据源，即用于获取安全实体的；能够是 JDBC 实现，也能够是 LDAP 实现，或者内存实现等等；由用户提供；注意：Shiro 不知道你的用户 / 权限存储在哪及以何种格式存储；因此咱们通常在应用中都须要实现本身的 Realm；
SessionManager：若是写过 Servlet 就应该知道 Session 的概念，Session 呢须要有人去管理它的生命周期，这个组件就是 SessionManager；而 Shiro 并不只仅能够用在 Web 环境，也能够用在如普通的 JavaSE 环境、EJB 等环境；全部呢，Shiro 就抽象了一个本身的 Session 来管理主体与应用之间交互的数据；这样的话，好比咱们在 Web 环境用，刚开始是一台 Web 服务器；接着又上了台 EJB 服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就能够实现本身的分布式会话（如把数据放到 Memcached 服务器）；
SessionDAO：DAO 你们都用过，数据访问对象，用于会话的 CRUD，好比咱们想把 Session 保存到数据库，那么能够实现本身的 SessionDAO，经过如 JDBC 写到数据库；好比想把 Session 放到 Memcached 中，能够实现本身的 Memcached SessionDAO；另外 SessionDAO 中可使用 Cache 进行缓存，以提升性能；
CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；由于这些数据基本上不多去改变，放到缓存中后能够提升访问的性能
Cryptography：密码模块，Shiro 提升了一些常见的加密组件用于如密码加密 / 解密的。
Shiro 身份验证
在 shiro 中，用户须要提供 principals （身份）和 credentials（证实）给 shiro，从而应用能验证用户身份：
principals：身份，即主体的标识属性，能够是任何东西，如用户名、邮箱等，惟一便可。一个主体能够有多个 principals，但只有一个 Primary principals，通常是用户名 / 密码 / 手机号。
credentials：证实 / 凭证，即只有主体知道的安全值，如密码 / 数字证书等。
最多见的 principals 和 credentials 组合就是用户名 / 密码了。
Spring整合shiro
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.3.2</version>
</dependency>
spring-shiro.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="redisSessionDAO" class="com.plantform.shiro.commons.RedisSessionDao"/>
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
<!-- 设置session过时时间为1小时(单位：毫秒)，默认为30分钟 -->
<property name="globalSessionTimeout" value="3600000"/>
<property name="sessionValidationSchedulerEnabled" value="true"/>
<property name="sessionDAO" ref="redisSessionDAO"/>
</bean>
<bean id="cacheManager" class="com.plantform.shiro.commons.RedisCacheManager">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>
<!-- Shiro默认会使用Servlet容器的Session,可经过sessionMode属性来指定使用Shiro原生Session -->
<!-- 即<property name="sessionMode" value="native"/>,详细说明见官方文档 -->
<!-- 这里主要是设置自定义的单Realm应用,如有多个Realm,可以使用'realms'属性代替 -->
<!-- securityManager安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realms">
<list>
<ref bean="shiroRealm"/>
</list>
</property>
<!-- 注入缓存管理器 -->
<property name="cacheManager" ref="cacheManager"/>
<!-- 注入session管理器 -->
<property name="sessionManager" ref="sessionManager"/>
<!-- 记住我 -->
</bean>
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<!-- 要求登陆时的连接(可根据项目的URL进行替换),非必须的属性,默认会自动寻找Web工程根目录下的"/login.html"页面 -->
<property name="loginUrl" value="/index.jsp"/>
<!-- 用户访问未对其受权的资源时,所显示的链接 -->
<property name="unauthorizedUrl" value="/"/>
<property name="filters">
<map>
<entry key="authc" value-ref="authenticationFilter"/>
</map>
</property>
<!-- Shiro链接约束配置,即过滤链的定义 -->
<!-- 此处可配合个人这篇文章来理解各个过滤连的做用http://blog.csdn.net/jadyer/article/details/12172839 -->
<!-- 下面value值的第一个'/'表明的路径是相对于HttpServletRequest.getContextPath()的值来的 -->
<!-- anon：它对应的过滤器里面是空的,什么都没作,这里.do和.jsp后面的*表示参数,比方说login.jsp?main这种 -->
<!-- authc：该过滤器下的页面必须验证后才能访问,它是Shiro内置的一个拦截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter -->
<property name="filterChainDefinitions">
<value>
/login.jsp=anon
/system/captcha=anon
/static/**=anon
/system/logout = anon
/system/login=anon
/oauth/**=anon
/error/**=anon
/v2/**/=anon
/webjars/**=anon
/swagger-resources/**=anon
/swagger-ui.html/**=anon
/system/welcome=authc
/**=authc
</value>
</property>
</bean>
<bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
<property name="hashAlgorithmName" value="md5"/>
<property name="hashIterations" value="2"/>
</bean>
<bean id="shiroRealm" class="com.plantform.shiro.commons.ShiroRealm">
<property name="credentialsMatcher" ref="credentialsMatcher"/>
</bean>
<bean id="authenticationFilter" class="com.plantform.shiro.commons.ShiroAuthenticationFilter"/>
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
<!-- AOP式方法级权限检查 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
depends-on="lifecycleBeanPostProcessor">
<property name="proxyTargetClass" value="true"/>
</bean>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
</beans>
在spring配置文件中引入shiro资源文件,项目的其余配置我依然不会删除，一样是但愿你们能了解一下spring的整合方式，扩展你们的思路。
<?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"
xsi:schemaLocation="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.xsd">
<!-- 加载property文件配置 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:*.properties</value>
</list>
</property>
</bean>
<!-- 组件扫描 -->
<context:component-scan base-package="com.plantform.**"/>
<!-- 加载mybatis文件配置 -->
<import resource="classpath*:spring-mybatis.xml"/>
<!--redis-->
<import resource="classpath*:spring-redis.xml"/>
<!--shiro-->
<import resource="classpath*:spring-shiro.xml"/>
<bean id="customJobFactory" class="com.plantform.quartz.utils.CustomJobFactory"/>
<bean id="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<!--Scheduler推迟10秒启动-->
<property name="startupDelay" value="10"/>
<property name="autoStartup" value="true"/>
<property name="jobFactory" ref="customJobFactory"/>
<property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
<property name="configLocation" value="classpath:quartz.properties"/>
</bean>
</beans>
登陆
@ApiOperation(value = "登陆", httpMethod = "POST", produces = "application/json", response = Result.class)
@ResponseBody
@RequestMapping(value = "login", method = RequestMethod.POST)
public Result login(@RequestParam String loginName,
@RequestParam String password,
@RequestParam int platform,
HttpServletRequest request) throws Exception {
//根据用户名查询是否存在用户
SysUser user = sysUserService.selectByLoginName(loginName);
if (user == null) {
//告诉前端目前系统中不存在该用户，直接返回，再也不进行后面的shiro登陆。
return Result.instance(ResponseCode.unknown_account.getCode(), ResponseCode.unknown_account.getMsg());
}
Subject subject = SecurityUtils.getSubject();
//这个地方可能会抛出异常，系统已经进行全局处理了
subject.login(new UsernamePasswordToken(loginName, password));
LoginInfo loginInfo = sysUserService.login(user, subject.getSession().getId(), platform);
subject.getSession().setAttribute("loginInfo", loginInfo);
log.debug("登陆成功");
return Result.success(loginInfo);
}
完整的项目代码地址 https://gitee.com/jiansin/ssm.git
身份认证流程
首先调用 Subject.login(token) 进行登陆，其会自动委托给 Security Manager，SecurityManager 负责真正的身份验证逻辑；它会委托给 Authenticator 进行身份验证；
Authenticator 才是真正的身份验证者，Shiro API 中核心的身份认证入口点，此处能够自定义插入本身的实现；
Authenticator 可能会委托给相应的 AuthenticationStrategy 进行多 Realm 身份验证，默认 ModularRealmAuthenticator 会调用 AuthenticationStrategy 进行多 Realm 身份验证；
Authenticator 会把相应的 token 传入 Realm，从 Realm 获取身份验证信息，若是没有返回 / 抛出异常表示身份验证失败了。此处能够配置多个 Realm，将按照相应的顺序及策略进行访问。
Realm
Shiro 从从 Realm 获取安全数据（如用户、角色、权限），就是说SecurityManager 要验证用户身份，那么它须要从 Realm 获取相应的用户进行比较以肯定用户身份是否合法；也须要从 Realm 获得用户相应的角色 / 权限进行验证用户是否能进行操做；能够把 Realm 当作 DataSource，即安全数据源。
package com.plantform.shiro.commons;
import com.plantform.common.SystemConstant;
import com.plantform.shiro.bean.*;
import com.plantform.shiro.mapper.*;
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.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @Author: lee
* @Date : 2019/03/18
* @Description 自定义realm实现
*/
public class ShiroRealm extends AuthorizingRealm {
private static Logger log = LoggerFactory.getLogger(ShiroRealm.class);
/**
* 登陆验证
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
log.debug("登陆验证");
String username = (String)token.getPrincipal(); //获得用户名
String password = new String((char[])token.getCredentials()); //获得密码
if(!"admin".equals(username)) {
throw new UnknownAccountException(); //若是用户名错误
}
if(!"123456".equals(password)) {
throw new IncorrectCredentialsException(); //若是密码错误
}
//若是身份认证验证成功，返回一个AuthenticationInfo实现；
return new SimpleAuthenticationInfo(username, password, getName());
}
Shiro 受权方式
编程式：经过写 if/else 受权代码块完成：
Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
//有权限
} else {
//无权限
}
注解式：经过在执行的 Java 方法上放置相应的注解完成，实际应用开发中基本采用注解 方式：
@RequiresRoles("admin")
public void hello() {
//有权限
}
没有权限将抛出相应的异常；
JSP/GSP 标签：在 JSP/GSP 页面经过相应的标签完成：
<shiro:hasRole name="admin"> <!— 有权限 —> </shiro:hasRole>
Shiro动态受权
package com.plantform.shiro.commons;
import com.plantform.common.SystemConstant;
import com.plantform.shiro.bean.*;
import com.plantform.shiro.mapper.*;
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.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @Author: lee
* @Description 自定义realm实现
*/
public class ShiroRealm extends AuthorizingRealm {
private static Logger log = LoggerFactory.getLogger(ShiroRealm.class);
@Autowired
private SysUserPermissionMapper sysUserPermissionMapper;
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysPermissionMapper sysPermissionMapper;
@Autowired
private SysUserRoleOrganizationMapper sysUserRoleOrganizationMapper;
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysRoleOrganizationMapper sysRoleOrganizationMapper;
@Autowired
private SysRolePermissionMapper sysRolePermissionMapper;
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
/**
* 鉴权信息
*
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
log.debug("开始查询受权信息");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
String loginStr = (String) principalCollection.getPrimaryPrincipal();
SysUser user = sysUserMapper.selectUserByLoginName(loginStr);
List<SysUserPermission> userPermissions = sysUserPermissionMapper.selectByUserId(user.getId());
Set<String> permissions = new HashSet<>();
Set<String> roles = new HashSet<>();
for (SysUserPermission userPermission : userPermissions) {
SysPermission sysPermission = sysPermissionMapper.selectById(userPermission.getSysPermissionId());
permissions.add(sysPermission.getCode());
}
List<SysUserRoleOrganization> userRoleOrganizations = sysUserRoleOrganizationMapper.selectByUserId(user.getId());
for (SysUserRoleOrganization sysUserRoleOrganization : userRoleOrganizations) {
SysRoleOrganization sysRoleOrganization = sysRoleOrganizationMapper.selectById(sysUserRoleOrganization.getSysRoleOrganizationId());
SysRole sysRole = sysRoleMapper.selectById(sysRoleOrganization.getSysRoleId());
roles.add(sysRole.getName());
List<SysRolePermission> sysRolePermissions = sysRolePermissionMapper.selectByRoleId(sysRole.getId());
for (SysRolePermission sysRolePermission : sysRolePermissions) {
SysPermission sysPermission = sysPermissionMapper.selectById(sysRolePermission.getSysPermissionId());
permissions.add(sysPermission.getCode());
}
}
info.addRoles(roles);
info.addStringPermissions(permissions);
log.debug("角色信息: \n {}", roles.toString());
log.debug("权限信息: \n{}", permissions.toString());
return info;
}
/**
* 登陆验证
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
log.debug("登陆验证");
String loginName = (String) authenticationToken.getPrincipal();
SysUser sysUser = sysUserMapper.selectUserByLoginName(loginName);
AuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(loginName, sysUser.getPassword(), ByteSource.Util.bytes(sysUser.getPasswordSalt()), getName());
return authenticationInfo;
}
@Override
protected void doClearCache(PrincipalCollection principals) {
redisTemplate.delete(SystemConstant.shiro_cache_prefix + principals.getPrimaryPrincipal().toString());
}
@Override
protected void clearCachedAuthorizationInfo(PrincipalCollection principals) {
log.debug("clearCachedAuthorizationInfo");
}
}
配置shiro受权也能够采用以下这种方式
https://www.w3cschool.cn/shiro/skex1if6.html
web应用集成shiro
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1" metadata-complete="true">
<display-name>ssm</display-name>
<description>springmvc-mybatis脚手架</description>
<!-- 在Spring框架中是如何解决从页面传来的字符串的编码问题的呢？
下面咱们来看看Spring框架给咱们提供过滤器CharacterEncodingFilter
这个过滤器就是针对于每次浏览器请求进行过滤的，而后再其之上添加了父类没有的功能即处理字符编码。
其中encoding用来设置编码格式，forceEncoding用来设置是否理会 request.getCharacterEncoding()方法，设置为true则强制覆盖以前的编码格式。-->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 添加druid监控-->
<servlet>
<servlet-name>DruidStatView</servlet-name>
<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DruidStatView</servlet-name>
<url-pattern>/druid/*</url-pattern>
</servlet-mapping>
<!-- 添加Web应用等监控-->
<filter>
<filter-name>DruidWebStatFilter</filter-name>
<filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
<init-param>
<param-name>exclusions</param-name>
<param-value>*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*</param-value>
</init-param>
<init-param>
<param-name>profileEnable</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>principalCookieName</param-name>
<param-value>USER_COOKIE</param-value>
</init-param>
<init-param>
<param-name>principalSessionName</param-name>
<param-value>USER_SESSION</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>DruidWebStatFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 项目中使用Spring 时，applicationContext.xml配置文件中并无BeanFactory，要想在业务层中的class 文件中直接引用Spring容器管理的bean可经过如下方式-->
<!--一、在web.xml配置监听器ContextLoaderListener-->
<!--ContextLoaderListener的做用就是启动Web容器时，自动装配ApplicationContext的配置信息。由于它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。
在ContextLoaderListener中关联了ContextLoader这个类，因此整个加载配置过程由ContextLoader来完成。
它的API说明
第一段说明ContextLoader能够由 ContextLoaderListener和ContextLoaderServlet生成。
若是查看ContextLoaderServlet的API，能够看到它也关联了ContextLoader这个类并且它实现了HttpServlet 这个接口
第二段，ContextLoader建立的是 XmlWebApplicationContext这样一个类，它实现的接口是WebApplicationContext->ConfigurableWebApplicationContext->ApplicationContext->
BeanFactory这样一来spring中的全部bean都由这个类来建立
IUploaddatafileManager uploadmanager = (IUploaddatafileManager)
ContextLoaderListener.getCurrentWebApplicationContext().getBean("uploadManager");-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--二、部署applicationContext的xml文件-->
<!--若是在web.xml中不写任何参数配置信息，默认的路径是"/WEB-INF/applicationContext.xml，
在WEB-INF目录下建立的xml文件的名称必须是applicationContext.xml。
若是是要自定义文件名能够在web.xml里加入contextConfigLocation这个context参数：
在<param-value> </param-value>里指定相应的xml文件名，若是有多个xml文件，能够写在一块儿并以“,”号分隔。
也能够这样applicationContext-*.xml采用通配符，好比这那个目录下有applicationContext-ibatis-base.xml，
applicationContext-action.xml，applicationContext-ibatis-dao.xml等文件，都会一同被载入。
在ContextLoaderListener中关联了ContextLoader这个类，因此整个加载配置过程由ContextLoader来完成。-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--若是你的DispatcherServlet拦截"/"，为了实现REST风格，拦截了全部的请求，那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。-->
<!--方案一：激活Tomcat的defaultServlet来处理静态文件-->
<!--要写在DispatcherServlet的前面， 让 defaultServlet先拦截请求，这样请求就不会进入Spring了，我想性能是最好的吧。-->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.swf</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.gif</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.png</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.xml</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.json</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.map</url-pattern>
</servlet-mapping>
<!--使用Spring MVC,配置DispatcherServlet是第一步。DispatcherServlet是一个Servlet,,因此能够配置多个DispatcherServlet-->
<!--DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(咱们写的Action)来处理。-->
<servlet>
<servlet-name>spring-mvc</servlet-name>
<!--在DispatcherServlet的初始化过程当中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。-->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--指明了配置文件的文件名，不使用默认配置文件名，而使用dispatcher-servlet.xml配置文件。-->
<init-param>
<param-name>contextConfigLocation</param-name>
<!--其中<param-value>**.xml</param-value> 这里可使用多种写法-->
<!--一、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml-->
<!--二、<param-value>/WEB-INF/classes/dispatcher-servlet.xml</param-value>-->
<!--三、<param-value>classpath*:dispatcher-servlet.xml</param-value>-->
<!--四、多个值用逗号分隔-->
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
<!--是启动顺序，让这个Servlet随Servletp容器一块儿启动。-->
</servlet>
<servlet-mapping>
<!--这个Servlet的名字是dispatcher，能够有多个DispatcherServlet，是经过名字来区分的。每个DispatcherServlet有本身的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中.-->
<!--ApplicationContext是Spring的核心，Context咱们一般解释为上下文环境，我想用“容器”来表述它更容易理解一些，ApplicationContext则是“应用的容器”了:P，Spring把Bean放在这个容器中，在须要的时候，用getBean方法取出-->
<servlet-name>spring-mvc</servlet-name>
<!--Servlet拦截匹配规则能够自已定义，当映射为@RequestMapping("/user/add")时，为例,拦截哪一种URL合适？-->
<!--一、拦截*.do、*.htm， 例如：/user/add.do,这是最传统的方式，最简单也最实用。不会致使静态文件（jpg,js,css）被拦截。-->
<!--二、拦截/，例如：/user/add,能够实现如今很流行的REST风格。不少互联网类型的应用很喜欢这种风格的URL。弊端：会致使静态文件（jpg,js,css）被拦截后不能正常显示。 -->
<!--<url-pattern>*.do</url-pattern>-->
<url-pattern>/</url-pattern>
<!--会拦截URL中带“/”的请求。-->
</servlet-mapping>
<!-- shiro的filter -->
<!-- shiro过虑器，DelegatingFilterProxy经过代理模式将spring容器中的bean和filter关联起来 -->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<!-- 设置true由servlet容器控制filter的生命周期 -->
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
<!-- 设置spring容器filter的bean id，若是不设置则找与filter-name一致的bean-->
<init-param>
<param-name>targetBeanName</param-name>
<param-value>shiroFilter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<error-page>
<!--当系统出现404错误，跳转到页面nopage.html-->
<error-code>404</error-code>
<location>/nopage.html</location>
</error-page>
<error-page>
<!--当系统出现java.lang.NullPointerException，跳转到页面error.html-->
<exception-type>java.lang.NullPointerException</exception-type>
<location>/error.html</location>
</error-page>
<session-config>
<!--会话超时配置，单位分钟-->
<session-timeout>360</session-timeout>
</session-config>
</web-app>
相关文章
- 1. Shiro 登陆认证及权限管理
- 2. shiro实现APP、web统一登陆认证和权限管理
- 3. springmvc+shiro+maven 实现登陆认证与权限受权管理
- 4. Spring Boot 整合 Shiro 实现登陆认证与权限控制
- 5. Shiro登陆认证
- 6. Shiro权限认证
- 7. shiro：受权，认证总结
- 8. 四、Shiro之IniRealm以及用户登陆认证，角色认证，权限认证
- 9. springboot(十四)：springboot整合shiro-登陆认证和权限管理
- 10. springboot整合shiro-登陆认证和权限管理
- 更多相关文章...
- • IP地址分配（静态分配+动态分配+零配置） - TCP/IP教程
- • Maven 构建配置文件 - Maven教程
- • 算法总结-滑动窗口
- • IntelliJ IDEA 代码格式化配置和快捷键
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
