ssm分页插件+安全认证+权限控制

前言：内容基本来源于各种博客或视频笔记，偶尔会加些个人补充，仅作为复习巩固用途。如有错误，请指出，谢谢。
血泪教训：org.springframework.security.access.AccessDeniedException: Access is denied

一、PageHelper介绍

注意：PageHelper是mybatis分页插件
详细说明：本项目在 gitosc 的项目地址

1、集成

1.1、引入 Jar 包

待补充

1.2、使用 Maven

在 pom.xml 中添加如下依赖：

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>最新版本</version>
</dependency>

2、配置

2.1、在 MyBatis 配置 xml 中配置拦截器插件，暂时未尝试这种方式

<!--
plugins在配置文件中的位置必须符合要求，否则会报错，顺序如下:
properties?, settings?,
typeAliases?, typeHandlers?,
objectFactory?,objectWrapperFactory?,
plugins?,
environments?, databaseIdProvider?, mappers?
-->
<plugins>
	<!-- com.github.pagehelper为PageHelper类所在包名 -->
	<plugin interceptor="com.github.pagehelper.PageInterceptor">
		<!-- 使用下面的方式配置参数，后面会有所有的参数介绍 -->
		<property name="param1" value="value1"/>
	</plugin>
</plugins>

2.2、在 Spring 配置文件中配置拦截器插件

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<!-- 注意其他配置 -->
	<property name="plugins">
		<array>
			<bean class="com.github.pagehelper.PageInterceptor">
				<property name="properties">
					<!--使用下面的方式配置参数，一行配置一个 
					<value>
					params=value1
					</value>-->
					<props>
   							<prop key="helperDialect">mysql</prop>
   							<prop key="reasonable">true</prop>
   					</props>
				</property>
			</bean>
		</array>
	</property>
</bean>

3、分页插件参数介绍

1. helperDialect ：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置helperDialect 属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值：
oracle , mysql , mariadb , sqlite , hsqldb , postgresql , db2 , sqlserver , informix , h2 , sqlserver2012 , derby
特别注意：使用 SqlServer2012 数据库时，需要手动指定为sqlserver2012 ，否则会使用 SqlServer2005 的方式进行分页。
你也可以实现 AbstractHelperDialect ，然后配置该属性为实现类的全限定名称即可使用自定义的实现方法。

2. offsetAsPageNum ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。 
当该参数设置为true 时，会将 RowBounds 中的 offset 参数当成 pageNum 使用，可以用页码和页面大小两个参数进行分页。

3. rowBoundsWithCount ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。 
当该参数设置为 true 时，使用 RowBounds 分页会进行 count 查询。

4. pageSizeZero ：默认值为 false ，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit =0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）。

5. reasonable ：分页合理化参数，默认值为 false 。
当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages （超过总数时），会查询最后一页。默认 false 时，直接根据参数进行查询。

6. params ：为了支持 startPage(Object params) 方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值， 可以配置pageNum,pageSize,count,pageSizeZero,reasonable ，不配置映射的用默认值， 默认值为
pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero
。

7. supportMethodsArguments ：支持通过 Mapper 接口参数来传递分页参数，默认值 false ，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。 
使用方法可以参考测试代码中的 com.github.pagehelper.test.basic 包下的 ArgumentsMapTest 和ArgumentsObjTest 。

8. autoRuntimeDialect ：默认值为 false 。
设置为 true 时，允许在运行时根据多数据源自动识别对应方言的分页 （不支持自动选择 sqlserver2012 ，只能使用 sqlserver ），用法和注意事项参考下面的场景五。

9. closeConn ：默认值为 true 。当使用运行时动态数据源或没有设置 helperDialect 属性自动获取数据库类型时，会自动获取一个数据库连接， 通过该属性来设置是否关闭获取的这个连接，默认 true 关闭，设置为
false 后，不会关闭获取的连接，这个参数的设置要根据自己选择的数据源来决定。

4、基本使用有6种，介绍最常用的两种

4.1、RowBounds方式的调用，了解

4.2、PageHelper.startPage 静态方法调用，重点

在你需要进行分页的 MyBatis 查询方法前调PageHelper.startPage 静态方法即可，紧跟在这个方法后的第一个MyBatis 查询方法会被进行分页。

PageHelper.startPage(1, 10); // 获取第1页，10条内容，默认查询总数count

service层

@Service
@Transactional
public class OrdersServiceImpl implements IOrdersService {

    @Autowired
    private IOrdersDao iOrdersDao;

    @Override
    public List<Orders> findAllByPage(Integer page, Integer pageSize) throws Exception {
        PageHelper.startPage(page, pageSize); // 这里加一个静态方法
        return iOrdersDao.findAll();
    }

    @Override
    public List<Orders> findAll() throws Exception {
        return iOrdersDao.findAll();
    }
}

controller层，就是将查到的完整list封装进PageInfo，辅助确定分页

@Controller
@RequestMapping("/orders")
public class OrdersController {
    @Autowired
    private IOrdersService ordersService;
    //未分页
    @RequestMapping("/findAll.do")
    public ModelAndView findAll(@RequestParam(name = "page", required = true, defaultValue =
            "1") Integer page, @RequestParam(name = "pageSize", required = true, defaultValue = "10")
                                        Integer pageSize) throws Exception {
        List<Orders> ordersList = ordersService.findAllByPage(page, pageSize);
        PageInfo pageInfo = new PageInfo(ordersList); // PageInfo里面有list
        //List<Orders> ordersList = ordersService.findAll(); // 原先不使用分页
        ModelAndView mv = new ModelAndView();
        mv.setViewName("orders-list");
        //mv.addObject("ordersList", ordersList);// 原先不使用分页
        mv.addObject("pageInfo", pageInfo);
        return mv;
    }
}

附一下实体类PageInfo源码

public class PageInfo<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    //当前页
    private int pageNum;
    //每页的数量
    private int pageSize;
    //当前页的数量
    private int size;

    //由于startRow和endRow不常用，这里说个具体的用法
    //可以在页面中"显示startRow到endRow 共size条数据"

    //当前页面第一个元素在数据库中的行号
    private int startRow;
    //当前页面最后一个元素在数据库中的行号
    private int endRow;
    //总记录数
    private long total;
    //总页数
    private int pages;
    //结果集
    private List<T> list;

    //前一页
    private int prePage;
    //下一页
    private int nextPage;

    //是否为第一页
    private boolean isFirstPage = false;
    //是否为最后一页
    private boolean isLastPage = false;
    //是否有前一页
    private boolean hasPreviousPage = false;
    //是否有下一页
    private boolean hasNextPage = false;
    //导航页码数
    private int navigatePages;
    //所有导航页号
    private int[] navigatepageNums;
    //导航条上的第一页
    private int navigateFirstPage;
    //导航条上的最后一页
    private int navigateLastPage;
    // 其余方法不附加了
}

二、Spring Security概述

Spring Security 的前身是 Acegi Security ，是 Spring 项目组中用来提供安全认证服务的框架。

安全包括两个主要操作：
1、认证，是为用户建立一个他所声明的主体。
	主体一般式指用户，设备或可以在你系 统中执行动作的其他系统。
2、授权，指的是一个用户能否在你的应用中执行某个操作，在到达授权判断之前，身份的主题已经由 身份验证过程建立了。

特别注意：
出现org.springframework.security.access.AccessDeniedException: Access is denied问题分析

<!--login-page表示初始登录页面，login-processing-url若存在必须和表单action一模一样-->
<security:form-login
                login-page="/login.jsp" 
                login-processing-url="/login.do"	
                default-target-url="/index.jsp"
                authentication-failure-url="/failer.jsp"
        />

<form action="${pageContext.request.contextPath}/login.do" method="post">

1、若spring-security.xml没有login-processing-url这一属性，故登录表单的action，必须为j_spring_secutity_check
2、若spring-security.xml中form-login有了login-processing-url属性，那么login-processing-url必须和jsp页面表单action属性值一模一样，否则拒绝拒绝拒绝

1、Spring Security快速入门

1.1、Maven依赖，实际主要依赖前两个，后面两个是有特殊功能需要才加入

<properties>      
	<spring.security.version>5.0.1.RELEASE</spring.security.version>
</properties>
<dependencies>
     <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-web</artifactId>	<!--spring security主要依赖-->
          <version>${spring.security.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-config</artifactId>	<!--spring security主要依赖-->
          <version>${spring.security.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-core</artifactId>
          <version>${spring.security.version}</version>
      </dependency>
      <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-taglibs</artifactId>	<!--spring security提供的权限标签，服务器端方法权限控制解释了-->
          <version>${spring.security.version}</version>
      </dependency>
</dependencies>

1.2、web.xml文件中创建filter

注意：关键在于filter-name名字为springSecurityFilterChain，不可修改

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:spring-security.xml</param-value>
</context-param>
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<filter>
	<filter-name>springSecurityFilterChain</filter-name>
	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
	<filter-name>springSecurityFilterChain</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

1.3、spring security配置核心文件spring-security.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:security="http://www.springframework.org/schema/security"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/security
	http://www.springframework.org/schema/security/spring-security.xsd">
	<!-- auto-config若为true会为我们创建一个默认的登录窗口（页面） -->
	<security:http auto-config="true" use-expressions="false">
		<!-- intercept-url定义一个过滤规则 
		pattern表示对哪些url进行权限控制，
		ccess属性表示在请求对应的URL时需要什么权限，
		默认配置时它应该是一个以逗号分隔的角色列表，请求的用户只需拥有其中的一个角色就能成功访问对应的URL -->
		<security:intercept-url pattern="/**" access="ROLE_USER" />
		<!-- auto-config配置后，不需要在配置下面信息
		 <security:form-login /> 定义登录表单信息
		<security:http-basic/> 
		<security:logout /> -->
	</security:http>
	<security:authentication-manager>
		<security:authentication-provider>
			<security:user-service>
				<security:user name="user" password="{noop}user"
				authorities="ROLE_USER" />
				<security:user name="admin" password="{noop}admin"
				authorities="ROLE_ADMIN" />
			</security:user-service>
		</security:authentication-provider>
	</security:authentication-manager>
</beans>

2、使用自定义登录页面

spring-security.xml配置，后续要注意下use-expressions
注意：跳转条件有区别，比如用户名存在，密码错误，但权限有
default-target-url，有账户，密码也对，可能权限不足
authentication-success-forward-url，有账户，密码也对，有权限
这里 authentication具体区别需要后面查

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:security="http://www.springframework.org/schema/security"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/security
	http://www.springframework.org/schema/security/spring-security.xsd">
	    <!-- 配置不拦截的资源 -->
	    <security:http pattern="/login.jsp" security="none"/>
	    <security:http pattern="/failer.jsp" security="none"/>
	    <security:http pattern="/css/**" security="none"/>
	    <security:http pattern="/img/**" security="none"/>
	    <security:http pattern="/plugins/**" security="none"/>
	
	<security:http auto-config="true" use-expressions="false">
		<!-- 配置资料连接，表示任意路径都需要ROLE_USER权限 -->
		<security:intercept-url pattern="/**" access="ROLE_USER" />
		<!-- 自定义登陆页面，
		login-page 自定义登陆页面 
		authentication-failure-url 用户权限校验失败之后才会跳转到这个页面，如果数据库中没有这个用户则不会跳转到这个页面。
		default-target-url 登陆成功后跳转的页面。 
		注：登陆页面用户名固定 username，密码password，action:login -->
		<security:form-login login-page="/login.html"
			login-processing-url="/login" 
			username-parameter="username"
			password-parameter="password" 
			authentication-failure-url="/failer.html"
			default-target-url="/success.html"
			authentication-success-forward-url="/failer.html"
		/>
		<!-- 登出， invalidate-session 是否删除session logout-url：登出处理链接 logout-successurl：登出成功页面
		注：登出操作 只需要链接到 logout即可登出当前用户 -->
		<security:logout invalidate-session="true" logout-url="/logout"
		logout-success-url="/login.jsp" />
		<!-- 关闭CSRF,默认是开启的 -->
		<security:csrf disabled="true" />
	</security:http>
	<security:authentication-manager>
		<security:authentication-provider>
			<security:user-service>
				<security:user name="user" password="{noop}user"
				authorities="ROLE_USER" />
				<security:user name="admin" password="{noop}admin"
				authorities="ROLE_ADMIN" />
			</security:user-service>
		</security:authentication-provider>
	</security:authentication-manager>
</beans>

3、Spring Security使用数据库认证

在Spring Security中如果想要使用数据进行认证操作，有很多种操作方式，这里我们介绍使用UserDetails、UserDetailsService来完成操作。
UserDetails源码，是接口

public interface UserDetails extends Serializable {
	Collection<? extends GrantedAuthority> getAuthorities();
	String getPassword();
	String getUsername();
	boolean isAccountNonExpired();	//帐户是否过期
	boolean isAccountNonLocked();	//帐户是否锁定
	boolean isCredentialsNonExpired();	//认证是否过期
	boolean isEnabled();	//帐户是否可用
}

UserDetails是一个接口，我们可以认为UserDetails作用是于封装当前进行认证的用户信息，但由于其是一个接口，所以我们可以对其进行实现，也可以使用Spring Security提供的一个UserDetails的实现类User来完成操作。
User类源码部分，注意是实现类

public class User implements UserDetails, CredentialsContainer {

	private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

	// ~ Instance fields
	// ================================================================================================
	private String password;
	private final String username;
	private final Set<GrantedAuthority> authorities;
	private final boolean accountNonExpired;
	private final boolean accountNonLocked;
	private final boolean credentialsNonExpired;
	private final boolean enabled;
	// 其余不附上了
}

UserDetailsService源码，是接口，UserDetailsService把方法都定义好了

public interface UserDetailsService {
	UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

这里很重要，“ROLE_” + role.getRoleName()

public interface IUserService extends UserDetailsService {
}

@Service("userService")
@Transactional
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserDao userDao;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        UserInfo userInfo = userDao.findByUsername(username);
        List<Role> roles = userInfo.getRoles();
        List<SimpleGrantedAuthority> authoritys = getAuthority(roles);
        User user = new User(userInfo.getUsername(), "{noop}" + userInfo.getPassword(),
                userInfo.getStatus() == 0 ? false : true, true, true, true, authoritys); //这里userInfo的status是表示用户是否已开启，应该是类似激活意思
        return user;
    }

    private List<SimpleGrantedAuthority> getAuthority(List<Role> roles) {
        List<SimpleGrantedAuthority> authoritys = new ArrayList();
        for (Role role : roles) {
            //authoritys.add(new SimpleGrantedAuthority(role.getRoleName())); //当前代码验证一次就失效了或者说本身代码就有问题
            authoritys.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleName())); //这样才能一次登录除非主动退出，能一直访问其他页面
        }
        return authoritys;
    }
}

xml配置
注意：前面创建使用了"{noop}" + userInfo.getPassword()，那么就不需要加密方式，xml中就要把加密方式注释掉，否则反而验证通不过

<security:authentication-manager>
	<security:authentication-provider user-service-ref="userService">
	<!-- 配置加密的方式
	<security:password-encoder ref="passwordEncoder"/>
	-->
	</security:authentication-provider>
</security:authentication-manager>

三、服务器端方法级权限控制

在服务器端我们可以通过Spring security提供的注解对方法来进行权限控制。Spring Security在方法的权限控制上支持三种类型的注解：
JSR-250注解、@Secured注解和支持表达式的注解，
这三种注解默认都是没有启用的，需要单独通过global-method-security元素的对应属性进行启用

1、开启注解使用，3种选择

1.1、spring-security.xml配置文件，选择一种即可

<security:global-method-security jsr250-annotations=“enabled”/>
<security:global-method-security secured-annotations=“enabled”/>
<security:global-method-security pre-post-annotations=“enabled”/>

1.2、注解开启，这里没看懂，后续了解再补充

@EnableGlobalMethodSecurity ：
Spring Security默认是禁用注解的，要想开启注解，需要在继承
WebSecurityConfigurerAdapter的类上加@EnableGlobalMethodSecurity注解，并在该类中将AuthenticationManager定义为Bean

2、JSR-250注解

2.1、@RolesAllowed表示访问对应方法时所应该具有的角色，常用

@RolesAllowed({“USER”, “ADMIN”}) 该方法只要具有"USER", "ADMIN"任意一种权限就可以访问。
这里可以省略前缀ROLE_，实际的权限可能是ROLE_ADMIN，已验证加上前缀也可以做到权限控制
pom.xml导入依赖jsr250

        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
        </dependency>

注意看下面findAll()上的@RolesAllowed(“ADMIN”)注解

@Controller
@RequestMapping("/product")
public class ProductController {

    @Autowired
    private IProductService productService;
    
    @RequestMapping("/findAll.do")
    @RolesAllowed("ADMIN")
    public ModelAndView findAll() throws Exception {
        ModelAndView mv = new ModelAndView();
        List<Product> ps = productService.findAll();
        mv.addObject("productList", ps);
        mv.setViewName("product-list");
        return mv;
    }
}

若非授予的角色权限，refuse，403错误

web.xml可以设置权限不足403跳转页面，代替上面图片中的提示，人性化一些

    <!--权限不足403跳转页面-->
    <error-page>
        <error-code>403</error-code>
        <location>/403.jsp</location>
    </error-page>

2.2、@PermitAll表示允许所有的角色进行访问，也就是说不进行权限控制

2.3、@DenyAll是和PermitAll相反的，表示无论什么角色都不能访问

3、@Secured注解

注意：
区别于使用@Secured，@Secured对应的角色必须要有ROLE_前缀，否则权限控制失效，即权限不足
@Secured注解标注的方法进行权限控制的支持，其值默认为disabled
@Secured(“IS_AUTHENTICATED_ANONYMOUSLY”)，意思就是放行，不需要权限
@Secured(“ROLE_ADMIN”)这个给方法加权限

下面简单看一下就行

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
public Account readAccount(Long id);
@Secured("ROLE_TELLER")

4、支持表达式的注解，详细使用查文档

4.1、@PreAuthorize 在方法调用之前,基于表达式的计算结果来限制对方法的访问，重点掌握

注意：principal是一个object对象

@PreAuthorize("#userId == authentication.principal.userId or hasAuthority(‘ADMIN’)")

@PreAuthorize("authentication.principal.username == 'tom' ")

@PreAuthorize("hasRole('ROLE_ADMIN')")

这里表示在changePassword方法执行之前，判断方法参数userId的值是否等于principal中保存的当前用户的
userId，或者当前用户是否具有ROLE_ADMIN权限，两种符合其一，就可以访问该方法。

4.2、@PostAuthorize 允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异常

@PostAuthorize
User getUser("returnObject.userId == authentication.principal.userId or hasPermission(returnObject, 'ADMIN')");

4.3、@PostFilter 允许方法调用,但必须按照表达式来过滤方法的结果

4.4、@PreFilter 允许方法调用,但必须在进入方法之前过滤输入值

四、页面端标签控制权限

1、spring-security.xml配置

<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-taglibs</artifactId>
	<version>version</version>
</dependency>

2、页面导入

<%@taglib uri="http://www.springframework.org/security/tags" prefix="security"%>

3、常用标签，jsp页面

在jsp中我们可以使用以下三种标签，
其中authentication代表的是当前认证对象，可以获取当前认证对象信息，例如用户名。
其它两个标签我们可以用于权限控制

3.1、authentication，可以获取当前正在操作的用户信息

<security:authentication property="" htmlEscape="" scope="" var=""/>

1、property： 只允许指定Authentication所拥有的属性，可以进行属性的级联获取，如“principal.username”，不允许直接通过方法进行调用，注意principal要写对了
2、htmlEscape：表示是否需要将html进行转义。默认为true。
3、scope：与var属性一起使用，用于指定存放获取的结果的属性名的作用范围，默认我pageContext。Jsp中拥有的作用范围都进行进行指定
4、var： 用于指定一个属性名，这样当获取到了authentication的相关信息后会将其以var指定的属性名进行存放，默认是存放在pageConext中

3.2、authorize，用户控制页面上某些标签是否可以显示，使用方式是jsp内使用authorize与xml配置中改动

authorize是用来判断普通权限的，通过判断用户是否具有对应的权限而控制其所包含内容的显示

<security:authorize access="" method="" url="" var=""></security:authorize>

1、access： 需要使用表达式来判断权限，当表达式的返回结果为true时表示拥有对应的权限
3、method：method属性是配合url属性一起使用的，表示用户应当具有指定url指定method访问的权限，
method的默认值为GET，可选值为http请求的7种方法
3、url：url表示如果用户拥有访问指定url的权限即表示可以显示authorize标签包含的内容
4、var：用于指定将权限鉴定的结果存放在pageContext的哪个属性中

简单摘取一段jsp内代码理解

<security:authorize access="hasRole('ROLE_ADMIN')">
                        <a href="${pageContext.request.contextPath}/user/findAll.do"> <i
							class="fa fa-circle-o"></i> 用户管理</a>
</security:authorize>
</li>

注意：2种处理方式
1、使用了authorize ，spring-security.xml配置中要将use-expressions设为true，access=“hasAnyRole(‘ROLE_USER’, ‘ROLE_ADMIN’)”，改变以上两个小地方

<!--<security:http auto-config="true" use-expressions="false">
    <security:intercept-url pattern="/**" access="ROLE_USER,ROLE_ADMIN"/>-->
   <security:http auto-config="true" use-expressions="true">
       <!-- 配置具体的拦截的规则 pattern="请求路径的规则" access="访问系统的人，必须有ROLE_USER的角色" -->
       <security:intercept-url pattern="/**" access="hasAnyRole('ROLE_USER', 'ROLE_ADMIN')"/>
       <!-- 其他的不变-->
       <!-- 定义跳转的具体的页面 -->
       <!-- 关闭跨域请求 -->
       <!-- 退出-->
   </security:http>

2、可以不改变以上两个地方，只要配置一个webSecurityExpressionHandler的bean

<bean id="webSecurityExpressionHandler" class="org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler"/>

3.3、accesscontrollist

accesscontrollist标签是用于鉴定ACL权限的。其一共定义了三个属性：hasPermission、domainObject和var，其中前两个是必须指定的

<security:accesscontrollist hasPermission="" domainObject="" var=""></security:accesscontrollist>

1、hasPermission：hasPermission属性用于指定以逗号分隔的权限列表
3、domainObject：domainObject用于指定对应的域对象
3、var：var则是用以将鉴定的结果以指定的属性名存入pageContext中，以供同一页面的其它地方使用

五、SSMAOP日志，待后补