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

2009-10-19 14:25:53|  分类： |  标签： |字号大中小 

 

 

      权限控制是保护系统安全运行很重要的一扇门。在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相关

Access

 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}

 

AccessOption

 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}

 

UserAccessOption

 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类

AccessAction

 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）拦截器

AccessInterceptor

 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

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