Struts2中基于Annotation的细粒度权限控制

【晋哥哥原创】转载请保留此信息：http://shoru.cnblogs.com/

      权限控制是保护系统安全运行很重要的一扇门。在web应用里，仅仅隐藏url是不够的。由于web应用是以请求/响应为单位的，我们的权限控制的粒度只有达到这个程度才能让全国人民放心。在java web开发的世界里，MVC框架的使用再平常不过，大都是将请求拦截后，控制器根据配置文件将请求转给某个函数来处理。下面看看在struts2中我们可以用的几种方案：
      1、在每个函数里进行权限校验
      这主意实在是简单，缺点我就不说了~太多了~
      2、在每个请求对应的Action的配置项里配置参数，用以标示访问此Action需要的权限，再用拦截器处理
      以前我这么做过，比方案1好很多，不过这注定你无法实现ZeroConfig。在ROR的促进下，约定优于配置渐渐深入人心。本人就极其反感大量的配置文件。但是由于权限配置提到XML里配置，最大的好处就是我不必重新编译代码就能改变权限关联。不过情况下遇到需求变更，你会有一种宁可去改代码的冲动。
      3、结合Java的Annotation和Struts2的拦截器控制权限
      下面是上午没事写的一个示例：访问login.jsp，登录，功能有eat和drink，用户登陆后只能访问已授权的功能链接。
      基本思想：对每个Action方法进行注解，并注入一个资源字符串，部署一个拦截器，在每个请求之前拦截一下，通过反射拿到所调用的方法及其注解，依此来进行权限校验。
      优点：
      简单、可行性高
      不修改MVC框架配置文件
      不影响Action内的业务逻辑
      注解的原则之一就是不影响代码的运行，这也实现了本方案的可插拔性、独立性高
      更高的可配置性
      缺点：
      不知道对性能影响如何

      代码基本上都贴到下面了，不想细讲了，有兴趣的可以留言讨论，觉得我火星的就不要拍砖了，有需要eclipse工程源码的发邮件问我要shoru#163.com。



      （1）Annotation相关

 1package com.shoru.access;
 2
 3import java.lang.annotation.ElementType;
 4import java.lang.annotation.Retention;
 5import java.lang.annotation.RetentionPolicy;
 6import java.lang.annotation.Target;
 7
 8/** *//**
 9 * 访问控制注解
10 * 该注解保留到运行时，针对方法使用，默认为BLOCK
11 * @author Shoru
12 * @version 0.1
13 */
14@Retention(RetentionPolicy.RUNTIME)
15@Target(ElementType.METHOD)
16public @interface Access {
17    String[] value() default { AccessOption.BLOCK };
18}

 1package com.shoru.access;
 2
 3/** *//**
 4 * 访问控制接口，定义默认的控制常量
 5 * @author Shoru
 6 * @version 0.1
 7 */
 8public interface AccessOption {
 9    /** *//**
10     * 拦截访问
11     */
12    public static String BLOCK="block";
13    /** *//**
14     * 通过访问
15     */
16    public static String PASS="pass";
17    /** *//**
18     * 要求登录
19     */
20    public static String LOGIN="login";
21}

 1package com.shoru.access;
 2
 3
 4/** *//**
 5 * 用户自定义控制接口，继承自AccessOption
 6 * 可将系统权限全部定义到此处，格式为：权限名=资源名
 7 * @author Shoru
 8 * @see AccessOption
 9 */
10public interface UserAccessOption extends AccessOption {
11    public static String EAT = "eat";
12    public static String DRINK = "drink";
13}

      （2）Action类

 1package com.shoru.access.action;
 2
 3import java.util.ArrayList;
 4import java.util.List;
 5
 6import com.opensymphony.xwork2.Action;
 7import com.opensymphony.xwork2.ActionContext;
 8import com.shoru.access.Access;
 9import com.shoru.access.UserAccessOption;
10
11public class AccessAction implements Action {
12    @Access
13    public String execute() throws Exception {
14        return SUCCESS;
15    }
16
17    @Access(UserAccessOption.PASS)
18    public String index() throws Exception {
19        /**//*
20         * 此处模拟权限的获取
21         */
22        List<String> accessPoints = new ArrayList<String>();
23        /**//*
24         * 赋予eat权限
25         */
26        accessPoints.add("eat");
27        ActionContext.getContext().getSession().put("access", accessPoints);
28        return SUCCESS;
29    }
30
31    @Access(UserAccessOption.DRINK)
32    public String drink() throws Exception {
33        return SUCCESS;
34    }
35
36    @Access( { UserAccessOption.EAT })
37    public String eat() throws Exception {
38        return SUCCESS;
39    }
40}

      （3）拦截器

 1package com.shoru.access.interceptor;
 2
 3import java.lang.annotation.Annotation;
 4import java.lang.reflect.Method;
 5import java.util.List;
 6
 7import com.opensymphony.xwork2.ActionContext;
 8import com.opensymphony.xwork2.ActionInvocation;
 9import com.opensymphony.xwork2.interceptor.Interceptor;
10import com.opensymphony.xwork2.util.AnnotationUtils;
11import com.shoru.access.Access;
12import com.shoru.access.AccessOption;
13
14public class AccessInterceptor implements Interceptor {
15
16    private static final long serialVersionUID = -1066389312400000758L;
17
18    List<String> accessPoints = null;
19
20    public void init() {
21
22    }
23
24    public void destroy() {
25        accessPoints = null;
26    }
27
28    public String intercept(ActionInvocation invocation) throws Exception {
29        if (accessPoints == null) {
30            /**//*
31             * 获取权限列表
32             */
33            accessPoints = (List<String>) ActionContext.getContext()
34                    .getSession().get("access");
35        }
36        /**//*
37         * 获取此次调用的方法名
38         */
39        String method = invocation.getProxy().getMethod();
40        /**//*
41         * 获取所有已注解方法
42         */
43        List<Method> methods = AnnotationUtils.findAnnotatedMethods(invocation
44                .getAction().getClass(), Access.class);
45        /**//*
46         * 迭代所有已注解方法
47         */
48        for (Method m : methods) {
49            if (m.getName().equals(method)) {
50                /**//*
51                 * 获取被调用方法的注解
52                 */
53                Annotation annotation = m.getAnnotation(Access.class);
54                /**//*
55                 * 放过不需要校验权限列表的请求，e.g.登录、验证码
56                 */
57                for (String s : ((Access) annotation).value()) {
58                    if (s.equals(AccessOption.PASS)) {
59                        return invocation.invoke();
60                    }
61                }
62                /**//*
63                 * 权限列表为空，返回登录
64                 */
65                if (accessPoints == null) {
66                    return AccessOption.LOGIN;
67                }
68                /**//*
69                 * 迭代方法注解里的值，判断是否存在于权限列表中
70                 */
71                for (String s : ((Access) annotation).value()) {
72                    if (accessPoints.indexOf(s) != -1) {
73                        /**//*
74                         * 权限校验通过
75                         */
76                        return invocation.invoke();
77                    }
78                }
79            }
80        }
81        /**//*
82         * 没有对方法进行注解或者权限校验不通过，拦截此次请求
83         */
84        return AccessOption.BLOCK;
85    }
86}

      （4）struts.xml

 1<?xml version="1.0" encoding="UTF-8"?>
 2<!DOCTYPE struts PUBLIC
 3    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
 4    "http://struts.apache.org/dtds/struts-2.0.dtd">
 5<struts>
 6    <package name="access" extends="struts-default">
 7        <interceptors>
 8            <!-- 权限拦截器 -->
 9            <interceptor name="access"
10                class="com.shoru.access.interceptor.AccessInterceptor"></interceptor>
11            <interceptor-stack name="my-default">
12                <interceptor-ref name="access"></interceptor-ref>
13                <interceptor-ref name="defaultStack"></interceptor-ref>
14            </interceptor-stack>
15        </interceptors>
16        <default-interceptor-ref name="my-default"></default-interceptor-ref>
17        <global-results>
18            <result name="block">/login.jsp</result>
19            <result name="login">/login.jsp</result>
20        </global-results>
21        <!-- Zero Config All Actions -->
22        <action name="*" class="com.shoru.access.action.AccessAction"
23            method="{1}">
24            <result>/{1}.jsp</result>
25        </action>
26    </package>
27</struts>