目錄
1.1 通過表達式控制URL權限
1.2 通過表達式控制方法權限
1.2.1 使用@PreAuthorize和@PostAuthorize進行訪問控制
1.2.2 使用@PreFilter和@PostFilter進行過濾
1.3 使用hasPermission表達式
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。 |
1.1 通過表達式控制URL權限
URL的訪問權限是通過http元素下的intercept-url元素進行定義的，其access屬性用來定義訪問配置屬性。默認情況下該屬性值只能是以字符串進行分隔的字符串列表，且每一個元素都對應着一個角色，因為默認使用的是RoleVoter。通過設置http元素的use-expressions=”true”可以啟用intercept-url元素的access屬性對Spring EL表達式的支持，use-expressions的值默認為false。啟用access屬性對Spring EL表達式的支持后每個access屬性值都應該是一個返回結果為boolean類型的表達式，當表達式返回結果為true時表示當前用戶擁有訪問權限。此外WebExpressionVoter將加入AccessDecisionManager的AccessDecisionVoter列表，所以如果不使用NameSpace時應當手動添加WebExpressionVoter到AccessDecisionVoter。
<security:http use-expressions="true">
<security:form-login/>
<security:logout/>
<security:intercept-url pattern="/**" access="hasRole('ROLE_USER')" />
</security:http>
在上述配置中我們定義了只有擁有ROLE_USER角色的用戶才能訪問系統。
使用表達式控制URL權限使用的表達式對象類是繼承自SecurityExpressionRoot的WebSecurityExpressionRoot類。其相比基類而言新增了一個表達式hasIpAddress。hasIpAddress可用來限制只有指定IP或指定范圍內的IP才可以訪問。
<security:http use-expressions="true">
<security:form-login/>
<security:logout/>
<security:intercept-url pattern="/**" access="hasRole('ROLE_USER') and hasIpAddress('10.10.10.3')" />
</security:http>
在上面的配置中我們限制了只有IP為”10.10.10.3”，且擁有ROLE_USER角色的用戶才能訪問。hasIpAddress是通過Ip地址或子網掩碼來進行匹配的。如果要設置10.10.10下所有的子網都可以使用，那么我們對應的hasIpAddress的參數應為“10.10.10.n/24”，其中n可以是合法IP內的任意值。具體規則可以參照hasIpAddress()表達式用於比較的IpAddressMatcher的matches方法源碼。以下是IpAddressMatcher的源碼。
package org.springframework.security.web.util;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import org.springframework.util.StringUtils;
/**
* Matches a request based on IP Address or subnet mask matching against the remote address.
* <p>
* Both IPv6 and IPv4 addresses are supported, but a matcher which is configured with an IPv4 address will
* never match a request which returns an IPv6 address, and vice-versa.
*
* @author Luke Taylor
* @since 3.0.2
*/
public final class IpAddressMatcher implements RequestMatcher {
private final int nMaskBits;
private final InetAddress requiredAddress;
/**
* Takes a specific IP address or a range specified using the
* IP/Netmask (e.g. 192.168.1.0/24 or 202.24.0.0/14).
*
* @param ipAddress the address or range of addresses from which the request must come.
*/
public IpAddressMatcher(String ipAddress) {
if (ipAddress.indexOf('/') > 0) {
String[] addressAndMask = StringUtils.split(ipAddress, "/");
ipAddress = addressAndMask[0];
nMaskBits = Integer.parseInt(addressAndMask[1]);
} else {
nMaskBits = -1;
}
requiredAddress = parseAddress(ipAddress);
}
public boolean matches(HttpServletRequest request) {
return matches(request.getRemoteAddr());
}
public boolean matches(String address) {
InetAddress remoteAddress = parseAddress(address);
if (!requiredAddress.getClass().equals(remoteAddress.getClass())) {
return false;
}
if (nMaskBits < 0) {
return remoteAddress.equals(requiredAddress);
}
byte[] remAddr = remoteAddress.getAddress();
byte[] reqAddr = requiredAddress.getAddress();
int oddBits = nMaskBits % 8;
int nMaskBytes = nMaskBits/8 + (oddBits == 0 ? 0 : 1);
byte[] mask = newbyte[nMaskBytes];
Arrays.fill(mask, 0, oddBits == 0 ? mask.length : mask.length - 1, (byte)0xFF);
if (oddBits != 0) {
int finalByte = (1 << oddBits) - 1;
finalByte <<= 8-oddBits;
mask[mask.length - 1] = (byte) finalByte;
}
// System.out.println("Mask is " + new sun.misc.HexDumpEncoder().encode(mask));
for (int i=0; i < mask.length; i++) {
if ((remAddr[i] & mask[i]) != (reqAddr[i] & mask[i])) {
return alse;
}
}
return true;
}
private InetAddress parseAddress(String address) {
try {
return InetAddress.getByName(address);
} catch (UnknownHostException e) {
thrownew IllegalArgumentException("Failed to parse address" + address, e);
}
}
}
1.2 通過表達式控制方法權限
Spring Security中定義了四個支持使用表達式的注解，分別是@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter。其中前兩者可以用來在方法調用前或者調用后進行權限檢查，后兩者可以用來對集合類型的參數或者返回值進行過濾。要使它們的定義能夠對我們的方法的調用產生影響我們需要設置global-method-security元素的pre-post-annotations=”enabled”，默認為disabled。
<security:global-method-security pre-post-annotations="disabled"/>
1.2.1使用@PreAuthorize和@PostAuthorize進行訪問控制
@PreAuthorize可以用來控制一個方法是否能夠被調用。
@Service
public class UserServiceImpl implements UserService {
@PreAuthorize("hasRole('ROLE_ADMIN')")
public void addUser(User user) {
System.out.println("addUser................" + user);
}
@PreAuthorize("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")
public User find(int id) {
System.out.println("find user by id............." + id);
return null;
}
}
在上面的代碼中我們定義了只有擁有角色ROLE_ADMIN的用戶才能訪問adduser()方法，而訪問find()方法需要有ROLE_USER角色或ROLE_ADMIN角色。使用表達式時我們還可以在表達式中使用方法參數。
public class UserServiceImpl implements UserService {
/**
* 限制只能查詢Id小於10的用戶
*/
@PreAuthorize("#id<10")
public User find(int id) {
System.out.println("find user by id........." + id);
return null;
}
/**
* 限制只能查詢自己的信息
*/
@PreAuthorize("principal.username.equals(#username)")
public User find(String username) {
System.out.println("find user by username......" + username);
return null;
}
/**
* 限制只能新增用戶名稱為abc的用戶
*/
@PreAuthorize("#user.name.equals('abc')")
public void add(User user) {
System.out.println("addUser............" + user);
}
}
在上面代碼中我們定義了調用find(int id)方法時，只允許參數id小於10的調用；調用find(String username)時只允許username為當前用戶的用戶名；定義了調用add()方法時只有當參數user的name為abc時才可以調用。
有時候可能你會想在方法調用完之后進行權限檢查，這種情況比較少，但是如果你有的話，Spring Security也為我們提供了支持，通過@PostAuthorize可以達到這一效果。使用@PostAuthorize時我們可以使用內置的表達式returnObject表示方法的返回值。我們來看下面這一段示例代碼。
@PostAuthorize("returnObject.id%2==0")
public User find(int id) {
User user = new User();
user.setId(id);
return user;
}
上面這一段代碼表示將在方法find()調用完成后進行權限檢查，如果返回值的id是偶數則表示校驗通過，否則表示校驗失敗，將拋出AccessDeniedException。 需要注意的是@PostAuthorize是在方法調用完成后進行權限檢查，它不能控制方法是否能被調用，只能在方法調用完成后檢查權限決定是否要拋出AccessDeniedException。
1.2.2使用@PreFilter和@PostFilter進行過濾
使用@PreFilter和@PostFilter可以對集合類型的參數或返回值進行過濾。使用@PreFilter和@PostFilter時，Spring Security將移除使對應表達式的結果為false的元素。
@PostFilter("filterObject.id%2==0")
public List<User> findAll() {
List<User> userList = new ArrayList<User>();
User user;
for (int i=0; i<10; i++) {
user = new User();
user.setId(i);
userList.add(user);
}
return userList;
}
上述代碼表示將對返回結果中id不為偶數的user進行移除。filterObject是使用@PreFilter和@PostFilter時的一個內置表達式，表示集合中的當前對象。當@PreFilter標注的方法擁有多個集合類型的參數時，需要通過@PreFilter的filterTarget屬性指定當前@PreFilter是針對哪個參數進行過濾的。如下面代碼就通過filterTarget指定了當前@PreFilter是用來過濾參數ids的。
@PreFilter(filterTarget="ids", value="filterObject%2==0")
public void delete(List<Integer> ids, List<String> usernames) {
...
}
1.3 使用hasPermission表達式
Spring Security為我們定義了hasPermission的兩種使用方式，它們分別對應着PermissionEvaluator的兩個不同的hasPermission()方法。Spring Security默認處理Web、方法的表達式處理器分別為DefaultWebSecurityExpressionHandler和DefaultMethodSecurityExpressionHandler，它們都繼承自AbstractSecurityExpressionHandler，其所持有的PermissionEvaluator是DenyAllPermissionEvaluator，其對於所有的hasPermission表達式都將返回false。所以當我們要使用表達式hasPermission時，我們需要自已手動定義SecurityExpressionHandler對應的bean定義，然后指定其PermissionEvaluator為我們自己實現的PermissionEvaluator，然后通過global-method-security元素或http元素下的expression-handler元素指定使用的SecurityExpressionHandler為我們自己手動定義的那個bean。
接下來看一個自己實現PermissionEvaluator使用hasPermission()表達式的簡單示例。
首先實現自己的PermissionEvaluator，如下所示：
public class MyPermissionEvaluator implements PermissionEvaluator {
public boolean hasPermission(Authentication authentication,
Object targetDomainObject, Object permission) {
if ("user".equals(targetDomainObject)) {
return this.hasPermission(authentication, permission);
}
return false;
}
/**
* 總是認為有權限
*/
public boolean hasPermission(Authentication authentication,
Serializable targetId, String targetType, Object permission) {
return true;
}
/**
* 簡單的字符串比較，相同則認為有權限
*/
private boolean hasPermission(Authentication authentication, Object permission) {
Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
for (GrantedAuthority authority : authorities) {
if (authority.getAuthority().equals(permission)) {
returntrue;
}
}
return false;
}
}
接下來在ApplicationContext中顯示的配置一個將使用PermissionEvaluator的SecurityExpressionHandler實現類，然后指定其所使用的PermissionEvaluator為我們自己實現的那個。這里我們選擇配置一個針對於方法調用使用的表達式處理器，DefaultMethodSecurityExpressionHandler，具體如下所示。
<bean id="expressionHandler"
class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler">
<property name="permissionEvaluator" ref="myPermissionEvaluator" />
</bean>
<!-- 自定義的PermissionEvaluator實現 -->
<bean id="myPermissionEvaluator" class="com.xxx.MyPermissionEvaluator"/>
有了SecurityExpressionHandler之后，我們還要告訴Spring Security，在使用SecurityExpressionHandler時應該使用我們顯示配置的那個，這樣我們自定義的PermissionEvaluator才能起作用。因為我們上面定義的是針對於方法的SecurityExpressionHandler，所以我們要指定在進行方法權限控制時應該使用它來進行處理，同時注意設置pre-post-annotations=”true”以啟用對支持使用表達式的@PreAuthorize等注解的支持。
<security:global-method-security
pre-post-annotations="enabled">
<security:expression-handler ref="expressionHandler" />
</security:global-method-security>
之后我們就可以在需要進行權限控制的方法上使用@PreAuthorize以及hasPermission()表達式進行權限控制了。
@Service
public class UserServiceImpl implements UserService {
/**
* 將使用方法hasPermission(Authentication authentication,
Object targetDomainObject, Object permission)進行驗證。
*/
@PreAuthorize("hasPermission('user', 'ROLE_USER')")
public User find(int id) {
return null;
}
/**
* 將使用PermissionEvaluator的第二個方法，即hasPermission(Authentication authentication,
Serializable targetId, String targetType, Object permission)進行驗證。
*/
@PreAuthorize("hasPermission('targetId','targetType','permission')")
public User find(String username) {
return null;
}
@PreAuthorize("hasPermission('user', 'ROLE_ADMIN')")
public void add(User user) {
}
}
在上面的配置中，find(int id)和add()方法將使用PermissionEvaluator中接收三個參數的hasPermission()方法進行驗證，而find(String username)方法將使用四個參數的hasPermission()方法進行驗證。因為hasPermission()表達式與PermissionEvaluator中hasPermission()方法的對應關系就是在hasPermission()表達式使用的參數基礎上加上當前Authentication對象調用對應的hasPermission()方法進行驗證。
其實Spring Security已經針對於ACL實現了一個AclPermissionEvaluator。關於ACL的內容將在后文進行介紹。
（注：本文是基於Spring Security3.1.6所寫）