一、注解基本知识
1、元注解
元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。
1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
2. 参数成员只能用public或默认(default)这两个访问权修饰
3. 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
4. 要获取类方法和字段的注解信息,必须通过Java的反射技术来获取 Annotation对象,因为你除此之外没有别的获取注解对象的方法
5. 注解也可以没有定义成员, 不过这样注解就没啥用了
自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效), 是否将注解包含在javadoc中及是否允许子类继承父类中的注解, 具体如下:
1. @Target 表示该注解目标,可能的 ElemenetType 参数包括:
1
2
3
4
5
6
7
|
ElemenetType.CONSTRUCTOR 构造器声明 ElemenetType.FIELD 域声明(包括 enum 实例) ElemenetType.LOCAL_VARIABLE 局部变量声明 ElemenetType.METHOD 方法声明 ElemenetType.PACKAGE 包声明 ElemenetType.PARAMETER 参数声明 ElemenetType.TYPE 类,接口(包括注解类型)或 enum 声明 |
2. @Retention 表示该注解的生命周期,可选的 RetentionPolicy 参数包括
1
2
3
|
RetentionPolicy.SOURCE 注解将被编译器丢弃 RetentionPolicy.CLASS 注解在 class 文件中可用,但会被VM丢弃 RetentionPolicy.RUNTIME VM将在运行期也保留注释,因此可以通过反射机制读取注解的信息 |
3. @Documented 指示将此注解包含在 javadoc 中
4. @Inherited 指示允许子类继承父类中的注解
二、在java中如何使用
2.1、定义注解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
package com.test.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; public class MyAnnotation { /** * 注解类 * @author T4980D * */ @Retention (RetentionPolicy.RUNTIME) @Target (ElementType.TYPE) public @interface MyClassAnnotation { String uri(); String desc(); } /** * 构造方法注解 * @author T4980D * */ @Retention (RetentionPolicy.RUNTIME) @Target (ElementType.CONSTRUCTOR) public @interface MyConstructorAnnotation { String uri(); String desc(); } /** * 我的方法注解 * @author Owner * */ @Retention (RetentionPolicy.RUNTIME) @Target (ElementType.METHOD) public @interface MyMethodAnnotation { String uri(); String desc(); } /** * 字段注解定义 * @author Owner * */ @Retention (RetentionPolicy.RUNTIME) @Target (ElementType.FIELD) public @interface MyFieldAnnotation { String uri(); String desc(); } /** * * 可以同时应用到类上和方法上 * @author T4980D * */ @Target ({ElementType.TYPE, ElementType.METHOD}) @Retention (RetentionPolicy.RUNTIME) public @interface Yts { // 定义枚举 public enum YtsType { util, entity, service, model } // 设置默认值 public YtsType classType() default YtsType.util; // 数组 int [] arr() default { 3 , 7 , 5 }; String color() default "blue" ; } } |
2.2、基本测试注解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
package com.test.annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import com.test.annotation.MyAnnotation.MyClassAnnotation; import com.test.annotation.MyAnnotation.MyConstructorAnnotation; import com.test.annotation.MyAnnotation.MyFieldAnnotation; import com.test.annotation.MyAnnotation.MyMethodAnnotation; import com.test.annotation.MyAnnotation.Yts; import com.test.annotation.MyAnnotation.Yts.YtsType; @MyClassAnnotation (desc = "The class" , uri = "com.test.annotation.Test" ) @Yts (classType =YtsType.util) public class TestAnnotation { @MyFieldAnnotation (desc = "The class field" , uri = "com.test.annotation.Test#id" ) private String id; @MyConstructorAnnotation (desc = "The class constructor" , uri = "com.test.annotation.Test#MySample" ) public TestAnnotation() { } public String getId() { return id; } @MyMethodAnnotation (desc = "The class method" , uri = "com.test.annotation.Test#setId" ) public void setId(String id) { System.out.println( " method info: " +id); this .id = id; } @MyMethodAnnotation (desc = "The class method sayHello" , uri = "com.test.annotation.Test#sayHello" ) @Yts public void sayHello(String name){ if (name == null || name.equals( "" )){ System.out.println( "hello world!" ); } else { System.out.println(name + "\t:say hello world!" ); } } public static void main(String[] args) throws Exception { Class<TestAnnotation> clazz = TestAnnotation. class ; // 得到类注解 MyClassAnnotation myClassAnnotation = clazz.getAnnotation(MyClassAnnotation. class ); System.out.println(myClassAnnotation.desc() + " " + myClassAnnotation.uri()); // 得到构造方法注解 Constructor<TestAnnotation> cons = clazz.getConstructor( new Class[]{}); MyConstructorAnnotation myConstructorAnnotation = cons.getAnnotation(MyConstructorAnnotation. class ); System.out.println(myConstructorAnnotation.desc() + " " + myConstructorAnnotation.uri()); // 获取方法注解 Method method = clazz.getMethod( "setId" , new Class[]{ int . class }); MyMethodAnnotation myMethodAnnotation = method.getAnnotation(MyMethodAnnotation. class ); System.out.println(myMethodAnnotation.desc() + " " + myMethodAnnotation.uri()); // 获取字段注解 Field field = clazz.getDeclaredField( "id" ); MyFieldAnnotation myFieldAnnotation = field.getAnnotation(MyFieldAnnotation. class ); System.out.println(myFieldAnnotation.desc() + " " + myFieldAnnotation.uri()); } } |
2.3、通过反射解析
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
package com.test.annotation; import java.lang.reflect.Method; import java.util.Arrays; import com.test.annotation.MyAnnotation.MyClassAnnotation; import com.test.annotation.MyAnnotation.MyMethodAnnotation; import com.test.annotation.MyAnnotation.Yts; import com.test.annotation.MyAnnotation.Yts.YtsType; public class ParseAnnotation { /** * 解析方法注解 * @param <T> * @param clazz */ public static <T> void parseMethod(Class<T> clazz) { try { T obj = clazz.newInstance(); for (Method method : clazz.getDeclaredMethods()) { MyMethodAnnotation methodAnnotation = method.getAnnotation(MyMethodAnnotation. class ); if (methodAnnotation!= null ) { //通过反射调用带有此注解的方法 method.invoke(obj, methodAnnotation.uri()); } Yts yts = (Yts) method.getAnnotation(Yts. class ); if (yts != null ) { if (YtsType.util.equals(yts.classType())) { System.out.println( "this is a util method" ); } else { System.out.println( "this is a other method" ); } System.out.println(Arrays.toString(yts.arr())); //打印数组 System.out.println(yts.color()); //输出颜色 } System.out.println( "\t\t-----------------------" ); } } catch (Exception e) { e.printStackTrace(); } } /** * 解析类注解 * @param <T> * @param clazz */ public static <T> void parseType(Class<T> clazz) { try { Yts yts = (Yts) clazz.getAnnotation(Yts. class ); if (yts != null ) { if (YtsType.util.equals(yts.classType())) { System.out.println( "this is a util class" ); } else { System.out.println( "this is a other class" ); } } MyClassAnnotation classAnnotation = (MyClassAnnotation) clazz.getAnnotation(MyClassAnnotation. class ); if (classAnnotation != null ) { System.err.println( " class info: " +classAnnotation.uri()); } } catch (Exception e) { e.printStackTrace(); } } public static void main(String[] args) { parseMethod(TestAnnotation. class ); parseType(TestAnnotation. class ); } } |
三、注解应用案例
3.1、关于细粒度权限拦截的问题,在Struts2中可以根据登录用户所具有的的权限进行任一一个action方法的拦截,可以定义一个自定义方法注解,例如
1
2
3
4
5
6
7
8
9
10
|
@Retention (RetentionPolicy.RUNTIME) //代表Permission注解保留在的阶段 @Target (ElementType.METHOD) //标注在方法上面 public @interface Permission { /** 模块 */ String module(); /** 权限值 */ String privilege(); } |
3、2 比如有一个部门action,Department.action,有一个方法public String departmentlistUI(){}可以这样定义方法
1
2
3
4
|
@Permission (module= "department" ,privilege= "view" ) public String departmentlistUI(){ } |
3.3、然后自定定义一个权限拦截器PrivilegeInterceptor.java并在struts.xml中注册,在实现interceptor接口后,实现方法public String intercept(ActionInvocation invocation) throws Exception {},在这里调用任一个action方法都会经过该拦截方法,通过invocation可以获取当前调用的action的名字,以及调用的action的哪个方法,通过这段代码可以获取action名字和方法名。
1
2
3
4
|
String actionName=invocation.getProxy().getActionName(); String methodName=invocation.getProxy().getMethod(); System.out.println( "拦截到:action的名字:" +actionName+ "方法名:" +methodName); |
4、然后通过反射技术,获取该方法上的自定义权限注解,获取当前登录的用户(从session中),遍历当前用户的所拥有的权限组,并且遍历任一个权限组下的所有的权限,看是否包括该方法上注解所需的权限。这样就可以完成细粒度的action方法权限拦截了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
private boolean validate(ActionInvocation invocation) throws SecurityException, NoSuchMethodException { String methodName=invocation.getProxy().getMethod(); Method currentMethod = invocation.getAction().getClass().getMethod(methodName); if (currentMethod != null && currentMethod.isAnnotationPresent(Permission. class )){ //得到方法上的注解 Permission permission = currentMethod.getAnnotation(Permission. class ); //该方法上的所需要的权限 SystemPrivilege methodPrivilege = new SystemPrivilege( new SystemPrivilegePK(permission.module(), permission.privilege())); //得到当前登录的用户 Employee e = (Employee) ActionContext.getContext().getSession().get( "loginUser" ); //遍历当前用户下的所有的权限组 for (PrivilegeGroup group : e.getGroups()){ //如果该权限组下包含,要访问该方法所需要的权限,就放行 if (group.getPrivileges().contains(methodPrivilege)){ return true ; } } //说明遍历的该用户所有的权限组,没有发现该权限,说明没有该权限 return false ; } //没有标注注解,表示谁都可以调用该方法 return true ; } |
感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!