Java Annotation的一些学习

 

1.使用注解实现生成器

1）生成器模式原始代码：
PC类：

public class PC {
    private String CPU;
    private String HDD;
    private String RAM;
    private String GPU;

    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public void setHDD(String HDD) {
        this.HDD = HDD;
    }

    public void setRAM(String RAM) {
        this.RAM = RAM;
    }

    public void setGPU(String GPU) {
        this.GPU = GPU;
    }

    public void show(){
        System.out.println("This is a PC with:"+CPU+","+RAM+","+HDD+","+GPU);
    }
}

PCBuilder类：

public abstract class PCBuilder {
    protected PC pc=new PC();

    public abstract void buildCPU(String CPU);
    public abstract void buildRAM(String RAM);
    public abstract void buildHDD(String HDD);
    public abstract void buildGPU(String GPU);

    public PC getPC(){
        return pc;
    }
}

OEMPC类：

public class OEMPC extends PCBuilder {

    @Override
    public void buildCPU(String CPU) {
        pc.setCPU(CPU);
    }

    @Override
    public void buildRAM(String RAM) {
        pc.setRAM(RAM);
    }

    @Override
    public void buildHDD(String HDD) {
        pc.setHDD(HDD);
    }

    @Override
    public void buildGPU(String GPU) {
        pc.setGPU(GPU);
    }
}

Director类：

public class Director {
    private PCBuilder builder;

    public Director(PCBuilder builder) {
        this.builder = builder;
    }

    public void create(String CPU,String RAM,String HDD,String GPU){
        builder.buildCPU(CPU);
        builder.buildRAM(RAM);
        builder.buildHDD(HDD);
        builder.buildGPU(GPU);
        builder.getPC().show();
    }
}

主函数：

public static void main(String[] args) 
{
    Director lenovo=new Director(new OEMPC());
    lenovo.create("Intel Core i5 8300H","8GB","128GB+1TB","nVidia Geforce GTX1050ti");
}

 输出：

This is a PC with:Intel Core i5 8300H,8GB,128GB+1TB,nVidia Geforce GTX1050ti

2）实现注解：
Generate注解接口：

@Retention(RetentionPolicy.RUNTIME)  
/*作用范围，作用范围有三个：
SOURCE:作用范围是源码，作用于Java文件中，当执行javac时去除该注解。
CLASS：作用范围是二进制码，就是存在于class文件中，当执行Java时去除该注解。
RUNTIME：作用范围为运行时，就是我们可以通过动态获取该注释。
*/
@Inherited
@Documented
@Target(ElementType.TYPE)   //作用域，TYPE为类，METHOD为方法，FIELD为字段
public @interface Generate {
    String CPU() default "Intel Core i5 8300H";
    String RAM() default "8GB";
    String HDD() default "128GB+1TB";
    String GPU() default "nVidia Geforce GTX1050ti";
}

GenerateHandler类：

public class GenerateHandler {
    public void generate() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class appClazz=Class.forName("annotation.Application");
        Field field=appClazz.getDeclaredField("pc");  //如果是Class::getField方法，只能获取到public字段
        PC p= (PC) field.getType().newInstance();
        Generate g= (Generate) appClazz.getAnnotation(Generate.class);
        p.setCPU(g.CPU());
        p.setRAM(g.RAM());
        p.setHDD(g.HDD());
        p.setGPU(g.GPU());
        p.show();
    }
}

主类（Application）：

@Generate
public class Application {
    PC pc;

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Director lenovo=new Director(new OEMPC());
        lenovo.create("Intel Core i5 8300H","8GB","128GB+1TB","nVidia Geforce GTX1050ti");
        GenerateHandler handler=new GenerateHandler();
        handler.generate();
    }
}

输出：

This is a PC with:Intel Core i5 8300H,8GB,128GB+1TB,nVidia Geforce GTX1050ti
This is a PC with:Intel Core i5 8300H,8GB,128GB+1TB,nVidia Geforce GTX1050ti

修改Generate注解：

@Generate(CPU="Intel Core i7 8750H",GPU="nVidia Geforce GTX 1060")

结果：

This is a PC with:Intel Core i7 8750H,8GB,128GB+1TB,nVidia Geforce GTX 1060

2.实现类似Spring自动扫描效果（仅仅是类名比较像，Spring的实现肯定复杂得多）

主类：

@MyApplication
public class Main {
    public static void main(String[] args) {
        Application.run(Main.class);
    }
}

Application类：

public class Application {

    public static void run(Class<? extends Object> clazz) {
        Annotation my=clazz.getAnnotation(YhcApplication.class);
        //如果没有@MyApplication就不正常启动 
        if(my==null){
            throw new IllegalStateException("Application Class without @MyApplication is illegal!");
        }
        try {
            //扫描主类所处包下面所有类
            System.out.println("Scanning classes……");
            File[] classFiles=new File(System.getProperty("user.dir")+"\\src\\main\\java\\"+clazz.getPackage().getName()).listFiles();
            Class[] classes=new Class[classFiles.length];
            for(int i=0;i<classFiles.length;i++){                     
                classes[i]=Class.forName(clazz.getPackage().getName()+"."+classFiles[i].getName().replace(".java",""));
            }
            //模拟拦截请求
            System.out.println("Ready to get request……");
            Scanner sc=new Scanner(System.in);
            String context=sc.nextLine();
            //扫描类的所有方法       
            loop:
            for(int i=0;i<classes.length;i++){
                Method[] methods=classes[i].getMethods();
                for(int j=0;j<methods.length;j++){
                 if(methods[j].getAnnotation(RequestMapping.class).value().equals(context)){
                       //反射调用匹配到的方法，然后跳出循环          
                        methods[j].invoke(classes[i].newInstance());
                        break loop;
                    }
                }
            }
        }catch (Throwable e){
            e.printStackTrace();
        }
    }
}

注解：

@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Target(ElementType.TYPE)
public @interface MyApplication {

}

@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Target(ElementType.METHOD)
public @interface RequestMapping {
    String value();
}

Controller类：

写了两个类、三个方法来验证：

public class AController {

    @RequestMapping("A")
    public void printA(){
        System.out.println("Hello A!");
    }

    @RequestMapping("C")
    public void printC(){
        System.out.println("Hello C!");
    }
}

public class BController {

    @RequestMapping("B")
    public void printB(){
        System.out.println("Hello B!");
    }
}

运行：

1）注释掉@YhcApplication：

Exception in thread "main" java.lang.IllegalStateException: Application Class without @MyApplication is illegal!
at annotation.Application.run(Application.java:12)
at annotation.Main.main(Main.java:6)

Process finished with exit code 1

2）正常运行&输入 A ：

Scanning classes……
Ready to get request……
A
Hello A!