IOC(控制反转的点点滴滴注解.反射)

镇楼导图

ioc点滴.jpg

1 ButterKnife源码分析

纵观网络小宇宙，发现这个已有大神分析的相当彻底了，故而“盗来”以备查阅，再次感谢大神顾修忠

深入理解ButterKnife源码并掌握原理（一)
深入理解ButterKnife源码并掌握原理（二）
深入理解ButterKnife源码并掌握原理（三）
深入理解ButterKnife源码并掌握原理（四）
深入理解ButterKnife源码并掌握原理（五）

2 注解基础一览无遗

元数据

为代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻非常方便的使用这些数据¬

@Interface ：

定义为注解

@Target ：

表示注解可以用在什么地方

ElementType.CONSTRUCTOR 构造器
ElementType.FIELD 域(包括enum实例)
ElementType.LOCAL_VARIABLE 局部变量
ElementType.METHOD 方法
ElementType.PACKAGE 包
ElementType.PARAMETER 参数
ElementType.TYPE 类接口(包括注解类型) enum

@Retention：

表示需要在什么时候保存该注解信息

RetentionPolicy.SOURCE 注解将被编译器丢弃
RetentionPolicy.CLASS 编译时注解，注解在class文件中可用,但是会被VM丢弃
RUNTIME VM 运行时注解，将在运行期也保留注解，因此可以通过反射的机制读取注解的信息

@Documented:

将此注解包含在javadoc中

@Inherited:

允许子类可以继承父类中的注解

注解元素可用的类型

所有基本类型 short int long 等

String

Class

Enum

Annotation

以上类型的数组

java自带的注解

@Override 复写父类的方法

@Deprecated 某一方法不建议使用时

@SuppressWarings 告诉编译器忽略特定的警告

Demo

//定义
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnClick {
    int[] value();
}
//使用
public class Test{
    @OnClick(100)
    public void test(){
    }
}

3 反射基础一览无遗

基本概念

反射机制

在运行状态中，对任意一个类，都能知道这个类的所有属性和方法；对任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取信息以及动态调用对象方法的功能称之为反射机制

作用

运行时判断一个任意对象的所属的类

运行时构造任意一个对象的类

运行时判断任意一个类的所有成员方法和成员变量

运行时调用任意一个类的对象的方法

生成动态代理

功能示例

1.获取类的方式

/**针对PersonInterface  和 Person**/
1)  Class<?> class = Class.forName(“com.gjg.Person”);
2)  Class<?> class = Person.class
3)  Person person = new Person();
    Class<?> class = person.getClass();
//用class创建实例
Person person = (Person)class.newInstance();

2.获取父类及接口的方式

1)  获取所有实现的接口
Class<?>[] interfaces = class.getInterfaces();
2)  获取父类
Class<?> superclass = class.getSuperclass();

3.获取构造器的方式

1)  获取带参数的public构造器
Constructor constructor = class.getConstructor(String.class);
2)  获取所有public构造器
Constructor[] constructors = class.getConstructors();
3)  获取不用区分public的构造器 待一个String参数
Constructor constructor = class.getDeclaredConstructor(String.class);
4)  获取所有构造器
Constructor[] constructors = class.getDeclaredConstructors();
//用构造器创建实例
Person person = (Person)constructor.newInstance(“Gjg”);

4.获取方法的方式

1)  获取public setName(String name) 方法
Method methodSetName = class.getMethod(“setName”,String.class);
2)  获取 private setAge(int age) 方法 
Method methodSetAge = class.getDeclaredMethod(“setAge”,int.class);//* int.class 与 Integer.class 是不同的
3)  获取所有的public方法 (包含父类的public方法)
Method[] publicMethods = class.getMethods();
4)  获取所有的方法 
Method[] methods = class.getDeclaredMethods();
//由于是private方法 在调用前要进行改变其访问区域
methodSetAge.setAccessible(true)
methodSetAge.invoke(person,28);//person是对象 28 是实参值

5.获取成员属性的方式

1)  根据变量名获取public的变量
Field field = class.getField(“country”);
2)  根据变量名获取任意限定符的变量
Field field = class.getDeclaredField(“country”);
3)  获取所有public的变量
Field[] fields = class.getFields();
4)  获取所有变量，不受限定符限制
Filed[] fields = class.getDeclaredFields();
//动态改变属性值，如果是private需要先改变其限定性
field.setAccessible(true);
filed.set(person,”Gjg”);//person所属对象 “Gjg”实参
//获取属性值
String name = filed.get(person);

6.获取注解的方式 (XmlE是个注解示例)

1)  获取指定类型的注解(field method class上的包含继承)
Annotation annotation = filed.getAnnotation(XmlE.class);
2)  获取所有注解(field method class上的包含继承)
Annotation[] annotations = field.getAnnotations();
3)  获取指定类型的注解(field method class上的不包含继承)
Annotation annotation = field.getDeclaredAnnotation(“XmlE.class”);
4)  获取所有注解(filed method class 不包含继承)
Annotation[] annotations = filed.getDeclaredAnnotations();
//转换得到注解对象
XmlE xmlE = (XmlE)annotation;
//得到注解的类型
Class annotationType = annotation.annotationType();
//得到反射中某个值
String name = xmlE.name();

注意事项

1.getDeclaredXXX()与getXXX()

引用块内容
getDeclaredXXX():自身，不受限定符限制
getXXX():所有public 包含父类中的
反射工具类

public class ReflectionUtils {
    /**
     * 循环向上转型, 获     * @param object : 子类对象
     * @param methodName : 父类中的方法名
     * @param parameterTypes : 父类中的方法参数类型
     * @return 父类中的方法对象
     */

    public static Method getDeclaredMethod(Object object, String methodName, Class<?> ... parameterTypes){
        Method method = null ;

        for(Class<?> clazz = object.getClass() ; clazz != Object.class ; clazz = clazz.getSuperclass()) {
            try {
                method = clazz.getDeclaredMethod(methodName, parameterTypes) ;
                return method ;
            } catch (Exception e) {
                //这里甚么都不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会进入
            }
        }

        return null;
    }

    /**
     * 直接调用对象方法, 而忽略修饰符(private, protected, default)
     * @param object : 子类对象
     * @param methodName : 父类中的方法名
     * @param parameterTypes : 父类中的方法参数类型
     * @param parameters : 父类中的方法参数
     * @return 父类中方法的执行结果
     */

    public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
                                      Object [] parameters) {
        //根据 对象、方法名和对应的方法参数 通过取 Method 对象
        Method method = getDeclaredMethod(object, methodName, parameterTypes) ;

        //抑制Java对方法进行检查,主要是针对私有方法而言
        method.setAccessible(true) ;

        try {
            if(null != method) {

                //调用object 的 method 所代表的方法，其方法的参数是 parameters
                return method.invoke(object, parameters) ;
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 循环向上转型, 获     * @param object : 子类对象
     * @param fieldName : 父类中     * @return 父类中     */

    public static Field getDeclaredField(Object object, String fieldName){
        Field field = null ;

        Class<?> clazz = object.getClass() ;

        for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {
            try {
                field = clazz.getDeclaredField(fieldName) ;
                return field ;
            } catch (Exception e) {
                //这里甚么都不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会进入
            }
        }

        return null;
    }

    /**
     * 直接设置对象属性值, 忽略 private/protected 修饰符, 也     * @param object : 子类对象
     * @param fieldName : 父类中     * @param value : 将要设置的值
     */

    public static void setFieldValue(Object object, String fieldName, Object value){

        //根据 对象和属性名通过取 Field对象
        Field field = getDeclaredField(object, fieldName) ;

        //抑制Java对其的检查
        field.setAccessible(true) ;

        try {
            //将 object 中 field 所代表的值 设置为 value
            field.set(object, value) ;
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }

    /**
     * 直接读的属性值, 忽略 private/protected 修饰符, 也     * @param object : 子类对象
     * @param fieldName : 父类中     * @return : 父类中     */

    public static Object getFieldValue(Object object, String fieldName){

        //根据 对象和属性名通过取 Field对象
        Field field = getDeclaredField(object, fieldName) ;

        //抑制Java对其的检查
        field.setAccessible(true) ;

        try {
            //获的属性值
            return field.get(object) ;

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

        return null;
    }
}

4 编译时注解解析器基础

敬请期待

IOC(控制反转的点点滴滴 注解.反射)