Java注解

注解Annotation

注释与注解是不同的。

1.注解的写法

​ @Xxxx[(一些信息)]

2.注解放在哪里

​ 类的上面，属性的上面，方法的上面，构造方法的上面，参数前面。

3.注解的作用

​ 1.用来充当注释的作用(仅仅是一个文字说明) @Deprecated

​ 2.用来做代码的检测（验证） @Override

​ *3.可以携带一些信息（内容）

4.Java中有一些已经写好的注解供我们使用。

​ @Deprecated 用来说明方法是废弃的。

​ @Override 用来做代码检测，检测此方法是否是一个重写。

​ @SuppressWarnings({“all”})

​ unused：取消未使用警告

​ serial：类实现了序列化接口，但是没有添加序列化ID

​ rewTypes：集合没有定义泛型。

​ deprecation：方法已经废弃

​ unchecked：不进行异常检测

​ all:取消所有警告

5.注解中可以携带信息，可以不携带。

​ 信息不能随便写，信息的类型只能是如下的类型。

​ 1.基本数据类型

​ 2.String类型

​ 3.枚举类型enum

​ 4.注解类型@

​ 5.数组类型[] 数组的内部需要是如下的四种类型

6.如何自己描述一个注解类型

​ 1.通过@interface来定义一个新的注解。

​ 2.发现写法与接口非常相似（可以利用接口的特点来记忆注解）

​ 可以描述public static final 的属性。（比较少见）

​ 可以描述public abstract 方法。注解方法必须有返回值。返回值类型是上述描述的类型（5）。

​ 方法名为value时，只有一个注解则在使用的时候，可以不用写value=。

​ 如果方法是两个以上，所有必须写方法名。

​ 3.自定义注解如需要使用，光定义还不行，需要做很多细致的说明，（需要利用java提供好的注解来说明）。

​ 元注解（也是注解，不是用来使用的，是用来说明注解）

​ @Target 描述当前这个注解可以放置在哪里写的。

​ @Retention 描述当前的这个注解存在什么作用域中的

​ 源代码域：SOURCE

​ 字节码文件：CLASS

​ 内存执行：RUNTIME

​ @Inherited 描述当前注解是否能被子类对象继承。

​ @Documented 描述这个注解是否能被文档所记录。

​

package com.ooyhao.jdbc.annotation;

import java.lang.annotation.*;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD) //可以放在属性上
public @interface Column {
    public String value();//列名
}

7.如何解析注解内携带的信息（反射机制）

1.自定义注解

@Target({ElementType.FIELD,ElementType.CONSTRUCTOR,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnnotation {
    String [] value();
}

2.bean

public class Person {
    @MyAnnotation(value = {"欧阳浩","男","23"})
    private String[] name;
}

3.使用反射技术获取注解的信息

public static void main(String[] args) throws Exception {

    //1.获取Person Class 类
    Class clazz = Person.class;
    //2.获取Person的name方法
    Field name = clazz.getDeclaredField("name");
    //3.获取name属性上的MyAnnotation注解
    MyAnnotation anno = name.getAnnotation(MyAnnotation.class);
    //4.获取anno类的Class
    Class annoClass = anno.getClass();
    //5.获取MyAnnotation中的value方法
    Method method = annoClass.getMethod("value");
    //6.调用方法
    String[] result = (String[]) method.invoke(anno);
    //7.展示信息
    System.out.println(Arrays.toString(result));

}

使用注解+反射模拟IOC容器

1.Person

package com.ooyhao.myspring;

import java.io.Serializable;

public class Person implements Serializable {


    private String name;
    private Integer age;
    private String sex;

    @PersonAnnotation(value = {"ouYang","18","男"})
    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

2.PersonAnnotation

package com.ooyhao.myspring;

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

@Target(ElementType.CONSTRUCTOR)
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonAnnotation {
    String[] value();
}

3.MySpring(IOC)

package com.ooyhao.myspring;

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

public class MySpring {
    public static Object getBean(String className){
        Object obj = null;
        try{
            //1.获取类
            Class<?> clazz = Class.forName(className);
            //2.根据无参数的构造方法创建对象
            Constructor<?> constructor = clazz.getConstructor();
            //3.创建对象
            obj = constructor.newInstance();
            //4.获取无参数构造方法上的注解
            PersonAnnotation personAnnotation = constructor.getAnnotation(PersonAnnotation.class);
            //5.获取注解类的Class对象
            Class<? extends PersonAnnotation> pClass = personAnnotation.getClass();
            //6.获取注解类的value方法
            Method vMethod = pClass.getMethod("value");
            //7.调用value方法获取注解中的值
            String [] values = (String[]) vMethod.invoke(personAnnotation);
            //8.获取Person中的所有属性
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++){
                Field f = fields[i];
                String fieldName = f.getName();//属性名
                Class<?> rType = f.getType();
                //拼接setter方法
                String firstLetter = fieldName.substring(0, 1).toUpperCase();//获取属性名的首字母，并大写
                String otherLetter = fieldName.substring(1);
                StringBuilder set = new StringBuilder();
                String setMethod = set.append("set").append(firstLetter).append(otherLetter).toString();
                Constructor<?> rTypeConstructor = rType.getConstructor(String.class);
                Method method = clazz.getMethod(setMethod, rType);
                method.invoke(obj,rTypeConstructor.newInstance(values[i]));
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return obj;
    }
}

4.测试

package com.ooyhao.myspring;

public class TestMain {
    public static void main(String[] args) {
        Person bean = (Person) MySpring.getBean("com.ooyhao.myspring.Person");
        System.out.println(bean);//Person{name='ouYang', age=18, sex='男'}
    }
}

最后

如果觉得不错的话，那就关注一下小编哦！一起交流，一起学习