java注解简单使用

java注解可以比喻成标签，可以贴在任何地方，也可以限制只能贴在固定地方，比如类上方、方法上方、属性[字段]上方等，然后通过反射，判断是否存在这个注解。

 

注解形式

public @interface Test {
}

应用

//类上
@Test
public class Entity{
   // 属性上
    @Test
    private int id;
    //方法上
    @Test
    public void test(){
    }
}

元注解

元注解是什么意思呢？

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

如果难于理解的话，你可以这样理解。元注解也是一张标签，但是它是一张特殊的标签，它的作用和目的就是给其他普通的标签进行解释说明的。

元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。

@Retention

Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。

它的取值如下：

• RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

@Documented

顾名思义，这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。

@Target

Target 是目标的意思，@Target 指定了注解运用的地方。

你可以这样理解，当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。

类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。@Target 有下面的取值

• ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
• ElementType.CONSTRUCTOR 可以给构造方法进行注解
• ElementType.FIELD 可以给属性进行注解
• ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
• ElementType.METHOD 可以给方法进行注解
• ElementType.PACKAGE 可以给一个包进行注解
• ElementType.PARAMETER 可以给一个方法内的参数进行注解
• ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举

@Inherited

Inherited 是继承的意思，但是它并不是说注解本身可以继承，而是说如果一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。

 

例子

打印实体类的sql查询语句

注解Test_Table，用于注解类，数据库表注解

package com.xiaostudy.test;

import java.lang.annotation.*;

//RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
//RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
//RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。
@Retention(RetentionPolicy.RUNTIME)
//它的作用是能够将注解中的元素包含到 Javadoc 中去。
@Documented
//ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
//ElementType.CONSTRUCTOR 可以给构造方法进行注解
//ElementType.FIELD 可以给属性进行注解
//ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
//ElementType.METHOD 可以给方法进行注解
//ElementType.PACKAGE 可以给一个包进行注解
//ElementType.PARAMETER 可以给一个方法内的参数进行注解
//ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
@Target(ElementType.TYPE)
public @interface Test_Table {
    String value();
}

注解Test_Column，注解属性，数据库列注解

package com.xiaostudy.test;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.FIELD)
public @interface Test_Column {
    String value();
}

student类

package com.xiaostudy.test;

@Test_Table("t_student")
public class Student {
    @Test_Column("id")
    private int id;

    @Test_Column("name")
    private String name;

    @Test_Column("age")
    private int age;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

 

测试

package com.xiaostudy.test;

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

public class Test {

    public static void main(String[] agrs) {
        Student student = new Student();
        student.setId(333);
        student.setName("xiaostudy,xiaoming");
        student.setAge(23);
        System.out.println(querySql(student));
    }

    private static String querySql(Object f) {
        StringBuilder sql = new StringBuilder();
        //获取到class
        Class c1 = f.getClass();
        //获取table的名字
        boolean exists = c1.isAnnotationPresent(Test_Table.class);
        if(!exists) {
            return null;
        }
        Test_Table t = (Test_Table)c1.getAnnotation(Test_Table.class);
        //定义表名
        String tableName = t.value();
        sql.append("select * from ").append(tableName).append(" where 1=1 ");
        //遍历所有的字段
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            //判断是否存在这个注解
            boolean Fexists = field.isAnnotationPresent(Test_Column.class);
            if(!Fexists) {
                continue;
            }
            //获取注解
            Test_Column column = field.getAnnotation(Test_Column.class);
            String ColumuName = column.value();
            //获取字段的值
            String fieldName = field.getName();
            String getMethodName = "get" + fieldName.substring(0,1).toUpperCase() + fieldName.substring(1);
            Method method = null;
            Object ColumuValue = null;
            try {
                method = c1.getMethod(getMethodName);
                ColumuValue = method.invoke(f);

            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            //int型不需要加单引号，String型需要加单引号
            if(ColumuValue instanceof Integer && 0 != (Integer)ColumuValue){
                sql.append("and " + ColumuName + " = " + ColumuValue + " ");
            }else if(ColumuValue instanceof String){
                if( ((String) ColumuValue).contains(",") ){
                    String[] values = ((String) ColumuValue).split(",");
                    sql.append("and " + ColumuName + " in (");
                    for(int i=0; i<values.length; i++) {
                        sql.append("'").append(values[i]).append(" ',");
                    }
                    sql.deleteCharAt(sql.length() -1);
                    sql.append(")");
                }else{
                    sql.append(" and " + ColumuName + " = '" + ColumuValue + "' ");
                }
            }
        }
        return sql.toString();
    }
}

 

参考文章：https://blog.csdn.net/qq1404510094/article/details/80577555

              https://www.cnblogs.com/lrzy/articles/8405723.html