SpringSecurity-Before

SpringSecurity概述

1.SpringSecurity介绍

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

(https://projects.spring.io/spring-security/) Spring Security 为基于J2EE企业应用软件提供了全面安全服务。特别是使用领先的J2EE解决方案-Spring框架开发的企业软件项目。人们使用Spring Security有很多种原因，不过通常吸引他们的是在J2EE Servlet规范或EJB规范中找不到典型企业应用场景的解决方案。 特别要指出的是他们不能再WAR 或 EAR 级别进行移植。这样，如果你更换服务器环境，就要，在新的目标环境进行大量的工作，对你的应用系统进行重新配 置安全。使用Spring Security 解决了这些问题，也为你提供很多有用的，完全可以指定的其他安全特性。 安全包括两个主要操作。

• “认证”，是为用户建立一个他所声明的主体。主题一般式指用户，设备或可以在你系 统中执行动作的其他系统。（用户登录）
• “授权” 指的是一个用户能否在你的应用中执行某个操作，在到达授权判断之前，身份的主题已经由 身份验证过程建立了。（具有某个权限才能执行某个操作）

这些概念是通用的，不是Spring Security特有的。在身份验证层面，Spring Security广泛支持各种身份验证模式，这些验证模型绝大多数都由第三方提供，或则正在开发的有关标准机构提供的，例如 Internet Engineering TaskForce.作为补充，Spring Security 也提供了自己的一套验证功能。

Spring Security 目前支持认证一体化如下认证技术： HTTP BASIC authentication headers (一个基于IEFT RFC 的标准) HTTP Digest authentication headers (一个基于IEFT RFC 的标准) HTTP X.509 client certificate exchange(一个基于IEFT RFC 的标准) LDAP (一个非常常见的跨平台认证需要做法，特别是在大环境) Form-basedauthentication (提供简单用户接口的需求) OpenID authentication Computer Associates Siteminder JA-SIGCentral Authentication Service (CAS，这是一个流行的开源单点登录系统) Transparent authentication contextpropagation for Remote Method Invocation and HttpInvoker (一个Spring远程调用协议)

Maven依赖

<dependencies> 
	<dependency> 
		<groupId>org.springframework.security</groupId> 
		<artifactId>spring-security-web</artifactId> 
		<version>5.0.1.RELEASE</version> 
	</dependency> 
    <dependency> 
   		<groupId>org.springframework.security</groupId> 
   		<artifactId>spring-security-config</artifactId> 
   		<version>5.0.1.RELEASE</version> 
   	</dependency> 
</dependencies>

Spring Security快速入门

1.pom.xml导入依赖

<properties>
	<spring.version>5.0.2.RELEASE</spring.version>
	<spring.security.version>5.0.1.RELEASE</spring.security.version>
</properties>

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-web</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context-support</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jdbc</artifactId>
		<version>${spring.version}</version>
	</dependency>
	
	<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-web</artifactId>
		<version>${spring.security.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-config</artifactId>
		<version>${spring.security.version}</version>
	</dependency>
	<dependency>
		<groupId>javax.servlet</groupId>
		<artifactId>javax.servlet-api</artifactId>
		<version>3.1.0</version>
		<scope>provided</scope>
	</dependency>
</dependencies>

<build>
	<plugins>
		<!-- java编译插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.2</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.tomcat.maven</groupId>
			<artifactId>tomcat7-maven-plugin</artifactId>
			<configuration>
				<!-- 指定端口 -->
				<port>8090</port>
				<!-- 请求路径 -->
				<path>/</path>
			</configuration>
		</plugin>
	</plugins>
</build>

2.web.xml

<!--配置监听器架子加载springsecurity框架配置文件-->
<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>

<!--配置springsecurity过滤器-->
<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>

3.使用Spring Security自带的页面

1.使用Spring Security自带的页面图解

2.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"	不用自己编写登录的页面，框架提供默认登录页面
        use-expressions="false"	是否使用SPEL表达式（没学习过）
    -->
    <security:http auto-config="true" use-expressions="false">
        <!-- intercept-url定义一个过滤规则 pattern表示对哪些url进行权限控制，access属性表示在请求对应的URL时需要什么权限，
             默认配置时它应该是一个以逗号分隔的角色列表，请求的用户只需拥有其中的一个角色就能成功访问对应 的URL -->
        <security:intercept-url pattern="/**" access="ROLE_USER"/>
        <!-- auto-config配置为true后，不需要在配置下面信息
            定义登录表单信息
            <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>

3.测试

当我们访问index.html页面时发现会弹出登录窗口，可能会奇怪，我没有建立下面的登录页面，为什么SpringSecurity会跳到上面的登录页面呢？这是我们设置http的auto-config=”true”时Spring Security自动为生成的。

4.使用自定义的页面

1.使用自定义的页面图解

2.准备页面

login.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Insert title here</title></head>
<body>
<form action="login" method="post">
    <table>
        <tr>
            <td>用户名：</td>
            <td><input type="text" name="username"/></td>
        </tr>
        <tr>
            <td>密码：</td>
            <td><input type="password" name="password"/></td>
        </tr>
        <tr>
            <td colspan="2" align="center"><input type="submit" value="登录"/> <input type="reset" value="重置"/></td>
        </tr>
    </table>
</form>
</body>
</html>

success.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Insert title here</title></head>
<body> success html<br> <a href="logout">退出</a></body>
</html>

failer.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Insert title here</title></head>
<body>登录失败</body>
</html>

3.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">
    <!-- 配置不过滤的资源（静态资源及登录相关） -->
    <security:http security="none" pattern="/login.html"/>
    <security:http security="none" pattern="/failer.html"/>

      <!--
        配置具体的规则
        auto-config="true"	不用自己编写登录的页面，框架提供默认登录页面
        use-expressions="false"	是否使用SPEL表达式（没学习过）
    -->
    <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 登陆成功后跳转的页面。（或者使用authentication-success-forward-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"/>
        <!-- 登出(退出)，
             invalidate-session 是否删除session
             logout-url：登出(退出)处理链接
             logout-success- url：登出(退出)成功页面注：登出操作 只需要链接到 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>

4.测试

Spring Security使用数据库认证方式

上面的认证方式使用的用户名和密码，都是在配置文件中的，现在是用户名和密码在数据库中。
在Spring Security中如果想要使用数据进行认证操作，有很多种操作方式，这里介绍使用UserDetails（用户实体类）、
UserDetailsService（用户登录service）来完成操作。

• 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 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

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

上面将UserDetails与UserDetailsService做了一个简单的介绍，那么具体如何完成Spring Security的数据库认证操作，通过用户管理中用户登录来完成Spring Security的认证操作。

1.用户管理

1.springsecurity环境

1.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">
    
    <!-- 配置不拦截的资源 -->
    <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"/> 
    
    <!-- 
    	配置具体的规则 
    	auto-config="true"	不用自己编写登录的页面，框架提供默认登录页面
    	use-expressions="false"	是否使用SPEL表达式（没学习过）
    -->
    <security:http auto-config="true" use-expressions="false">
    	<!-- 配置具体的拦截的规则 pattern="请求路径的规则" access="访问系统的人，必须有ROLE_USER的角色" -->
    	<security:intercept-url pattern="/**" access="ROLE_USER,ROLE_ADMIN"/>
    	<!-- 定义跳转的具体的页面 -->
    	<security:form-login  
    		login-page="/login.jsp"
    		login-processing-url="/login.do"
    		default-target-url="/index.jsp"
    		authentication-failure-url="/failer.jsp"/>
    	<!-- 关闭跨域请求 -->
    	<security:csrf disabled="true"/>
    	<!-- 退出 -->
    	<security:logout invalidate-session="true" logout-url="/logout.do" logout-success-url="/login.jsp" />
    </security:http>
    
    <!-- 切换成数据库中的用户名和密码 -->
    <security:authentication-manager>
    	<security:authentication-provider user-service-ref="userService">
    		<!-- 配置解密的方式 -->
    		<security:password-encoder ref="passwordEncoder"/>
    	</security:authentication-provider>
    </security:authentication-manager>
    
    <!-- 配置加密和解密类 -->
    <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>
    
    <!-- 提供了入门的方式，在内存中存入用户名和密码 
    <security:authentication-manager>
    	<security:authentication-provider>
    		<security:user-service>
    			<security:user name="admin" password="{noop}admin" authorities="ROLE_USER"/>
    		</security:user-service>
    	</security:authentication-provider>
    </security:authentication-manager>
    -->
</beans>    

2.web.xml

<!--配置监听器加载springsecurity框架配置文件-->
<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>

<!--配置springsecurity过滤器-->
<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>

2.用户登录

1.登录页面login.jsp

2.在spring-security.xml文件加入加密和解密配置

<!-- 切换成数据库中的用户名和密码 -->
<security:authentication-manager>
	<security:authentication-provider user-service-ref="userService">
		<!-- 配置解密的方式 -->
		<security:password-encoder ref="passwordEncoder"/>
	</security:authentication-provider>
</security:authentication-manager>

<!-- 配置加密和解密类 -->
<bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

2.Service

UserDetailsService

public interface IUserService extends UserDetailsService{

}

UserServiceImpl

/**
 * UserServiceImpls实现类间接继承springsecurity框架的UserDetailsService接口
 */
@Service("userService")
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserDao userDao;

    @Autowired
    private BCryptPasswordEncoder bcpe; //注入二次加密类(当然也可以提取一个工具类)

    /**
     * 用户登录功能版本1.0没有进行二次加密
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    /*@Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名查询用户
        UserInfo userInfo = userDao.findByUsername(username);
        // 将查询出用户中的角色添加到 SimpleGrantedAuthority 类中
        List<SimpleGrantedAuthority> sgas = getAuthorities(userInfo.getRoles());
        // 将封装的 user 返回，底层会比较用户和密码。
        // 因为密码是明文的所以要{noop}前缀才能访问。
        return new User(userInfo.getUsername(), "{noop}" + userInfo.getPassword(), sgas);
    }*/

    /**
     * 用户登录功能版本2.0对输入密码进行二次加密（这是错误的登录时不用加密）
     *
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    /*@Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名查询用户
        UserInfo userInfo = userDao.findByUsername(username);
        //将加密后的密码重新设置到用户中
        userInfo.setPassword(bcpe.encode(userInfo.getPassword()));
        // 将查询出用户中的角色添加到 SimpleGrantedAuthority 类中
        List<SimpleGrantedAuthority> sgas = getAuthorities(userInfo.getRoles());
        // 将封装的 user 返回，底层会比较用户和密码。
        // 因为密码已经进行二次加密{noop}前缀就可以不用写了。
        return new User(userInfo.getUsername(),userInfo.getPassword(),sgas);
    }*/

    /**
     * 用户登录功能版本3.0判断账户是否启用，启用后才能登录。
     *
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名查询用户
        UserInfo userInfo = userDao.findByUsername(username);
        // 将查询出用户中的角色添加到 SimpleGrantedAuthority 类中
        List<SimpleGrantedAuthority> sgas = getAuthorities(userInfo.getRoles());
        // 将封装的 user 返回，底层会比较用户和密码。
        // 因为密码已经进行二次加密{noop}前缀就可以不用写了。
        return new User(userInfo.getUsername(), userInfo.getPassword(),
               userInfo.getStatus()==0 ? false:true,true, true, true, sgas);
    }

    /**
     * 将查询的用户中的角色添加到 SimpleGrantedAuthority 类中
     *
     * @param roles
     * @return
     */
    private List<SimpleGrantedAuthority> getAuthorities(List<Role> roles) {
        List<SimpleGrantedAuthority> sgas = new ArrayList<>();
        for (Role role : roles) {
            //将用户中的角色拼接上 "ROLE_" 添加到 SimpleGrantedAuthority 类中
            sgas.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleName()));
        }
        return sgas;
    }
}    

3.dao

 /**
  * 根据用户名查询用户
  *
  * @param username
  * @return
  */
 @Select(" select * from users where username = #{username} ")
 @Results(id = "usersMap", value = {
         @Result(id = true, property = "id", column = "id"),
         @Result(property = "username", column = "username"),
         @Result(property = "email", column = "email"),
         @Result(property = "password", column = "password"),
         @Result(property = "phoneNum", column = "phoneNum"),
         @Result(property = "status", column = "status"),
         @Result(property = "roles", column = "id", many = @Many(select = "com.ginger.wlfl.dao.IRoleDao.findByUserId"))
 })
public UserInfo findByUsername(String username);

3.用户退出

使用spring security完成用户退出，非常简单

1.在spring-security.xml文件加入以下配置

<security:logout invalidate-session="true" logout-url="/logout.do" logout-success- url="/login.jsp" />

2.页面中

<a href="${pageContext.request.contextPath}/logout.do" class="btn btn-default btn-flat">注销</a>

4.用户查询

1.用户查询页面 user-list.jsp

2.UserController

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    IUserService userService;

    /**
     * 查询所有用户
     *
     * @return
     */
    @RequestMapping("/findAll.do")
    public ModelAndView findAll() {
        ModelAndView mav = new ModelAndView();
        List<UserInfo> userInfos = userService.findAll();
        mav.addObject("userInfos", userInfos);
        mav.setViewName("user-list");
        return mav;
    }
}

3.Dao

/**
 * 查询所有用户
 *
 * @return
 */
@Select(" select * from users ")
public List<UserInfo> findAll();

5.用户添加

1.用户添加页面 user-add.jsp

2.UserController

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    IUserService userService;
    
    /**
     * 保存用户
     *
     * @param userInfo
     * @return
     */
    @RequestMapping("/save.do")
    public String saveUserInfo(UserInfo userInfo) {
        userService.saveUserInfo(userInfo);
        return "redirect:findAll.do";
    }
}

3.Service

/**
 * UserServiceImpls实现类间接继承springsecurity框架的UserDetailsService接口
 */
@Service("userService")
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserDao userDao;

    @Autowired
    private BCryptPasswordEncoder bcpe; //注入二次加密类(当然也可以提取一个工具类)

    @Override
    public void saveUserInfo(UserInfo userInfo) {
        //保存用户对密码进行二次加密
        userInfo.setPassword(bcpe.encode(userInfo.getPassword()));
        userDao.saveUserInfo(userInfo);
    }
}    

4.dao

/**
 * 保存用户
 *
 * @param userInfo
 */
@Insert(" insert into users (email,username,password,phonenum,status) " +
        " values (#{email},#{username},#{password},#{phoneNum},#{status}) ")
public void saveUserInfo(UserInfo userInfo);

6.用户详情

1.用户详情页面user-show.jsp

2.UserController

@Controller
@RequestMapping("/user")
public class UserController {
 	/**
     * 根据id查询用户
     *
     * @param userId
     * @return
     */
    @RequestMapping("/findById.do")
    public ModelAndView findById(@RequestParam(name = "id") String userId) {
        ModelAndView mav = new ModelAndView();
        UserInfo userInfo = userService.findById(userId);
        mav.addObject("userInfo", userInfo);
        mav.setViewName("user-show");
        return mav;
    }
}

3.dao

/**
 * 根据id查询用户
 *
 * @param userId
 * @return
 */
 @Select(" select * from users where id = #{userId} ")
 @ResultMap("usersMap")
 public UserInfo findById(String userId);


/**
 * 根据用户id查询角色
 *
 * @param userId
 * @return
 */
@Select(" select * " +
        " from role " +
        " where id in ( " +
        " select roleid " +
        " from users_role " +
        " where userid = #{userId} " +
        " ) ")
@Results(id = "roleMap", value = {
        @Result(id = true, property = "id", column = "id"),
        @Result(property = "roleName", column = "roleName"),
        @Result(property = "roleDesc", column = "roleDesc"),
        @Result(property = "permissions", column = "id", many = @Many(select = "com.ginger.wlfl.dao.IPermissionDao.findByRoleId")),
        @Result(property = "users", column = "id", many = @Many(select = "com.ginger.wlfl.dao.IUserDao.findByRoleId"))
})
public List<Role> findByUserId(String userId);

服务器端方法级权限控制

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

1.开启注解使用

• 配置文件
  <security:global-method-security jsr250-annotations=“enabled”/>
  <security:global-method-security secured-annotations=“enabled”/>
  <security:global-method-security pre-post-annotations=“disabled”/>
• 注解开启
  @EnableGlobalMethodSecurity ：Spring Security默认是禁用注解的，要想开启注解，需要在继承
  WebSecurityConfigurerAdapter的类上加@EnableGlobalMethodSecurity注解，并在该类中将
  AuthenticationManager定义为Bean。

2.JSR-250注解

1.JSR-250注解使用图解

• @RolesAllowed表示访问对应方法时所应该具有的角色
  示例： @RolesAllowed({“USER”, “ADMIN”}) 该方法只要具有"USER", "ADMIN"任意一种权限就可以访问。这里可以省 略前缀ROLE_，实际的权限可能是ROLE_ADMIN。
• @PermitAll表示允许所有的角色进行访问，也就是说不进行权限控制
• @DenyAll是和PermitAll相反的，表示无论什么角色都不能访问

3.支持表达式的注解（SPEL表达式）

1.Spring EL表达式

Spring Security允许我们在定义URL访问或方法访问所应有的权限时使用Spring EL表达式，在定义所需的访问权限时如果对应的表达式返回结果为true则表示拥有对应的权限，反之则无。Spring Security可用表达式对象的基类是SecurityExpressionRoot，其为我们提供了如下在使用Spring EL表达式对URL或方法进行权限控制时通用的内置表达式。

表达式	描述
hasRole([role])	当前用户是否拥有指定角色
hasAnyRole([role1,role2])	多个角色是一个以逗号进行分隔的字符串。如果当前用户拥有指定角色中的任意一个则返回true
hasAuthority([auth])	等同于hasRole
hasAnyAuthority([auth1,auth2])	等同于hasAnyRole
Principle	代表当前用户的principle对象
authentication	直接从SecurityContext获取的当前Authentication对象
permitAll	总是返回true，表示允许所有的
denyAll	总是返回false，表示拒绝所有的
isAnonymous()	当前用户是否是一个匿名用户
isRememberMe()	表示当前用户是否是通过Remember-Me自动登录的
isAuthenticated()	表示当前用户是否已经登录认证成功了
isFullyAuthenticated()	如果当前用户既不是一个匿名用户，同时又不是通过Remember-Me自动登录的，则返回true

2.支持表达式的注解使用图解

• @PreAuthorize 在方法调用之前,基于表达式的计算结果来限制对方法的访问
  示例： @PreAuthorize("#userId == authentication.principal.userId or hasAuthority(‘ADMIN’)") void changePassword(@P(“userId”) long userId ){ } 这里表示在changePassword方法执行之前，判断方法参数userId的值是否等于principal中保存的当前用户的 userId，或者当前用户是否具有ROLE_ADMIN权限，两种符合其一，就可以访问该方法。

• @PostAuthorize 允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异常
  示例： @PostAuthorize User getUser(“returnObject.userId == authentication.principal.userId or hasPermission(returnObject, ‘ADMIN’)”);

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

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

4.@Secured注解

1.@Secured注解使用图解

• @Secured注解标注的方法进行权限控制的支持，其值默认为disabled
  示例：@Secured(“IS_AUTHENTICATED_ANONYMOUSLY”) public Account readAccount(Long id); @Secured(“ROLE_TELLER”)

页面端标签控制权限

在jsp页面中也可以使用spring security提供的权限标签来进行权限控制

1.页面端标签控制权限使用图解

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

2.导入

1.导入坐标

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

2.页面导入

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

3.常用标签

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

1.authentication

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

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

2.authorize

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

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

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

3.accesscontrollist

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

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

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