注解

概念

JDK 1.5引入了一个很重要特性就是对元数据(Metadata)的支持，在J2SE 5.0中，这种元数据被称为注解(Annotation),注解可以在不改变原有逻辑的情况下加一些补充信息来说明程序，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

注解作为简化程序配置的一种手段，在Java中一般都是方法前@开头的标注。注解一般应用在哪些方面呢？

• 在程序中写配置信息，这个时候有什么改动都需要修改源文件，非常不便，比如服务器地址改变了，要在源码中修改服务器的地址。注意在配置文件中写配置信息，在配置项不多的情况下挺好用，但是配置项比较多的时候就难以维护了。将配置信息重新写回程序中，利用注解来将配置信息与程序分离，现在基本是注解+配置文件。
• 编写文档，生成doc文档，代码分析，编译检查。

注解基础

Java中可以自定义Annotation，定义时可使用@interface进行标记，同时可使用@Target定义Annotation范围。定义格式为：

元注解
public @interface 注解名称{
    属性列表;
}

注解本质上就是一个接口，该接口默认继承Annotation接口。利用反射获取注解，其实就是在内存中生成了一个该注解接口的子类实现对象。

属性

对于上面属性的返回值要求有几种：

• 基本数据类型
• String
• 枚举
• 注解
• 以上类型的数组

对属性赋值时注意：

1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略。

元注解

元注解是用于描述注解的注解。

• @Target：描述注解能够作用的位置
• @Retention：描述注解被保留的阶段
• @Documented：描述注解是否被抽取到api文档中
• @Inherited：描述注解是否被子类继承

Target

它用于描述注解能够作用的位置，会使用ElementType枚举变量，它的取值如下：

Retention

它用于描述注解被保留的阶段，使用RetentionPolicy枚举变量，它的取值如下：

• SOURCE:这种Annotation类型信息只保留在源文件(.java)中，编译后不会保存在编译好的类文件(.class)中。
• CLASS:此Annotation类型将保留在源文件(.java)和编译后的类文件中(.class)中，使用此类时，Annotation信息不会被加载到虚拟机JVM中。一个注解如果没有指定范围，默认是此范围。
• RUNTIME：此类Annotation信息会被保留在源文件(.java)，类文件(.class)和JVM中。

基本使用

下面是它的基本使用方法：

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


@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface myAnnotation{
    public String name();
    public String info() default "defaultInfo";
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface myOwnAnnotation{
    public String value();
    //public String name();
    public String info() default "defaultInfo";
}


class MyClass{
    @myAnnotation(name="xie")
    public void Info(String info) {
        System.out.println("信息："+info);
    }
    
    //如果注解只有一个需要用户设置的必要属性时，可以使用Value作为属性名称，
    @myOwnAnnotation("li")
    public void Info2(String info2) {
        System.out.println("信息2："+info2);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Method method = MyClass.class.getMethod("Info", String.class);
        myAnnotation myAnno = method.getAnnotation(myAnnotation.class);
        method.invoke(MyClass.class.getDeclaredConstructor().newInstance(), myAnno.name()+":"+myAnno.info());
        
        Method method2 = MyClass.class.getMethod("Info2", String.class);
        myOwnAnnotation myAnno2 = method2.getAnnotation(myOwnAnnotation.class);
        method2.invoke(MyClass.class.getDeclaredConstructor().newInstance(), myAnno2.value()+":"+myAnno2.info());
        
    }
}

常用注解

下面是三个常用注解：

• @Override，标记该方法是要重写父类的方法。
• @Deprecated，标记该方法在后面要被遗弃。
• @SuppressWarnings，压制某类警告信息。 @SuppressWarnings(value={"警告类别"})，它拥有的警告类别有：deprecation，unchecked，fallthrough，path，serial，finally，all。

应用案例

反射获取注解信息

import java.io.Serializable;
import java.lang.annotation.Annotation;

@FunctionalInterface
@Deprecated(since = "9.0")
interface IMyOper{
    public void OpenInfo(String info);
}

@Deprecated(since = "2.0")
@SuppressWarnings("serial")
class Computer implements IMyOper,Serializable{

    @Deprecated(since = "1.0")
    @Override
    public void OpenInfo(String info) {
        // TODO Auto-generated method stub
        System.out.println("hello");
    }
    
}

public class Main {
    public static void main(String[] args) throws Exception {
        PrintAnnotations(IMyOper.class.getAnnotations());
        PrintAnnotations(Computer.class.getAnnotations());
        PrintAnnotations(Computer.class.getDeclaredMethod("OpenInfo", String.class).getAnnotations());
    }
    
    public static void PrintAnnotations(Annotation annotations[]) {
        System.out.println("--------------------");
        for(Annotation temp:annotations) {
            System.out.println(temp);
        }
    }
}

通过反射注解生成新类

下面是通过注解和反射来创建任意类对象，并执行其中某些方法。

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;


class TestClass {
	public void Show() {
		System.out.println("This is my TestClass show method");
	}
}


@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyClassInfo {

    String className();
    String methodName();
}


@MyClassInfo(className = "TestClass",methodName = "Show")
public class Main {
    public static void main(String[] args) throws Exception {
    	Class<Main> reflectTestClass = Main.class;
    	MyClassInfo myAnnotation = reflectTestClass.getAnnotation(MyClassInfo.class);
        String className = myAnnotation.className();
        String methodName = myAnnotation.methodName();
        System.out.println("className:"+className+",methodName:"+methodName);

        Class cls = Class.forName(className);
        Object obj = cls.newInstance();
        Method method = cls.getMethod(methodName);
        method.invoke(obj);
    }
}

简单测试框架

下面通过注解反射来实现一个简单测试框架，下面会对TestClass中有checkError注解的方法进行测试，如果有问题，就写入到error.txt中：

import java.io.BufferedWriter;
import java.io.FileWriter;
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;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface checkError {

}


class TestClass {
	@checkError
	public void Calculate1() {
		int temp = 10/0;
	}

	public void Calculate2() {
		int temp = 10/0;
	}
	
	@checkError
	public void Calculate3() {
		int temp = 100/0;
	}

	public void Show() {
		System.out.println("This is my TestClass show method");
	}
}




public class Main {
    public static void main(String[] args) throws Exception {
    	TestClass targetTestClass = new TestClass();
        Class cls = targetTestClass.getClass();
        Method[] methods = cls.getMethods();

        int number = 0;//出现异常的次数
        BufferedWriter bw = new BufferedWriter(new FileWriter("error.txt"));


        for (Method method : methods) {
            if(method.isAnnotationPresent(checkError.class)){
                try {
                	System.out.println(method.getName());
                    method.invoke(targetTestClass);
                } catch (Exception e) {
                    //记录到文件中
                    number ++;

                    bw.write(method.getName()+ " 方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:"+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();

                }
            }
        }

        bw.write("本次测试一共出现 "+number+" 次异常");

        bw.flush();
        bw.close();
       
    }
}

Annotation整合工厂模式

使用Annotation开发可以将配置信息写入Annotation后，在项目启动时通过反射获取相应Annotation定义并进行操作，下面使用Annotation整合工厂设计模式与代理设计模式。

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


interface IDealInfo{
    public void dealInfo(String info);
}

class Computer implements IDealInfo{

    @Override
    public void dealInfo(String info) {
        // TODO Auto-generated method stub
        System.out.println("computer:"+info);
    }
}

class Phone implements IDealInfo{

    @Override
    public void dealInfo(String info) {
        // TODO Auto-generated method stub
        System.out.println("phone:"+info);
    }
}

class DeviceFactory{
    private DeviceFactory() {};
    public static <T> T GetInstance(Class<T> myClass) {
        try {
            return (T) new UseDeviceProxy().bind(myClass.getDeclaredConstructor().newInstance());
        } catch (Exception e) {
            // TODO: handle exception
            return null;
        }
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface UseDevice{
    public Class<?> myClass();
}

@UseDevice(myClass = Phone.class)
class DealInfoService{
    private IDealInfo iDealInfo;
    
    public DealInfoService() {
        UseDevice useDevice = DealInfoService.class.getAnnotation(UseDevice.class);
        this.iDealInfo = (IDealInfo)DeviceFactory.GetInstance(useDevice.myClass());
    }
    
    public void DealInfo(String msg) {
        this.iDealInfo.dealInfo(msg);

    }
}

class UseDeviceProxy implements InvocationHandler{
    private Object target;
    
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    
    public void Oper1() {
        System.out.println("oper1!");
    }
    public void Oper2() {
        System.out.println("oper2!");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        Oper1();
        Oper2();
        return method.invoke(this.target,args);
    }
    
}



public class Main {
    public static void main(String[] args) throws Exception {
        DealInfoService dealInfoService = new DealInfoService();
        dealInfoService.DealInfo("hello world!");
    }
}