Spring Security 权限控制
Posted java小皮皮
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring Security 权限控制相关的知识，希望对你有一定的参考价值。
日积月累，水滴石穿 😄
前言
| 项目 | 版本 |
|---|---|
| Boot | 2.3.12.RELEASE |
| Security | 5.3.9.RELEASE |
在前面的文章中，所有的接口只需要登录就能访问。并没有对每个接口进行权限限制。 在正式的系统中，一个用户会拥有一个或者多个角色，而不同的角色会拥有不同的接口权限。如果要实现这些功能，需要重写WebSecurityConfigurerAdapter 中的configure(HttpSecurity http)。HttpSecurity 用于构建一个安全过滤器链 SecurityFilterChain，可以通过它来进行自定义安全访问策略。
配置如下：
@Bean
PasswordEncoder passwordEncoder()
return NoOpPasswordEncoder.getInstance();
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception
auth.inMemoryAuthentication()
.withUser("cxyxj")
.password("123").roles("admin", "user")
.and()
.withUser("security")
.password("security").roles("user");
@Override
protected void configure(HttpSecurity http) throws Exception
http.authorizeRequests() //开启配置
.antMatchers("/cxyxj/**").hasRole("admin") //访问/cxyxj/**下的路径，必须具备admin身份
.antMatchers("/security/**").hasRole("user") //访问/security/**下的路径，必须具备user身份
.antMatchers("/permitAll").permitAll() // 访问/permitAll路径，不需要登录
.anyRequest() //其他请求
.authenticated()//验证 表示其他请求只需要登录就能访问
.and()
.formLogin(); // 开启表单登陆
复制代码上述配置含义如下：
antMatchers("/cxyxj/**").hasRole("admin")：表示访问/cxyxj/路径的必须要有 admin 角色。antMatchers("/security/**").hasRole("user")：表示访问/security/路径的必须要有 user 角色。.antMatchers("/permitAll").permitAll()：表示访问/permitAll 路径不需要认证.anyRequest().authenticated()：表示除了前面定义的url，其余url访问都得认证后才能访问（登录）- and：表示结束当前标签，回到上下文 HttpSecurity，开启新一轮的配置
- formLogin：开启表单登陆
根据上述的配置，我们新增三个接口，代码如下：
@GetMapping("/hello")
public String hello()
return "你好 Spring Security";
@GetMapping("/cxyxj/hello")
public String cxyxj()
return "cxyxj 你好 Spring Security";
@GetMapping("/security/hello")
public String user()
return "user 你好 Spring Security";
@GetMapping("/permitAll")
public String permitAll()
return "permitAll 你好 Spring Security";
复制代码按照我们的配置，permitAll接口不需要登录就能访问，cxyxj接口只有admin角色才能访问，security接口admin角色和user角色都能访问，而 hello接口登录就能访问！
这里就不演示了，各位可以将上述代码 copy 到本地运行一下。
授权方式
授权的方式包括 web授权 和 方法授权，web授权是通过 url 拦截进行授权，方法授权是通过方法拦截进行授权。他们都会使用 AccessDecisionManager接口进行授权决策。若为web授权则拦截器为 FilterSecurityInterceptor；若为方法授权则拦截器为MethodSecurityInterceptor。如果同时使用 web 授权和方法授权，则先执行web授权，再执行方法授权，最后决策都通过，则允许访问资源，否则将禁止访问。 文章开头使用的方式就是 web授权方式。
- FilterSecurityInterceptor：底层是 Filter。
- MethodSecurityInterceptor：底层是 AOP。
web授权
Spring Security 可以通过 http.authorizeRequests() 开启对 web 请求进行授权保护。
http.formLogin();
http.authorizeRequests()
.antMatchers("/permitAll").permitAll() // 访问/permitAll路径，不需要认证
.anyRequest() //其他请求
.authenticated(); //需要认证才能访问
复制代码url匹配
antMatchers()
方法定义如下：
antMatchers(String... antPatterns)
复制代码参数是可变长参数，每个参数是一个 ant 表达式，用于匹配 URL规则。
ANT通配符有三种：
| 通配符 | 说明 |
|---|---|
| ? | 匹配任何单字符 |
| * | 匹配0个或者任意数量的字符 |
| ** | 匹配0个或者任意目录 |
// 访问 /cxyxj/** 路径，任意目录下 .js 文件 可以直接访问
.antMatchers("/cxyxj/**","/**/*.js").permitAll()
复制代码使用 antMatchers 方法需要注意配置规则的顺序，配置顺序会影响授权的效果，越是具体的应该放在前面，越是笼统的应该放到后面。
如下错误示例：
.antMatchers("/cxyxj/**").hasRole("ADMIN")
.antMatchers("/cxyxj/login").permitAll()
复制代码如上配置会导致访问/cxyxj/login接口时需要拥有ADMIN角色才能访问。
regexMatchers
使用正则表达式进行匹配。
//所有以.js 结尾的文件都被放行
.regexMatchers( ".+[.]js").permitAll()
复制代码无论是 antMatchers() 还是 regexMatchers() 都具有两个参数的方法，其中第一个参数都是 HttpMethod ，表示请求方式，当设置了 HttpMethod 后表示只有设定的请求方式才执行对应的权限验证。
.antMatchers(HttpMethod.GET,"/cxyxj/hello").permitAll()
.regexMatchers(HttpMethod.GET,".+[.]jpg").permitAll()
复制代码anyRequest
匹配所有的请求。该方法一般会放在最后。结合 authenticated使用，表示所有请求需要认证才能访问。
.anyRequest().authenticated()
复制代码mvcMatchers
适用于配置了 mvcServletPath 的情况。 mvcServletPath 就是所有的 URL 的统一前缀。在 application.properties 中添加下面内容。
spring.mvc.servlet.path= /role
复制代码- 正例
.mvcMatchers("/cxyxj/**").servletPath("/role").permitAll()
复制代码- 反例
.mvcMatchers("/role/cxyxj/**").permitAll()
复制代码如果不想使用 mvcMatchers() 也可以使用 antMatchers()。
.antMatchers("/role/cxyxj/**").permitAll()
复制代码如果你在项目中还配置了项目根路径。
server.servlet.context-path=/ctx-path
复制代码在SecurityConfig中不需要理会，你只需要修改你的请求接口路径。
- 配置
.mvcMatchers("/cxyxj/**").servletPath("/role").permitAll()
复制代码- 请求接口路径
http://localhost:8080/ctx-path/role/cxyxj/hello
复制代码调试完成之后请将properties文件的配置进行注释！以下示例代码不使用配置文件。
RequestMatcher接口
上述的几种匹配方式都是 RequestMatcher 接口的子实现。 接口定义了matches方法，方法如果返回 true 表示提供的请求与提供的匹配规则匹配，如果返回的是 false 则不匹配。 Spring Security 内置提供了一些 RequestMatcher 实现类：
内置操作
上文只是将请求接口路径与配置的规则进行匹配，那匹配成功之后应该进行什么操作呢？Spring Security 内置了一些控制操作。
- permitAll() 方法，所有用户可访问。
- denyAll() 方法，所有用户不可访问。
- authenticated() 方法，登录用户可访问。
- anonymous() 方法，匿名用户可访问。
- rememberMe() 方法，通过 remember me 登录的用户可访问。
- fullyAuthenticated() 方法，非 remember me 登录的用户可访问。
- hasIpAddress(String ipaddressExpression) 方法，来自指定 IP 表达式的用户可访问。
- hasRole(String role) 方法， 拥有指定角色的用户可访问，传入的角色将被自动增加 “ROLE_” 前缀。
- hasAnyRole(String... roles) 方法，拥有指定任意角色的用户可访问。传入的角色将被自动增加 “ROLE_” 前缀。
- hasAuthority(String authority) 方法，拥有指定权限( authority )的用户可访问。
- hasAuthority(String... authorities) 方法，拥有指定任意权限( authority )的用户可访问。
- access(String attribute) 方法，上面所有方法的底层实现，当 Spring EL 表达式的执行结果为 true 时，可以访问。 使用用法如下：
// 如果用户具备 admin 权限，就允许访问。
.antMatchers("/cxyxj/**").hasAuthority("admin")
// 如果用户具备给定权限中某一个，就允许访问。
.antMatchers("/admin/demo").hasAnyAuthority("admin","System")
// 如果用户具备 user 权限，就允许访问。注意不需要手动写 ROLE_ 前缀，写了会报错
.antMatchers("/security/**").hasRole("user")
//如果请求是指定的 IP 就允许访问。
.antMatchers("/admin/demo").hasIpAddress("192.168.64.5")
复制代码这里单独介绍一下 access(表达式）。表达式的基类是SecurityExpressionRoot，提供了一些在web和方法安全性中都可用的通用表达式，如下：
| 表达式 | 描述 |
|---|---|
| hasRole(String role) | 当前用户是否拥有指定角色。拥有则可以访问。 |
| hasAnyRole(String... roles) | 当前用户是否拥有指定角色中的任意一个，拥有则可以访问。 |
| hasAuthority(String authority) | 拥有指定权限( authority )的用户可访问。 |
| hasAnyAuthority(String... authorities) | 拥有指定任一权限( authority )的用户可访问。 |
| getPrincipal | 获得当前用户，可能是一个用户名，也可能是一个用户对象。 |
| getAuthentication | 获取当前Authentication对象（认证对象）。 |
| permitAll | 总是返回true，表示允许所有用户访问。 |
| denyAll | 总是返回false，表示拒绝所有用户访问。 |
| isAnonymous() | 是否是一个匿名用户，如果是则允许访问。 |
| isRememberMe() | 用户是否是通过Remember-Me自动登录，如果是则允许访问。 |
| isAuthenticated() | 用户是否登录认证成功，如果是则允许访问。 |
| isFullyAuthenticated() | 如果当前用户不是一个匿名用户，又不是通过Remember-Me自动登录的，则允许访问。（手动输入帐户信息认证）。 |
可以使用 access() 实现相同的功能。
.antMatchers("/cxyxj/**").access("hasAuthority('admin')")
.antMatchers("/permitAll").access("isAnonymous")
复制代码自定义方法（重要）
虽然内置了很多的表达式，但是在实际项目中，用的很少，而且很有可能不能满足需求。所以需要自定义逻辑的情况。比如判断当前登录用户是否具有访问当前 URL 的权限！
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.User;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
@Component
public class MyAccess
// 只需要登录就能访问的接口地址
private static final Set<String> URL = new HashSet<>();
// 需要区分角色的接口地址 用户名称：接口地址
private static final HashMap<String,Set<String>> URL_MAP = new HashMap();
static
URL.add("/hello");
Set<String> cxyxjSet = new HashSet<>();
cxyxjSet.add("/cxyxj/hello");
cxyxjSet.add("/security/hello");
URL_MAP.put("cxyxj",cxyxjSet);
Set<String> securitySet = new HashSet<>();
securitySet.add("/security/hello");
URL_MAP.put("security",securitySet);
public boolean hasPermit(HttpServletRequest req, Authentication auth)
Object principal = auth.getPrincipal();
String servletPath = req.getRequestURI();
AntPathMatcher matcher = new AntPathMatcher();
// 有一些接口是不需要权限，只要登录就能访问的，比如一些省市区接口
boolean result = URL.stream().anyMatch(url -> matcher.match(url, servletPath));
if(result)
return true;
//这里使用的是定义在内存的用户信息
if(principal instanceof User)
User user = (User) principal;
// 可以根据用户id或者用户名从redis中获得用户拥有的菜单权限url
String username = user.getUsername();
Set<String> urlSet = URL_MAP.get(username);
return urlSet.stream().anyMatch(u -> matcher.match(u, servletPath));
return false;
复制代码- 配置
@Override
protected void configure(HttpSecurity http) throws Exception
http.authorizeRequests() //开启配置
.antMatchers("/permitAll").permitAll() // 访问/permitAll路径，不需要登录
.anyRequest().access("@myAccess.hasPermit(request,authentication)")
//.anyRequest() //其他请求
//.authenticated()//验证 表示其他请求只需要登录就能访问
.and()
.formLogin();
复制代码使用这种方式，authenticated()，就不需要加了。access表达式的写法为 @符号 + Bean名称.方法(参数...)
- 增加方法
@GetMapping("/denyAll")
public String denyAll()
return "denyAll 你好 Spring Security";
复制代码- 测试 登录
cxyxj用户：可以访问/cxyxj/hello、/security/hello、hello、permitAll接口。不能访问denyAll接口。
登录 security用户：可以访问/security/hello、hello、permitAll接口。不能访问 denyAll、/cxyxj/hello接口。
方法授权
Spring Security在方法的权限控制上支持三种类型的注解，JSR-250注解、@Secured注解、支持表达式注解。这三种注解默认都是没有启用的，需要使用@EnableGlobalMethodSecurity来进行启用。
1、JSR250E
在 @EnableGlobalMethodSecurity 设置 jsr250Enabled 为 true ，就开启了以下三个安全注解：
-
@RolesAllowed：表示访问对应方法时应该具备所指定的角色。示例:
@RolesAllowed("user", "admin")，表示该方法只要具有"user", "admin"任意一种权限就可以访问。可以省略前缀ROLE_不写。该注解可以标注在类上，也可以标注在方法上，当标注在类上时表示类中所有方法的执行都需要对应的角色，当标注在方法上表示执行该方法时所需要的角色，当方法和类上都标注了@RolesAllowed，则方法上的@RolesAllowed将覆盖类上的@RolesAllowed。 -
@PermitAll 表示允许所有的角色进行访问。@PermitAll可以标注在方法上也可以标注在类上，当标注在方法上时则只对对应方法不进行权限控制，而标注在类上时表示对类里面所有的方法都不进行权限控制。
-
- （1）当 @PermitAll 标注在类上，而 @RolesAllowed 标注在方法上时，@RolesAllowed 将覆盖 @PermitAll，即需要 @RolesAllowed 对应的角色才能访问。
-
- （2）当 @RolesAllowed 标注在类上，而 @PermitAll 标注在方法上时则对应的方法不进行权限控制。
-
- （3）当在类和方法上同时使用了@PermitAll 和 @RolesAllowed 时，先定义的将发生作用。
-
@DenyAll 表示什么角色都不能访问。@DenyAll可以标注在方法上也可以标注在类上，当标注在方法上时则只对对应方法进行权限控制，而标注在类上时表示对类里面所有的方法都进行权限控制。
提供测试接口
@GetMapping("/hello")
public String hello()
return "你好 Spring Security";
@GetMapping("/cxyxj/hello")
@RolesAllowed("admin")
public String cxyxj()
return "cxyxj 你好 Spring Security";
@GetMapping("/security/hello")
@RolesAllowed("user")
public String user()
return "user 你好 Spring Security";
@GetMapping("/denyAll")
@DenyAll
public String denyAll()
return "denyAll 你好 Spring Security";
@GetMapping("/permitAll")
@PermitAll
public String permitAll()
return "permitAll 你好 Spring Security";
复制代码SecurityConfig
@Configuration
@EnableGlobalMethodSecurity(jsr250Enabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter
@Bean
PasswordEncoder passwordEncoder()
return NoOpPasswordEncoder.getInstance();
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception
auth.inMemoryAuthentication()
.withUser("cxyxj")
.password("123").roles("admin", "user")
.and()
.withUser("security")
.password("security").roles("user");
@Override
protected void configure(HttpSecurity http) throws Exception
http.formLogin();
复制代码hello接口登录就能访问。/cxyxj/hello接口需要有 admin角色才能访问，/security/hello接口需要有 user角色才能访问,denyAll接口不允许访问，permitAll 接口所有人都能访问。
各位是不是发现 configure(HttpSecurity http)方法中只配置了 http.formLogin()。我为什么没有配置其他的呢？这是因为当配置 .authorizeRequests().anyRequest().authenticated()之后，所有方法需要认证之后才能访问。该配置与 @PermitAll注解发生了冲突。
开篇提到过：若为web授权则拦截器为 FilterSecurityInterceptor；若为方法授权则拦截器为MethodSecurityInterceptor。如果同时使用web 授权和方法授权，则先执行web授权，再执行方法授权，最后决策通过，则允许访问资源，否则将禁止访问。 当配置.authorizeRequests().anyRequest().authenticated()之后，相当于同时使用 web 授权和方法授权，然后被 web 授权拦截了，所以 @PermitAll 并没有生效。当然实际项目中， @PermitAll一般不会使用！
2、secured
在 @EnableGlobalMethodSecurity 设置 securedEnabled 为 true ，就开启了以下注解：
- @Secured 是由 Spring Security 定义的，用来支持方法权限控制的注解。@Secured 专门用于判断是否具有指定角色的，可以写在方法或类上。参数需要手动指定 "ROLE_" 前缀。
SecurityConfig
@EnableGlobalMethodSecurity(jsr250Enabled = true,securedEnabled = true)
复制代码提供测试接口
@GetMapping("/secured")
@Secured("admin")
public String secured()
return "secured 你好 Spring Security";
复制代码3、表达式
Spring Security 中定义了四个支持使用表达式的注解，分别是 @PreAuthorize、@PostAuthorize、 @PreFilter 和 @PostFilter。其中前两者可以用来在方法调用前或者调用后进行权限检查，后两者可以用来对集合类型的参数或者返回值进行过滤。 接下来演示一下使用方式，首先我们先来开启注解，在 @EnableGlobalMethodSecurity 设置 prePostEnabled 为 true 。
SecurityConfig
@EnableGlobalMethodSecurity(jsr250Enabled = true,securedEnabled = true,prePostEnabled = true)
复制代码@PreAuthorize
最被常用的注解为@PreAuthorize。在方法调用前进行权限检查，结果为 true 则可以执行！可以在类或者方法上进行标注。注解参数与 access方法参数一致，也就是说可以使用内置方法和Spring-EL表达式。
// 只有角色为 admin 或者 user才能访问
@PreAuthorize("hasRole('admin') or hasRole('user')")
@GetMapping("/preAuthorize")
public String preAuthorize()
return "PreAuthorize 你好 Spring Security";
//Id大于1才能查询
// 按名称访问任何方法参数作为表达式变量
@PreAuthorize("#id>1")
@GetMapping("/findById/id")
public Integer findById(@PathVariable("id") Integer id)
return id;
// 限制只能查询自己的信息
// principal 值通常是 UserDetails 实例
@PreAuthorize("principal.username.equals(#username)")
@GetMapping("/findByName/username")
public String findByName(@PathVariable("username") String username)
return username;
//限制只能新增用户名称为abc的用户
@PreAuthorize("#username.equals('abc')")
@GetMapping("/add/username")
public String add(@PathVariable("username") String username)
return username;
复制代码@PostAuthorize
这个注解使用的很少，当然可能某些需求需要使用。比如需要校验该方法的返回值，这可以使用 @PostAuthorize 注解来实现。要访问方法的返回值，请使用内置表达式 returnObject。
@PostAuthorize("returnObject.id%2==0")
@GetMapping("/find/id")
public SysUser find(@PathVariable("id") Integer id)
SysUser sysUser = new SysUser();
sysUser.setId(id);
User principal = (User)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
sysUser.setUsername(principal.getUsername());
return sysUser;
复制代码在方法调用完成后进行权限检查，如果返回值的id是偶数则表示校验通过，否则表示校验失败，将 抛出AccessDeniedException。@PostAuthorize是在方法调用完成后进行权限检查，它不能控制方法是否能被调用，只能在方法调用完成后，检查权限然后决定是否要抛出AccessDeniedException异常。
@PreFilter
对集合、数组类型的请求参数进行过滤，移除结果为false的元素。该过程发生在接口接收参数之前,可以使用内置表达式 filterObjec 进行数据过滤，filterObjec 表示集合中的当前对象。 如果有多个集合参数需要通过 filterTarget=<参数名> 来指定过滤的集合。
// id 大于 1 的才进行查询
@PreFilter("filterObject > 1")
@PostMapping("/find")
public List<Integer> batchGetInfo(@RequestParam("ids") ArrayList<Integer> ids)
return ids;
复制代码
多个集合参数需要通过 filterTarget=<参数名> 来指定。如下：
// id 大于 1 的才进行查询
@PreFilter(filterTarget = "ids",value = "filterObject > 1")
@PostMapping("/batchGetInfo")
public List<Integer> batchGetInfo(@RequestParam("ids") ArrayList<Integer> ids,@RequestParam("ids2")ArrayList<Integer> ids2)
return ids;
复制代码@PostFilter
@PostFilter可以对集合、数组类型的返回值进行过滤！
// 将结果集为偶数的值进行返回
@PostFilter("filterObject % 2 == 0")
@GetMapping("/findAll")
public List<Integer> findAll()
List<Integer> userList = new ArrayList<>();
for (int i=0; i<10; i++)
userList.add(i);
return userList;
spring security 3.1 实现权限控制
简单介绍:spring security 实现的权限控制,能够分别保护后台方法的管理,url连接訪问的控制,以及页面元素的权限控制等,
security的保护,配置有简单到复杂基本有三部:
1) 採用硬编码的方式:详细做法就是在security.xml文件里,将用户以及所拥有的权限写死,通常是为了查看环境搭建的检查状态.
2) 数据库查询用户以及权限的方式,这种方式就是在用户的表中直接存入了权限的信息,比方 role_admin,role_user这种权限信息,取出来的时候,再将其拆分.
3) 角色权限动态配置,这样的方式值得是将权限角色单独存入数据库中,与用户进行相关联,然后进行对应的设置.
以下就这三种方式进行对应的程序解析
初始化环境搭建
新建web项目,导入当中的包,环境搭建就算是完了,以下一部我们開始security权限控制中方法的第一种.
硬编码配置
<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/security/*.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/security/dispatcher-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcher</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> <!-- 权限 --> <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> </web-app>
以下我们就開始配置mvc的配置文件,名称为dispatcher-servlet.xml的springmvc的配置文件内容例如以下:
<?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:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"> <!-- 使Spring支持自己主动检測组件，如注解的Controller --> <context:component-scan base-package="com"/> <aop:aspectj-autoproxy/> <!-- 开启AOP --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/jsp/" p:suffix=".jsp" /> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list > <ref bean="mappingJacksonHttpMessageConverter" /> </list> </property> </bean> <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" /> <!-- 数据库连接配置 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/power"></property> <property name="user" value="root"></property> <property name="password" value="516725"></property> <property name="minPoolSize" value="10"></property> <property name="MaxPoolSize" value="50"></property> <property name="MaxIdleTime" value="60"></property><!-- 最少空暇连接 --> <property name="acquireIncrement" value="5"></property><!-- 当连接池中的连接耗尽的时候 c3p0一次同一时候获取的连接数。
--> <property name="TestConnectionOnCheckout" value="true" ></property> </bean> <bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource"> <ref local="dataSource"/> </property> </bean> <!-- 事务申明 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" > <ref local="dataSource"/> </property> </bean> <!-- Aop切入点 --> <aop:config> <aop:pointcut expression="within(com.ucs.security.dao.*)" id="serviceOperaton"/> <aop:advisor advice-ref="txadvice" pointcut-ref="serviceOperaton"/> </aop:config> <tx:advice id="txadvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="delete*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> </beans>
下一步我们開始配置spring-securoty.xml的权限控制配置,例如以下:
<?xml version="1.0" encoding="UTF-8"?> <beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"> <!-- 对全部页面进行拦截。须要ROLE_USER权限 --> <http auto-config='true'> <intercept-url pattern="/**" access="ROLE_USER" /> </http> <!-- 权限配置 jimi拥有两种权限 bob拥有一种权限 --> <authentication-manager> <authentication-provider> <user-service> <user name="jimi" password="123" authorities="ROLE_USER, ROLE_ADMIN" /> <user name="bob" password="456" authorities="ROLE_USER" /> </user-service> </authentication-provider> </authentication-manager> </beans:beans>
到此为止,权限的配置基本就结束了,以下就启动服务,securoty会为我们自己主动生成一个登陆页面,在地址栏中输入:http://localhost:8080/项目名称/spring_security_login,会出现一个登陆界面,尝试一下吧.看看登陆以后能不能依照你的权限配置进行控制.
下一步,我们開始解说另外一种,数据库的用户登陆并实现获取权限进行操作.
数据库权限控制
CREATE TABLE `user` ( `Id` int(11) NOT NULL auto_increment, `logname` varchar(255) default NULL, `password` varchar(255) default NULL, `role_ids` varchar(255) default NULL, PRIMARY KEY (`Id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
我们改动spring-security.xml文件,让其不在写死这些权限和用户的控制:
<?xml version="1.0" encoding="UTF-8"?
> <beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"> <!-- 启用方法控制訪问权限 用于直接拦截接口上的方法。拥有权限才干訪问此方法--> <global-method-security jsr250-annotations="enabled"/> <!-- 自己写登录页面，而且登陆页面不拦截 --> <http pattern="/jsp/login.jsp" security="none" /> <!-- 配置拦截页面 --> <!-- 启用页面级权限控制 使用表达式 --> <http auto-config='true' access-denied-page="/jsp/403.jsp" use-expressions="true"> <intercept-url pattern="/**" access="hasRole('ROLE_USER')" /> <!-- 设置用户默认登录页面 --> <form-login login-page="/jsp/login.jsp"/> </http> <authentication-manager> <!-- 权限控制 引用 id是myUserDetailsService的server --> <authentication-provider user-service-ref="myUserDetailsService"/> </authentication-manager> </beans:beans>
以下编辑了自己的登陆页面,我们做一个解释:
<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>登录界面</title>
</head>
<body>
<h3>登录界面</h3>
<form action="/项目根文件夹/j_spring_security_check" method="post">
<table>
<tr><td>User:</td><td><input type='text' name='j_username' value=''></td></tr>
<tr><td>Password:</td><td><input type='password' name='j_password'/></td></tr>
<tr><td colspan='2'><input name="submit" type="submit" value="Login"/></td></tr>
</table>
</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
<%@ taglib prefix="s" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; utf-8">
<title>Insert title here</title>
</head>
<body>
<h5><a href="../j_spring_security_logout">logout</a></h5>
<!-- 拥有ROLE_ADMIN权限的才看的到 -->
<sec:authorize access="hasRole('ROLE_ADMIN')">
<form action="#">
账号：<input type="text" /><br/>
密码：<input type="password"/><br/>
<input type="submit" value="submit"/>
</form>
</sec:authorize>
<p/>
<sec:authorize access="hasRole('ROLE_USER')">
显示拥有ROLE_USER权限的页面<br/>
<form action="#">
账号：<input type="text" /><br/>
密码：<input type="password"/><br/>
<input type="submit" value="submit"/>
</form>
</sec:authorize>
<p/>
<h5>測试方法控制訪问权限</h5>
<a href="addreport_admin.do">加入报表管理员</a><br/>
<a href="deletereport_admin.do">删除报表管理员</a>
</body>
</html>以下展示的是訪问controller层
package com.ucs.security.server;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import com.ucs.security.face.SecurityTestInterface;
@Controller
public class SecurityTest {
@Resource
private SecurityTestInterface dao;
@RequestMapping(value="/jsp/getinput")//查看近期收入
@ResponseBody
public boolean getinput(HttpServletRequest req,HttpServletRequest res){
boolean b=dao.getinput();
return b;
}
@RequestMapping(value="/jsp/geoutput")//查看近期支出
@ResponseBody
public boolean geoutput(HttpServletRequest req,HttpServletRequest res){
boolean b=dao.geoutput();
return b;
}
@RequestMapping(value="/jsp/addreport_admin")//加入报表管理员
@ResponseBody
public boolean addreport_admin(HttpServletRequest req,HttpServletRequest res){
boolean b=dao.addreport_admin();
return b;
}
@RequestMapping(value="/jsp/deletereport_admin")//删除报表管理员
@ResponseBody
public boolean deletereport_admin(HttpServletRequest req,HttpServletRequest res){
boolean b=dao.deletereport_admin();
return b;
}
@RequestMapping(value="/jsp/user")//普通用户登录
public ModelAndView user_login(HttpServletRequest req,HttpServletRequest res){
dao.user_login();
return new ModelAndView("user");
}
}
我们再次写入了一个内部方法调用的接口,这个我们能够使用权限进行方法的保护,在配置文件里<global-method-security jsr250-annotations="enabled"/>就是在接口上设置权限，当拥有权限时才干调用方法，没有权限是不能调用方法的，保证了安全性
package com.ucs.security.face;
import javax.annotation.security.RolesAllowed;
import com.ucs.security.pojo.Users;
public interface SecurityTestInterface {
boolean getinput();
boolean geoutput();
@RolesAllowed("ROLE_ADMIN")//拥有ROLE_ADMIN权限的用户才可进入此方法
boolean addreport_admin();
@RolesAllowed("ROLE_ADMIN")
boolean deletereport_admin();
Users findbyUsername(String name);
@RolesAllowed("ROLE_USER")
void user_login();
}
package com.ucs.security.dao;
import java.sql.SQLException;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;
import com.ucs.security.face.SecurityTestInterface;
import com.ucs.security.pojo.Users;
@Repository("SecurityTestDao")
public class SecurityTestDao implements SecurityTestInterface{
Logger log=Logger.getLogger(SecurityTestDao.class);
@Resource
private JdbcTemplate jdbcTamplate;
public boolean getinput() {
log.info("getinput");
return true;
}
public boolean geoutput() {
log.info("geoutput");
return true;
}
public boolean addreport_admin() {
log.info("addreport_admin");
return true;
}
public boolean deletereport_admin() {
log.info("deletereport_admin");
return true;
}
public Users findbyUsername(String name) {
final Users users = new Users();
jdbcTamplate.query("SELECT * FROM USER WHERE logname = ?",
new Object[] {name},
new RowCallbackHandler() {
@Override
public void processRow(java.sql.ResultSet rs)
throws SQLException {
users.setName(rs.getString("logname"));
users.setPassword(rs.getString("password"));
users.setRole(rs.getString("role_ids"));
}
});
log.info(users.getName()+" "+users.getPassword()+" "+users.getRole());
return users;
}
@Override
public void user_login() {
log.info("拥有ROLE_USER权限的方法訪问：user_login");
}
}
以下就是重要的一个类：MyUserDetailsService这个类须要去实现UserDetailsService这个接口:
package com.ucs.security.context; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import javax.annotation.Resource; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.GrantedAuthorityImpl; import org.springframework.security.core.userdetails.User; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; import com.ucs.security.face.SecurityTestInterface; import com.ucs.security.pojo.Users; /** * 在spring-security.xml中假设配置了 * <authentication-manager> <authentication-provider user-service-ref="myUserDetailsService" /> </authentication-manager> * 将会使用这个类进行权限的验证。登录的时候获取登录的username，然后通过数据库去查找该用户拥有的权限将权限添加到Set<GrantedAuthority>中，当然能够加多个权限进去，仅仅要用户拥有当中一个权限就能够登录进来。* * **/ @Service("myUserDetailsService") public class MyUserDetailsService implements UserDetailsService{ @Resource private SecurityTestInterface dao; //登录验证 public UserDetails loadUserByUsername(String name) throws UsernameNotFoundException { System.out.println("show login name："+name+" "); Users users =dao.findbyUsername(name); Set<GrantedAuthority> grantedAuths=obtionGrantedAuthorities(users); boolean enables = true; boolean accountNonExpired = true; boolean credentialsNonExpired = true; boolean accountNonLocked = true; //封装成spring security的user User userdetail = new User(users.getName(), users.getPassword(), enables, accountNonExpired, credentialsNonExpired, accountNonLocked, grantedAuths); return userdetail; } //查找用户权限 public Set<GrantedAuthority> obtionGrantedAuthorities(Users users){ String roles[] = users.getRole().split(","); Set<GrantedAuthority> authSet=new HashSet<GrantedAuthority>(); for (int i = 0; i < roles.length; i++) { authSet.add(new GrantedAuthorityImpl(roles[i])); } return authSet; } }
然后将从数据库查到的password和权限设置到security自己的User类中。security会自己去匹配前端发来的password和用户权限去对照。然后推断用户能否够登录进来。登录失败还是停留在登录界面。
在user.jsp中測试了用户权限来验证能否够拦截没有权限用户去訪问资源：
点击加入报表管理员或者删除报表管理员时候会跳到403.jsp由于没有权限去訪问资源。在接口上我们设置了訪问的权限:
- @RolesAllowed("ROLE_ADMIN")//拥有ROLE_ADMIN权限的用户才可进入此方法
- boolean addreport_admin();
- @RolesAllowed("ROLE_ADMIN")
- boolean deletereport_admin();
由于登录进来的用户时ROLE_USER权限的。
就被拦截下来。
logout是登出，返回到登录界面。而且用户在security中的缓存清掉了。一样会对资源进行拦截。
以下我们就開始研究第三种方式,须要用将角色可訪问资源链接保存到数据库，能够随时更改,也就是我们所谓的url的控制,什么鸡毛,就是数据库存放了角色权限,能够实时更改,而不再xml文件里写死.
以下链接,我给大家提供了一个源代码的下载链接 , 这是本届解说的内容的源代码,执行无误,狼心货 http://download.csdn.net/detail/u014201191/8929187
角色权限管理
# Host: localhost (Version: 5.0.22-community-nt) # Date: 2014-03-28 14:58:01 # Generator: MySQL-Front 5.3 (Build 4.81) /*!40101 SET NAMES utf8 */; # # Structure for table "power" # DROP TABLE IF EXISTS `power`; CREATE TABLE `power` ( `Id` INT(11) NOT NULL AUTO_INCREMENT, `power_name` VARCHAR(255) DEFAULT NULL, `resource_ids` VARCHAR(255) DEFAULT NULL, PRIMARY KEY (`Id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8; # # Data for table "power" # INSERT INTO `power` VALUES (1,'查看报表','1,2,'),(2,'管理系统','3,4,'); # # Structure for table "resource" # DROP TABLE IF EXISTS `resource`; CREATE TABLE `resource` ( `Id` INT(11) NOT NULL AUTO_INCREMENT, `resource_name` VARCHAR(255) DEFAULT NULL, `resource_url` VARCHAR(255) DEFAULT NULL, PRIMARY KEY (`Id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8; # # Data for table "resource" # INSERT INTO `resource` VALUES (1,'查看近期收入','/jsp/getinput.do'),(2,'查看近期支出','/jsp/geoutput.do'),(3,'加入报表管理员','/jsp/addreport_admin.do'),(4,'删除报表管理员','/jsp/deletereport_admin.do'); # # Structure for table "role" # DROP TABLE IF EXISTS `role`; CREATE TABLE `role` ( `Id` INT(11) NOT NULL AUTO_INCREMENT, `role_name` VARCHAR(255) DEFAULT NULL, `role_type` VARCHAR(255) DEFAULT NULL, `power_ids` VARCHAR(255) DEFAULT NULL, PRIMARY KEY (`Id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8; # # Data for table "role" # INSERT INTO `role` VALUES (1,'系统管理员','ROLE_ADMIN','1,2,'),(2,'报表管理员','ROLE_USER','1,'); # # Structure for table "user" # DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `Id` INT(11) NOT NULL AUTO_INCREMENT, `logname` VARCHAR(255) DEFAULT NULL, `password` VARCHAR(255) DEFAULT NULL, `role_ids` VARCHAR(255) DEFAULT NULL, PRIMARY KEY (`Id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8; SELECT * FROM USER; # # Data for table "user" # INSERT INTO `user` VALUES (1,'admin','123456','ROLE_USER,ROLE_ADMIN'),(3,'zhang','123','ROLE_USER'); COMMIT;
以下我们就開始写入spring-security.xml的配置文件:
<?xml version="1.0" encoding="UTF-8"?> <beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:beans="http://www.springframework.org/schema/beans" 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-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"> <!-- 启用方法控制訪问权限 用于直接拦截接口上的方法。拥有权限才干訪问此方法--> <global-method-security jsr250-annotations="enabled"/> <!-- 自己写登录页面。而且登陆页面不拦截 --> <http pattern="/jsp/login.jsp" security="none" /> <!-- 配置拦截页面 --> <!-- 启用页面级权限控制 使用表达式 --> <http auto-config='true' access-denied-page="/jsp/403.jsp" use-expressions="true"> <!-- requires-channel="any" 设置訪问类型http或者https --> <intercept-url pattern="/admin/**" access="hasRole('ROLE_ADMIN')" requires-channel="any"/> <!-- intercept-url pattern="/admin/**" 拦截地址的设置有载入先后的顺序， admin/**在前面请求admin/admin.jsp会先去拿用户验证是否有ROLE_ADMIN权限。有则通过，没有就拦截。假设shi pattern="/**" 设置在前面，当前登录的用户有ROLE_USER权限。那么就能够登录到admin/admin.jsp 所以两个配置有先后的。 --> <intercept-url pattern="/**" access="hasRole('ROLE_USER')" requires-channel="any"/> <!-- 设置用户默认登录页面 --> <form-login login-page="/jsp/login.jsp"/> <!-- 基于url的权限控制，载入权限资源管理拦截器,假设进行这种设置，那么 <intercept-url pattern="/admin/**" 就能够不进行配置了，会在数据库的资源权限中得到相应。 对于没有找到资源的权限为null的值就不须要登录才干够查看，相当于public的。能够公共訪问 --> <custom-filter ref="securityFilter" before="FILTER_SECURITY_INTERCEPTOR"/> </http> <!-- 当基于方法权限控制的时候仅仅须要此配置，在接口上加上权限就可以控制方法的调用 <authentication-manager> <authentication-provider user-service-ref="myUserDetailsService"/> </authentication-manager> --> <!-- 资源权限控制 --> <beans:bean id="securityFilter" class="com.ucs.security.context.MySecurityFilter"> <!-- 用户拥有的权限 --> <beans:property name="authenticationManager" ref="myAuthenticationManager" /> <!-- 用户是否拥有所请求资源的权限 --> <beans:property name="accessDecisionManager" ref="myAccessDecisionManager" /> <!-- 资源与权限相应关系 --> <beans:property name="securityMetadataSource" ref="mySecurityMetadataSource" /> </beans:bean> <authentication-manager alias="myAuthenticationManager"> <!-- 权限控制 引用 id是myUserDetailsService的server --> <authentication-provider user-service-ref="myUserDetailsService"/> </authentication-manager> </beans:beans>
同一时候,我们添加在xml文件里配置的java类:
假设获取到的角色是null，那就放行通过，这主要是对于那些不须要验证的公共能够訪问的方法。就不须要权限了。
能够直接訪问。
package com.ucs.security.context;
import java.util.Collection;
import java.util.Iterator;
import org.apache.log4j.Logger;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.stereotype.Service;
@Service("myAccessDecisionManager")
public class MyAccessDecisionManager implements AccessDecisionManager{
Logger log=Logger.getLogger(MyAccessDecisionManager.class);
@Override
public void decide(Authentication authentication, Object object,
Collection<ConfigAttribute> configAttributes) throws AccessDeniedException,
InsufficientAuthenticationException {
// TODO Auto-generated method stub
//假设相应资源没有找到角色 则放行
if(configAttributes == null){
return ;
}
log.info("object is a URL:"+object.toString()); //object is a URL.
Iterator<ConfigAttribute> ite=configAttributes.iterator();
while(ite.hasNext()){
ConfigAttribute ca=ite.next();
String needRole=ca.getAttribute();
for(GrantedAuthority ga:authentication.getAuthorities()){
if(needRole.equals(ga.getAuthority())){ //ga is user's role.
return;
}
}
}
throw new AccessDeniedException("no right");
}
@Override
public boolean supports(ConfigAttribute arg0) {
// TODO Auto-generated method stub
return true;
}
@Override
public boolean supports(Class<?> arg0) {
// TODO Auto-generated method stub
return true;
}
}
MySecurityFilter这个类是拦截中一个基本的类，拦截的时候会先通过这里：
package com.ucs.security.context;
import java.io.IOException;
import javax.annotation.Resource;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.log4j.Logger;
import org.springframework.security.access.SecurityMetadataSource;
import org.springframework.security.access.intercept.AbstractSecurityInterceptor;
import org.springframework.security.access.intercept.InterceptorStatusToken;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
public class MySecurityFilter extends AbstractSecurityInterceptor implements Filter {
Logger log=Logger.getLogger(MySecurityFilter.class);
private FilterInvocationSecurityMetadataSource securityMetadataSource;
public SecurityMetadataSource obtainSecurityMetadataSource() {
return this.securityMetadataSource;
}
public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {
return securityMetadataSource;
}
public void setSecurityMetadataSource(
FilterInvocationSecurityMetadataSource securityMetadataSource) {
this.securityMetadataSource = securityMetadataSource;
}
@Override
public void destroy() {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
FilterInvocation fi=new FilterInvocation(req,res,chain);
log.info("--------MySecurityFilter--------");
invok(fi);
}
private void invok(FilterInvocation fi) throws IOException, ServletException {
// object为FilterInvocation对象
//1.获取请求资源的权限
//运行Collection<ConfigAttribute> attributes = SecurityMetadataSource.getAttributes(object);
//2.是否拥有权限
//获取安全主体。能够强制转换为UserDetails的实例
//1) UserDetails
// Authentication authenticated = authenticateIfRequired();
//this.accessDecisionManager.decide(authenticated, object, attributes);
//用户拥有的权限
//2) GrantedAuthority
//Collection<GrantedAuthority> authenticated.getAuthorities()
log.info("用户发送请求！ ");
InterceptorStatusToken token = null;
token = super.beforeInvocation(fi);
try {
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
} finally {
super.afterInvocation(token, null);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
}
public Class<? extends Object> getSecureObjectClass() {
//以下的MyAccessDecisionManager的supports方面必须放回true,否则会提醒类型错误
return FilterInvocation.class;
}
}
package com.ucs.security.context;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.stereotype.Service;
import com.google.gson.Gson;
import com.ucs.security.face.SecurityTestInterface;
import com.ucs.security.pojo.URLResource;
@Service("mySecurityMetadataSource")
public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource{
//由spring调用
Logger log=Logger.getLogger(MySecurityMetadataSource.class);
@Resource
private SecurityTestInterface dao;
private static Map<String, Collection<ConfigAttribute>> resourceMap = null;
/*public MySecurityMetadataSource() {
loadResourceDefine();
}*/
public Collection<ConfigAttribute> getAllConfigAttributes() {
// TODO Auto-generated method stub
return null;
}
public boolean supports(Class<?> clazz) {
// TODO Auto-generated method stub
return true;
}
//载入全部资源与权限的关系
private void loadResourceDefine() {
if(resourceMap == null) {
resourceMap = new HashMap<String, Collection<ConfigAttribute>>();
/*List<String> resources ;
resources = Lists.newArrayList("/jsp/user.do","/jsp/getoutput.do");*/
List<URLResource> findResources = dao.findResource();
for(URLResource url_resource:findResources){
Collection<ConfigAttribute> configAttributes = new ArrayList<ConfigAttribute>();
ConfigAttribute configAttribute = new SecurityConfig(url_resource.getRole_Name());
for(String resource:url_resource.getRole_url()){
configAttributes.add(configAttribute);
resourceMap.put(resource, configAttributes);
}
}
//以权限名封装为Spring的security Object
}
Gson gson =new Gson();
log.info("权限资源相应关系："+gson.toJson(resourceMap));
Set<Entry<String, Collection<ConfigAttribute>>> resourceSet = resourceMap.entrySet();
Iterator<Entry<String, Collection<ConfigAttribute>>> iterator = resourceSet.iterator();
}
//返回所请求资源所须要的权限
public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
String requestUrl = ((FilterInvocation) object).getRequestUrl();
log.info("requestUrl is " + requestUrl);
if(resourceMap == null) {
loadResourceDefine();
}
log.info("通过资源定位到的权限："+resourceMap.get(requestUrl));
return resourceMap.get(requestUrl);
}
}
dao类中的方法有所改变:
package com.ucs.security.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.ucs.security.face.SecurityTestInterface;
import com.ucs.security.pojo.URLResource;
import com.ucs.security.pojo.Users;
@Repository("SecurityTestDao")
public class SecurityTestDao implements SecurityTestInterface{
Logger log=Logger.getLogger(SecurityTestDao.class);
@Resource
private JdbcTemplate jdbcTamplate;
public boolean getinput() {
log.info("getinput");
return true;
}
public boolean geoutput() {
log.info("geoutput");
return true;
}
public boolean addreport_admin() {
log.info("addreport_admin");
return true;
}
public boolean deletereport_admin() {
log.info("deletereport_admin");
return true;
}
public Users findbyUsername(String name) {
final Users users = new Users();
jdbcTamplate.query("SELECT * FROM USER WHERE logname = ?",
new Object[] {name},
new RowCallbackHandler() {
@Override
public void processRow(java.sql.ResultSet rs)
throws SQLException {
users.setName(rs.getString("logname"));
users.setPassword(rs.getString("password"));
users.setRole(rs.getString("role_ids"));
}
});
log.info(users.getName()+" "+users.getPassword()+" "+users.getRole());
return users;
}
@Override
public void user_login() {
log.info("拥有ROLE_USER权限的方法訪问：user_login");
}
@Override
//获取全部资源链接
public List<URLResource> findResource() {
List<URLResource> uRLResources =Lists.newArrayList();
Map<String,Integer[]> role_types=new HashMap<String, Integer[]>();
List<String> role_Names=Lists.newArrayList();
List list_role=jdbcTamplate.queryForList("select role_type,power_ids from role");
Iterator it_role = list_role.iterator();
while(it_role.hasNext()){
Map role_map=(Map)it_role.next();
String object = (String)role_map.get("power_ids");
String type = (String)role_map.get("role_type");
role_Names.add(type);
String[] power_ids = object.split(",");
Integer[] int_pow_ids=new Integer[power_ids.length];
for(int i=0;i<power_ids.length;i++){
int_pow_ids[i]=Integer.parseInt(power_ids[i]);
}
role_types.put(type, int_pow_ids);
}
for(String name:role_Names){
URLResource resource=new URLResource();
Integer[] ids=role_types.get(name);//更具角色获取权限id
List<Integer> all_res_ids=Lists.newArrayList();
List<String> urls=Lists.newArrayList();
for(Integer id:ids){//更具权限id获取资源id
List resource_ids=jdbcTamplate.queryForList("select resource_ids from power where id =?",new Object[]{id});
Iterator it_resource_ids = resource_ids.iterator();
while(it_resource_ids.hasNext()){
Map resource_ids_map=(Map)it_resource_ids.next();
String[] ids_str=((String)resource_ids_map.get("resource_ids")).split(",");
for(int i=0;i<ids_str.length;i++){
all_res_ids.add(Integer.parseInt(ids_str[i]));
}
}
}
for(Integer id:all_res_ids){
List resource_urls=jdbcTamplate.queryForList("select resource_url from resource where id=?
",new Object[]{id});
Iterator it_res_urls = resource_urls.iterator();
while(it_res_urls.hasNext()){
Map res_url_map=(Map)it_res_urls.next();
urls.add(((String)res_url_map.get("resource_url")));
}
}
//将相应的权限关系加入到URLRsource
resource.setRole_Name(name);
resource.setRole_url(urls);
uRLResources.add(resource);
}
Gson gson =new Gson();
log.info("权限资源相应关系:"+gson.toJson(uRLResources));
return uRLResources;
}
}
package com.ucs.security.face;
import java.util.List;
import javax.annotation.security.RolesAllowed;
import com.ucs.security.pojo.URLResource;
import com.ucs.security.pojo.Users;
public interface SecurityTestInterface {
boolean getinput();
boolean geoutput();
//@RolesAllowed("ROLE_ADMIN")//拥有ROLE_ADMIN权限的用户才可进入此方法
boolean addreport_admin();
//@RolesAllowed("ROLE_ADMIN")
boolean deletereport_admin();
Users findbyUsername(String name);
//@RolesAllowed("ROLE_USER")
void user_login();
List<URLResource> findResource();
}
首先用户没有登录的时候能够訪问一些公共的资源，可是必须把<intercept-url pattern="/**" access="hasRole(‘ROLE_USER‘)" requires-channel="any"/> 配置删掉。不拦截，不论什么资源都能够訪问。这样公共资源能够随意訪问。
对于须要权限的资源已经在数据库配置。假设去訪问会直接跳到登录界面。须要登录。
依据登录用户不同分配到的角色就不一样，依据角色不同来获取该角色能够訪问的资源。
拥有ROLE_USER角色用户去訪问ROLE_ADMIN的资源会返回到403.jsp页面。拥有ROLE_USER和ROLE_ADMIN角色的用户能够去訪问两种角色的资源。公共的资源两种角色都能够訪问。
security提供了默认的登出地址。登出后用户在spring中的缓存就清除了。
以上是关于Spring Security 权限控制的主要内容，如果未能解决你的问题，请参考以下文章
Spring Security（17）——基于方法的权限控制