如约所致~ Annotation详细介绍

1.annotation类型(叫法有很多种,官方API这样定义:Annotation Types)

1. @Documented:被这个类型标识(修饰)的annotation  将会被javadoc或其他文档工具提取
2. @Inherited:表示具有继承性，被这个类型标识(修饰)的annotation 它的子类将会自动被它标识(修饰)
3. @Retention:annotation将被保留多长时间
4. @Target:指定被标识(修饰)的annotation 能用于修饰程序的哪些部分(类、方法、成员变量等)

2.两个枚举类ElementType和RetentionPolicy

1. ElementType:枚举了@Target类型的value值
   ElementType.FIELD:用于修饰成员变量
   ElementType.METHOD:用于修饰方法
   当然不止这些,更加详细的可查api或者ide下自己试试
2. RetentionPolicy:枚举了@Retention的value值
   RetentionPolicy.RUNTIME:直到运行时候都会保留的annotation
   RetentionPolicy.CLASS:记录在class文件中,但是运行时不会被保留
   RetentionPolicy.SOURCE:保留在源码中,会被编译器丢弃

3.如何自己定义一个annotation(具体见例子中的注释)

1. 使用@interface关键字，和定义类，定义接口类似
   @interface MyAnnotation{} 这样一个最简单的annotation就定义好了。
2. 定义元数据，暂时可以理解为成员变量
3. 编写一个annotation处理器(通过反射获取annotation信息或者通过实现接口,继承抽象类来完成)

4.例子1简单讲解

1. 我们要做什么？
   原始的Aclass 没有日志，我们现在要给一些方法加上日志的功能(有点AOP思想)
2. 目录结构:
   a.Aclass:一个演示目标类，里面提供了4个方法，有2个打上了@CxyLog标记，当使用annotation处理器去处理的时候会看到打上标记的会输出日志语句。
   b.(不带元数据的)@CxyLog：加上这个标记的就自动加上打印日志功能
    c.CxyLogAp：annotation处理器，这里主要处理@CxyLog
3. 说明：
   1.一个很简单的例子，意在演示：如何创建一个annotation和annotation处理器，并让其工作起来
   2.本例借助的是AOP的概念，但是绝对不是实现AOP。所以程序运行时并不是一个一个方法去调用。
   3.实现AOP需要涉及接口、反射、动态代理、aop概念等等知识，这里只是单纯的做annotation的介绍。

5.例子2简单讲解

1. 我们要做什么？
   根据权限动态装配对应的类(bo)
2. 目录结构
   a.CxyAction:测试目标类，提供了两个不同权限的方法
   b.CxyBo:一个接口为了演示动态装配而生
   c.CxyCommonBo:普通权限的bo,实现CxyBo接口
   d.CxyAdvancedBo:高级权限的bo,实现CxyBo接口
   e.@CxyAuthority:标记方法的权限及对应权限的实现类
   f.CxyAuthorityAp：@CxyAuthority的处理器
3. 说明：
   1.本例演示了一个带元数据的annotation，并根据元数据信息(authority和boName)来动态装配bo。
   2.本例仅仅是演示annotation用法，实际工作中并不会这样去控制权限或者装配bo。
   3.authority和boName的存在貌似有些重复，那是因为这个例子里authority和boName是一对一的关系，如果是多对多的关系，这两个元信息就不会觉得是重复的了。

6.总结一下 看看我们干了什么？

• 其实就是给程序的某个部位(类、成员变量、方法等)打了一个标记，这个标记其实没什么大不了(不复杂不深奥顶多就是一个程序注释)
• 但是如果你自己写了一个annotation处理器去处理这个标记的话，那么它能为你做到很多很多。

说明：本例只是阐述annotation的详细用法，我会尽快出一个较为有意义的实例应用文章。

 

例一：

package com.cxy.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;

/**
 * @author cxy
 */
public class AnnotationDetailTest
{
	public static void main(String[] args) throws Exception
	{
		CxyLogAp.Processor(Aclass.class);
	}
}

/**
 * 一个测试用的类，这个类的method1和method3被@CxyLog标记
 */
class Aclass
{
	@CxyLog
	public static void method1(){System.out.println("method1执行");}
	public static void method2(){System.out.println("method2执行");}
	@CxyLog
	public static void method3(){System.out.println("method3执行");}
	public static void method4(){System.out.println("method4执行");}
}

/**
 * 一个简单的annotation，打上这个标记的我们就给这个方法加入日志打印功能
 * 1.@Retention(RetentionPolicy.RUNTIME) 解释：保留注释到程序运行
 * 2.@Target(ElementType.METHOD) 解释：这个annotation是标记在方法上的
 */
@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
@interface CxyLog{} 


/**这个类是@CxyLog的annotation处理器
 */
class CxyLogAp
{
	//处理器 处理@CxyLog标记
	public static void Processor(Class clz) throws Exception
	{
		for(Method m:clz.getMethods())
		{
			//如果当前访问的方法打上了@CxyLog标识，那么就加入打印语句
			if(m.isAnnotationPresent(CxyLog.class))
			{
				m.invoke(null);
				System.out.println("日志："+clz+"."+m.getName()+"执行！");
			}else
			{
				//因为他会执行所有的方法，包括父类的很多方法，所以这里我们限定一下只做我们定义的method开头的方法
				if(m.getName().contains("method"))
				{
					m.invoke(null);
				}
			}
		}
	}
}

 

结果图：

    
 

例二：

package com.cxy.annotation;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;

/**
 * @author cxy
 */
public class AnnotationDetailTest1
{
	public static void main(String[] args) throws Exception
	{
		CxyAction.commonAuthoritymethod();
		CxyAction.advanceAuthoritymethod();
		System.out.println("=============================");
		//以下面的两种方式执行这两个方法
		CxyAuthorityAp.Processor(CxyAction.class, "commonAuthoritymethod");
		System.out.println("------------------------------");
		CxyAuthorityAp.Processor(CxyAction.class, "advanceAuthoritymethod");
	}
}

/** 测试目标类，提供了两个不同权限的方法
 */
class CxyAction
{
	public static CxyBo bo=new CxyCommonBo(); //初始时候装配的是普通权限的bo
	
	//普通权限就能访问的方法
	@CxyAuthority(authority="c",boName=CxyCommonBo.class)
	public static void commonAuthoritymethod()
	{
		bo.doSomething();
	} 
	
	//高级权限能访问的方法 
	@CxyAuthority(authority="a",boName=CxyAdvancedBo.class)
	public static void advanceAuthoritymethod()
	{
		bo.doSomething();
	} 
}

/** 一个接口为了演示动态装配而生
 */
interface CxyBo
{
	public void doSomething();
}

/** 普通权限的bo
 */
class CxyCommonBo implements CxyBo
{
	//普通业务逻辑
	@Override
	public void doSomething()
	{
		System.out.println("执行：普通权限处理方法");
	}
}

/** 高级权限的bo
 */
class CxyAdvancedBo implements CxyBo
{
	//高级业务逻辑
	@Override
	public void doSomething()
	{
		System.out.println("执行：高级权限处理方法");
	}
}

//权限annotation，根据这个标记的authority值来判断装配哪个业务逻辑类
@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
@interface CxyAuthority
{
	String authority(); //代表权限
	Class boName(); //代表这个权限用什么bo去处理
}

/**这个类是@CxyAuthority的annotation处理器
 */
class CxyAuthorityAp
{
	//处理器 处理@CxyAuthority标记
	public static void Processor(Class clz,String methodName) throws Exception
	{
		Method m=clz.getMethod(methodName, null); //获得指定类的指定方法
		Annotation[] aArray=m.getAnnotations(); //获得方法所有的annotation
		for(Annotation one:aArray)
		{
			if(one instanceof CxyAuthority)
			{
				CxyBo tempBo=(CxyBo) ((CxyAuthority)one).boName().newInstance();
				if("c".equals(((CxyAuthority)one).authority()))
				{
					System.out.println("装配信息：普通权限bo装配成功");
					//这里还可以做一些权限控制的操作
				}else if("a".equals(((CxyAuthority)one).authority()))
				{
					System.out.println("装配信息：高级权限bo装配成功");
					//这里还可以做一些权限控制的操作
				}
				tempBo.doSomething();
			}
		}
	}
}

 结果图：

    
 

 

声明：

1.原创文章，转载请标明并加本文连接。

2.文章反映个人愚见，如有异议欢迎讨论指正

评论

12 楼 naoda 2013-06-25  

分析的很透彻，什么时候出下一篇：“有意义的实例应用文章”。

11 楼 snkcxy 2013-03-07  

ankonlcy 写道

楼主的文章很实在，例子非常的不错！赞！学习了！

leo123456 写道

例子很生动，以前一知半解的，静心看看还是学到更多，期待新的分享！

呵呵 谢谢大家的支持~

10 楼 ankonlcy 2013-03-07  

楼主的文章很实在，例子非常的不错！赞！学习了！

9 楼 leo123456 2013-03-07  

例子很生动，以前一知半解的，静心看看还是学到更多，期待新的分享！

8 楼 www314599782 2013-03-06  

很不错啊，收下了

7 楼 Androclus 2013-03-06  

不错，很实用，在项目中尝试了一下，很好用，有些地方反而给代码增加了可读性。
以前真没关注过这个东西，学习了~期待新作~

6 楼 snkcxy 2013-03-05  

CarzyW 写道

够专业  够细致

谢谢捧场~

5 楼 CarzyW 2013-03-05  

够专业  够细致

4 楼 xlaohe1 2013-03-05  

snkcxy 写道

晕 忘了写了 看这个之前 建议先看http://snkcxy.iteye.com/blog/1820951
这篇文章~

就是从这一篇跳到这里来的。
支持楼主。

3 楼 snkcxy 2013-03-05  

晕 忘了写了 看这个之前 建议先看http://snkcxy.iteye.com/blog/1820951
这篇文章~

2 楼 snkcxy 2013-03-05  

xlaohe1 写道

不错，期待下一篇，在来个AOP。。 

呵呵AOP需要动态代理 这个看时间吧 争取吧
下一篇实例 我觉得还是有些实用价值的，我会尽快出的~
感谢支持~

1 楼 xlaohe1 2013-03-05  

不错，期待下一篇，在来个AOP。。