如约所致~ Annotation详细介绍

转自：http://snkcxy.iteye.com/blog/1821512

 

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.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();
            }
        }
    }
}

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();
			}
		}
	}
}

 结果图：