想学习下SpringSecurity，看了下用户指南文档，觉得 SpringSecurity的配置太多，并且有点复杂。一般在权限控制中，对资 源访问的权限一般分为组权限（也有称角色，它包含多个单个的权限）和单个权限，那么我们完全可以在访问资源时，通过申明（Java注解）该资源所需的权限 就可以达到目的了。


Java注解其实一直伴随着我们，在Java类中，我们经常会看到“@Override”、“@SuppressWarnings” 等字符串，它们就是Java注解。就Java注解本身而言，它是不会对所注解的目标（类型，属性，方法，参数，构造函数，局部变量，注解和包）产生任何影 响的，但它可配合其它工具（比如Eclipse，加上@SuppressWarnings(“unckecked”)后，那条×××的警告线就消失了）或是 程序（比如对属性加上@Autowire，则Spring就帮我们注入了）对注解目标产生作用。


一、定义注解类
@Target( { ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SecurityControl {
    public String[] role() default "";
    public boolean roleOr() default true;
    public String[] perm() default "";
    public boolean permOr() default false;
}
说明：Java代码去除了文件说明、版权、注释等内容。
 注解“SecurityControl”它有三个注解来说明本注解：
 Target：指示了SecurityControl可以注解的目标（类型，属性，方法，参数，构造函数，局部变量，注解和包），本注解只有类型和方法；
 Retention：指示了SecurityControl注解所适用的范围（源代码?类文件?运行期），因为要在VM运行的时候读取注解，所以本注解是运行期；
 Documented：指示了是加把本注解加到生成的Java文档中（JavaDoc），本注解加入。
 注解“SecurityControl”有四个属性：
 role[]：资源的组权限；
 roleOr：组权限是不是或关系，即只要满足其中之一即可，默认为是；
 perm[]：单个权限组；
 permOr：单个权限是不是或关系，默认为否，即全部的单个权限必须全部满足才行。

 

 二、权限异常类
 当权限不满足时，抛出异常，这样系统可以捕捉该异常，然后做相应的处理。
public class SecurityControlException extends RuntimeException {
    private static final long serialVersionUID = -8065906692358500801L;
   
    public SecurityControlException() {
    }
   
    public SecurityControlException(String errMsg) {
        super(errMsg);
    }
}
 该异常可以带一个异常消息，比如可以说明在进行什么操作时抛出该异常。

 

 三、权限持有类
public class SecurityControlHolder {
    private static final ThreadLocal<Set<String>> roles = new ThreadLocal<Set<String>>();
    private static final ThreadLocal<Set<String>> perms = new ThreadLocal<Set<String>>();
   
    public static void set(Set<String> rs, Set<String> ps) {
        roles.set(rs);
        perms.set(ps);
    }
   
    public static Set<String> getRoles() {
        return roles.get();
    }
   
    public static Set<String> getPerms() {
        return perms.get();
    }
   
    public static void clear() {
        roles.set(null);
        perms.set(null);
    }
   
    public static void checkPermission(SecurityControl sc) {
        if (checkRoles(sc) && checkPerms(sc)) {
            return;
        }
       
        throw new SecurityControlException("访问操作拒绝.");
    }
   
    private static boolean checkRoles(SecurityControl sc) {
        if (sc == null) {
            return true;
        }
       
        String[] roles = sc.role();
        if (roles == null || roles.length == 0) {
            return true;
        }
        List<String> list = new ArrayList<String>();
        for (String role : roles) {
            if (role != null && role.trim().length() > 0) {
                list.add(role.trim());
            }
        }
        if (list.isEmpty()) {
            return true;
        }
       
        Set<String> rs = getRoles();
        if (sc.roleOr()) {
            for (String role : roles) {
                if (rs.contains(role)) {
                    return true;
                }
            }
        } else {
            for (String role : roles) {
                if (!rs.contains(role)) {
                    return false;
                }
            }
            return true;
        }
       
        return false;
    }
   
    private static boolean checkPerms(SecurityControl sc) {
        if (sc == null) {
            return true;
        }
       
        String[] perms = sc.perm();
        if (perms == null || perms.length == 0) {
            return true;
        }
        List<String> list = new ArrayList<String>();
        for (String perm : perms) {
            if (perm != null && perm.trim().length() > 0) {
                list.add(perm.trim());
            }
        }
        if (list.isEmpty()) {
            return true;
        }
       
        Set<String> ps = getPerms();
        if (sc.permOr()) {
            for (String perm : perms) {
                if (ps.contains(perm)) {
                    return true;
                }
            }
        } else {
            for (String perm : perms) {
                if (!ps.contains(perm)) {
                    return false;
                }
            }
            return true;
        }
       
        return false;
    }
}
 每 次验证权限“checkPermission(SecurityControl sc)”都是先验证组“checkRoles(SecurityControl sc)”，在组权限通过的情况下，再验证单个权限“checkPerms(SecurityControl sc)”，只有在组和单个权限都通过的情况下，才有权限访问资源，否则抛出权限不足异常（SecurityControlException）。

 

 四、访问切面类
 上面三步已经把准备工作做好了：我们可以通过注解来标示资源的权限，通过捕捉异常来决定当权限不足时做什么，可以通过一个简单的持有类来保持访问者的权限。现在还剩下最后一项工作：这个注解如何工作？可以通过拦截方法来达到该目的。
public class SecurityControlInterceptor implements MethodInterceptor {
    private static final Logger logger = Logger.getLogger(SecurityControlInterceptor.class);
   
  
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Method method = invocation.getMethod();
        Class<?> clazz = method.getDeclaringClass();
       
        if (logger.isInfoEnabled()) {
            logger.info("Start Monitor: " + this.dumpInvocation(clazz, method, invocation.getArguments()));
        }
       
        SecurityControl sc = clazz.getAnnotation(SecurityControl.class);
        if (logger.isInfoEnabled()) {
            logger.info("Class SecurityControl: " + this.dumpSecurityControl(sc));
        }
       
        // 验证类安全
        SecurityControlHolder.checkPermission(sc);
       
        sc = method.getAnnotation(SecurityControl.class);
        if (logger.isInfoEnabled()) {
            logger.info("Method SecurityControl: " + this.dumpSecurityControl(sc));
        }
       
        // 验证方法安全
        SecurityControlHolder.checkPermission(sc);
       
        return invocation.proceed();
    }
   
    private String dumpInvocation(Class<?> clazz, Method method, Object[] args) {
        StringBuilder txt = new StringBuilder();
        txt.append("[Class: ").append(clazz.getSimpleName()).append("]");
        txt.append("[Method: ").append(method.getName()).append("]");
        txt.append("[Args: ").append(Arrays.toString(args)).append("]");
       
        return txt.toString();
    }
   
    private String dumpSecurityControl(SecurityControl sc) {
        if (sc != null) {
            return sc.toString();
        }
        return "null";
    }
}


 最后就是在Spring中配置拦截器。
 <bean id="serviceSecurityInterceptor" class="com.alipay.test.security.SecurityControlInterceptor" />
 <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  <property name="interceptorNames">
   <list>
    <value>serviceSecurityInterceptor</value>
   </list>
  </property>
  <property name="beanNames">
   <value>*Service</value>
  </property>
 </bean>
 拦截器会拦截以Service结尾的类的方法。

 

 五、资源类（Service类）
@SecurityControl(role = { "ROLE_ADMIN", "ROLE_MANAGER" })
public interface SecurityService {
   
    public String getServiceName();
   
    @SecurityControl(perm = { "PERM_CREATE" })
    public void createService(String service);
   
    @SecurityControl(perm = { "PERM_READ" })
    public String getService();
}
 由注解可以看出：
1、 访问该类需要组权限：ROLE_ADMIN或是ROLE_MANAGER，只有该组权限满足后，才能进行类方法的调用；
2、访问方法createService()需要PERM_CREATE单个权限；
 3、访问方法getService()需要PERM_READ权限；
 4、访问方法getServiceName()除了类所需要的权限外，不需要额外权限。
 该接口的实现类：
@Component("securityService")
public class SecurityServiceImpl implements SecurityService {
   
    private String service = SecurityServiceImpl.class.getName();
   
    /**
     * @see com.aboy.SecurityService.test.annotation.service.AnnotationService#createService()
     */
    public void createService(String service) {
        this.service = service;
    }
   
    /**
     * @return
     * @see com.aboy.SecurityService.test.annotation.service.AnnotationService#getService()
     */
    public String getService() {
        return this.service;
    }
   
    /**
     * @return
     * @see com.aboy.SecurityService.test.annotation.service.AnnotationService#getServiceName()
     */
    public String getServiceName() {
        return "ServiceName";
    }
   
}

 

 六、测试
 @Test
public void testSecurityControl() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("META-INF/spring/security-context.xml");
        AnnotationService service = ctx.getBean(SecurityService.class);
       
        Set<String> roles = new HashSet<String>();
        roles.add("ROLE_ADMIN");
       
        Set<String> perms = new HashSet<String>();
        perms.add("PERM_READ");
       
        SecurityControlHolder.set(roles, perms);
       
        logger.info(service.getService());
        logger.info(service.getServiceName());
        service.createService(AnnotationServiceTest.class.getName());
        logger.info(service.getService());
    }


 运行用例发现，不通过，原因里没有PERM_CREATE权限。

 

 到此，整个注解的学习与使用已经结束了。整个权限部分，只有四个主要的类，它们完成的功能相当的简单：拦截以Service结尾的类的方法调用，获取该类和调用的方法的权限，判断权限，如果权限验证通过，则程序继续往下走，否则，抛出异常。