Java注解解析

短命女 2022-06-01 01:24 265阅读 0赞

## 概念 ##

注解是Java提供的一种 源程序中的元素关联任何信息和任何元数据的途径和方法。

## Java常见注解 ##

*  **JDK自带注解**  
    
    
    1.  @Override 覆盖父类的方法
    2.  @Deprecated 让方法过时
    3.  @Suppvisewarnings 忽略警告
 *  **常见第三方注解（Spring为例）**  
    
    
    1.  @Autowired 可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。通过 @Autowired的使用来消除set ，get方法。
    2.  @Service 用于标注业务层组件。定义某个类为一个bean，则在这个类的类名前一行使用@Service(“XXX”),就相当于讲这个类定义为一个bean，bean名称为XXX。而无需去xml文件内去配置。
    3.  @Repository 用于标注数据访问组件，即DAO组件。

## 注解分类 ##

*  **按运行机制分**  
    
    
    1.  源码注解：注解只在源码中存在，编译成.class文件就不存在了
    2.  编译时注解：注解在源码和.class文件中都存在（如：JDK内置系统注解）
    3.  运行时注解：在运行阶段还起作用，甚至会影响运行逻辑的注解（如：Spring中@Autowried）
 *  **按照来源分**  
    
    
    1.  JDK内置注解
    2.  自定义注解
    3.  第三方注解
 *  **元注解**——注解的注解

## 自定义注解 ##

*  **自定义注解的语法要求**
    
    1.  使用@interface关键字定义注解
    2.  成员以无参无异常方式声明
    3.  可以用default为成员指定一个默认值
        
        ![image.png][]
    4.  如果注解只有一个成员，则成员名必须取名value()，在使用时可以忽略成员名和赋值号(=)；
    5.  成员类型是受限的，合法的类型包括原始数据类型和String, Class, Annotation, Enumeration
    6.  注解类可以没有成员，没有成员的注解称为标识注解
        
        ![image.png][image.png 1]
 *  **元注解（注解里的注解）**  
    
    
    1.  *@Target(\{ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD\})*：定义注解的作用域  
        
        
         *  *CONSTRUCTOR* 构造方法声明
         *  *FIELD* 字段声明
         *  *LOCAL\_VARIABLE* 局部变量声明
         *  *METHOD* 方法声明
         *  *PACKAGE* 包声明
         *  *PARAMETER* 参数声明
         *  *TYPE* 类接口
    2.  *@Retention(RetentionPolicy.RUNTIME)*：定义生命周期  
        
        
         *  *SOURCE* 只在源码显示，编译时会丢弃
         *  *CLASS* 编译时会记录到class中，运行时忽略
         *  *RUNTIME* 运行时存在，可以通过反射读取
    3.  *@Inherited*：允许子类继承父类上的注解。只能用在类上，如果用在接口上将不会起作用。也只能继承类上的注解，方法上的不能被继承。
    4.  *@Documented*：生成javadoc的时候包含注解

## 使用自定义注解 ##

/* 自定义的注解类 */
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Description{ 
        int age() default 10;
        String author();
        String desc();
    }
    --------------------------------------------------------------------------------
    /* 使用注解的语法： @<注解名>（<成员名1>=<成员值1>,<成员名1>=<成员值1>,...） */
    @Description(desc="I am eyeColor",author="Mooc boy",age=18)
    public String eyeColor(){
        return "red";
    }

## 解析注解 ##

**概念**：通过反射获取类、函数或成员的**运行时**注解信息，从而实现动态控制程序运行的逻辑。  
**步骤**：

*  使用类加载器加载类
 *  找到类上边的注解
 *  拿到注解实例
 *  遍历方法上的注解

**示例**：

//自定义注解 Description.java
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Description{ 
        int age() default 10;
        String author();
        String desc();
    }

// Person.class 用自定义注解修饰
    @Description(desc="human class", author="wgp", age=20)
    public class Person { 
    
        @Description(desc="walk method", author="gp", age=21)
        public void walk(){
            System.out.println("human can walk!");
        }
    }

// 注解解析类 Test.class
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    public class Test { 
    
        public static void main(String[] args) {
    
            try {
                //1. 使用类加载器加载类
                Class c = Class.forName("Person");
                //2. 找到类上面的注解
                boolean isExist=c.isAnnotationPresent(Description.class);//isAnnotationParse()判断类上是否存在Description这样的注解
                if(isExist){
                    //3.获得注解实例
                    Description d = (Description)c.getAnnotation(Description.class);
                    System.out.println(d.desc());
                }
                //4.找到方法上的注解
                Method[] mts = c.getMethods();
                for (Method mt : mts) {
                    if(mt.isAnnotationPresent(Description.class)){
                        Description d2 = (Description)mt.getAnnotation(Description.class);
                        System.out.println(d2.author());
                    }
                }
    
                //另外一种获取类上的注解的途径
                Annotation[] annos = c.getAnnotations();
                for (Annotation anno : annos) {
                    if(anno instanceof Description){
                        System.out.println(((Description) anno).author());
                    }
                }
                //另一种获取方法上的注解的途径
                for (Method mt : mts){
                    Annotation[] annos2 = mt.getAnnotations();
                    for (Annotation anno : annos2) {
                        if(anno instanceof Description){ 
                            System.out.println(((Description) anno).desc());
                        }
                    }
                }
            } catch (Exception e) {
                //TODO: handle exception
            }
        }
    }

## 项目案例 ##

**说明**：  
代替Hibernate的解决方案，用在项目的持久层，核心代码就是用自定义注解实现的。  
**需求**：

1.  有一张用户表，字段包含id，用户名，密码，地址，手机号；
2.  方便的对每个字段或者每个字段的组合进行检索，并打印出SQL。

**分析**：

1.  首先肯定有一个关于用户的JavaBean，包含所有用户信息；
2.  有了JavaBean需要将属性与字段匹配，也就是ORM；
3.  匹配完相当于拼接SQL语句时，知道表名和字段名称了，还缺少where中的字段值是多少；
4.  通过用户类的getter方法来获取字段值为多少，拼接完整SQL语句。

**代码实现**：

1.  用户类，我们希望用@Table和@Cloumn来绑定;
    
        /** * User:用户JavaBean */
        @Table("user")
        public class User { 
        
            @Column("id")
            public Integer id;
            @Column("user_name")
            public String userName;
            @Column("password")
            public String passWord;
            @Column("address")
            public String address;
            @Column("phone_num")
            public String phoneNum;
        
            public void setId(Integer id) {
                this.id = id;
            }
        
            public void setUserName(String userName) {
                this.userName = userName;
            }
        
            public void setPassWord(String passWord) {
                this.passWord = passWord;
            }
        
            public void setAddress(String address) {
                this.address = address;
            }
        
            public void setPhoneNum(String phoneNum) {
                this.phoneNum = phoneNum;
            }
        
            public Integer getId() {
                return id;
            }
        
            public String getUserName() {
                return userName;
            }
        
            public String getPassWord() {
                return passWord;
            }
        
            public String getAddress() {
                return address;
            }
        
            public String getPhoneNum() {
                return phoneNum;
            }
        }
2.  自定义@Table注解和@Column注解；
    
        import java.lang.annotation.ElementType;
        import java.lang.annotation.Retention;
        import java.lang.annotation.RetentionPolicy;
        import java.lang.annotation.Target;
        
        @Target(ElementType.TYPE)
        @Retention(RetentionPolicy.RUNTIME)
        public @interface Table{ 
            String value();
        
        }
        --------------------------------------------------------------------------
        
        import java.lang.annotation.ElementType;
        import java.lang.annotation.Retention;
        import java.lang.annotation.RetentionPolicy;
        import java.lang.annotation.Target;
        
        @Target(ElementType.FIELD)
        @Retention(RetentionPolicy.RUNTIME)
        public @interface Column{ 
            String value();
        }
3.  根据反射来拼接出全部的SQL语句。
    
        import java.lang.reflect.Field;
        import java.lang.reflect.Method;
        
        public class UserDao { 
        
            public static void main(String[] args) {
                User user1 = new User();
                user1.setId(0);
        
                User user2 = new User();
                user2.setUserName("ping");
        
                User user3 = new User();
                user3.setAddress("beijing");
                user3.setPhoneNum("10101010101");
        
                String sql1 = query(user1); //查询id为0用户
                String sql2 = query(user2); //查询用户名含有ping的用户
                String sql3 = query(user3); //查询满足多个条件的用户
        
                System.out.println(sql1);
                System.out.println(sql2);
                System.out.println(sql3);
            }
        
            public static String query(User user) {
                StringBuilder sBuilder = new StringBuilder();
                Class clazz = user.getClass();
                // 获取表名
                if(!clazz.isAnnotationPresent(Table.class)){
                    return null;
                }
                Table table = (Table) clazz.getAnnotation(Table.class);
                String tableName = table.value();
                sBuilder.append("select * from ").append(tableName).append(" where 1 = 1");
        
                // 获取所有字段名+值
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    if(!field.isAnnotationPresent(Column.class)){
                        continue;
                    }
                    Column column = field.getAnnotation(Column.class);
                    String columnName = column.value(); //字段名
                    String fieldName = field.getName(); //属性名
                    String getMethodName = "get"+fieldName.substring(0, 1).toUpperCase()+fieldName.substring(1); //get方法名
                    Object fieldValue = null; //属性值（先提升为Object类型）
                    try {
                        Method getMethod = clazz.getMethod(getMethodName);
                        fieldValue = getMethod.invoke(user); //执行get方法获取值
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
        
                    //继续拼接SQL
                    if(fieldValue == null){
                        continue;
                    }
                    sBuilder.append(" and ").append(columnName);
                    if(fieldValue instanceof String){
                        sBuilder.append("='").append(fieldValue).append("'");
                    } else if(fieldValue instanceof Integer){
                        sBuilder.append("=").append(fieldValue);
                    }
                }
                return sBuilder.toString();
            }
        }

## 参考资料 ##

*  [慕课网《全面解析Java注解》][Java]

[image.png]: /images/20220601/e0fd9dd1605d46cb89a8aa7fe7d48cec.png
[image.png 1]: /images/20220601/e66c4af1f7b640a984501c97b2681a41.png
[Java]: https://www.imooc.com/learn/456