Java-注解(@Annotation)

Java基础

浏览数:227

2019-9-10

一、缘由

    上篇也提到过要开spring cloud系列,但是避免不了就是spring boot,那针对这个我们首先要明白的就是spring boot启动到底帮我做了那些事,明白这些我们后面使用起来的时候就会得心应手,但是你会发现一个问题,那就是spring boot就是通过这些注解去加载的,所以这个地方我要来聊聊注解,当然spring也好多都是注解去实现的,这样我们就要更改明白注解到底是帮我们做了哪些事。

二、什么是注解以及注解的作用(Annotation):

    注解是插入到代码中的元数据,JDK5.0以后的版本引入。注解必须有编译器或者虚拟机来解析它,才能发挥自己的作用,它可以生成文件,可以执行编译时进行测试和验证格式等等。因为本质上,注解是一种特殊的接口,程序可以通过反射来获取指定程序元素的注解对象,然后通过注解对象来获取注解里面的元数据。

    注解的作用:

    1.编写文档:通过代码里标识的元数据生成文档;

    2.代码分析:通过代码里标识的元数据对代码进行分析;

    3.编译检查:通过代码里标识的元数据让编译器能实现基本的编译检查;

二、注解的类型

    1.内置注解

    @Override:表示当前的方法可以覆盖父类中的方法;


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

    @Deprecated:用于标注该方法已经过时,当程序员调用的时候,编译器会发生警告的信息;


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

   @SuppressWarnnings:用于关闭不当的编译器警告;


@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

   内部有个string数组,简单的说一下改数组接收的几个常用的几个参数:

   1.deprecation:使用了由@Deprecated修饰的类或方法时的警告;

   2.unchecked:执行了未检查的转换时的警告;

   3.path:在类路径、源文件路径等中有不存在的路径时的警告;

   4.all:所有情况的警告;

   5.剩下的参考http://www.cnblogs.com/fsjohnhuang/p/4040785.html

   接下来简单的介绍下上面3种使用的方法:


public class Person {

    @Deprecated
    public void getCountryName(){
        System.out.printf("我是地球人");
    }
    
}

public class ChinaPerson extends Person {
    @SuppressWarnings("deprecation")
    @Override
    public void getCountryName(){
        System.out.printf("我是中国人");
    }


}
public class Main {

    public static void main(String[] args) {
        ChinaPerson chinaPerson=new ChinaPerson();
        chinaPerson.getCountryName();
    }
}

   2.元注解

   @Target:用来约束注解可以应用到的地方:


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}

   该注解可以接收一个ElementType数组,该类型是个枚举类型可以接收如下参数:

   1.PACKAGE:标明注解可以用于包声明;

   2.CONSTRUCTOR:标明注解可以用于构造函数声明;

   3.PARAMETER:标明该注解可以用于参数声明;

   4.METHOD:标明该注解可以用于方法声明;

   5.FIELD:标明该注解可以用于字段(域)声明,包括enum实例;

   6.TYPE:标明该注解可以用于类、接口(包括注解类型)或enum声明;

   7.LOCAL_VARIABLE:标明注解可以用于局部变量声明;

   8.ANNOTATION_TYPE:标明注解可以用于注解声明(应用于另一个注解上);

   9.TYPE_PARAMETER:标明注解可以用于类型参数声明(1.8新加入);

   10.TYPE_USE:类型使用声明(1.8新加入);

   @Retention:用来约束注解的生命周期:


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

   可接收的参数如下:

   1.SOURCE:在源文件中有效,被编译器丢弃;

   2.CLASS:在class文件中有效,会被VM丢弃,当没有定义CLASS默认CLASS;

   3.RUNTIME:在运行时有效,可以通过反射机制读取注解的信息;

   @Documented:被修饰的注解会生成到javadoc中


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

   @Inherited:允许子类继承父类的注解,即它所标注的Annotation将具有继承性,通过使用@Inherited,可以让子类Class对象使用getAnnotations()获取父类被@Inherited修饰的注解


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

   3.自定义注解

   使用@interface自定义注解,自动继承了java.lang.annotation.Annotation接口。在定义注解时,不能继承其他的注解或接口。@interface用来声明一个注解,其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称,返回值类型就是参数的类型。可以通过default来声明参数的默认值。

   接下来我们做个简单的案例来体验下:


import java.lang.annotation.*;

/**
 * Created by wangt on 2018/6/17.
 */
@Inherited
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Table {
    String value() default "";
}

import java.lang.annotation.*;

/**
 * Created by wangt on 2018/6/17.
 */
@Inherited
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Column {
    String value() default "";
}


/**
 * Created by wangt on 2018/6/17.
 */
@Table("sutdent")
public class StudentDto {

    @Column("id")
    private String id;

    @Column("username")
    private String name;

    public StudentDto(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}


import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Created by wangt on 2018/6/17.
 */
public class Test {
    public static void main(String[] args){
        StudentDto studentDto=new StudentDto("1","wtz");
        StudentDto studentDto2=new StudentDto("2","www");
        String sql = assembleSqlFromObj(studentDto);
        String sql1 = assembleSqlFromObj(studentDto2);
        System.out.println(sql);
        System.out.println(sql1);
    }

    private static String assembleSqlFromObj(Object object) {
        Table table = object.getClass().getAnnotation(Table.class);
        StringBuffer sbSql = new StringBuffer();
        String tableName = table.value();
        sbSql.append("select * from " + tableName + " where 1=1 ");
        Field[] fileds = object.getClass().getDeclaredFields();
        for (Field f : fileds) {
            String fieldName = f.getName();
            String methodName = "get" + fieldName.substring(0, 1).toUpperCase()
                    + fieldName.substring(1);
            try {
                Column column = f.getAnnotation(Column.class);
                if (column != null) {
                    Method method = object.getClass().getMethod(methodName);
                    String value = (String) method.invoke(object);
                    if (value != null && !value.equals("")) {
                        if (!isNum(column.value()) && !isNum(value)) {
                            // 判断参数是不是 in 类型参数 1,2,3
                            if (value.contains(",")) {
                                sbSql.append(" and " + column.value() + " in (" + value + ") ");
                            } else {
                                sbSql.append(" and " + column.value() + " like '%" + value + "%' ");
                            }
                        } else {
                            sbSql.append(" and " + column.value() + "=" + value + " ");
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return sbSql.toString();
    }

    public static boolean isNum(String target) {
        boolean isNum = false;
        if (target.toLowerCase().contains("id")) {
            isNum = true;
        }
        if (target.matches("\\d+")) {
            isNum = true;
        }
        return isNum;
    }


}

  这个自己想想是啥原理,,哈哈不懂问我。

四、总结

 Java的注解原理是Java的反射机制,要是自定义注解那块没有看懂的话,再去读读反射把,这是一个很重要的东西,有机会我也会写一篇反射方面的;

 欢迎大家加群:438836709,有问题可以咨询我

 欢迎大家关注我微信公众号:

 

作者:大魔王先生