反射 - 《Java 学习》

反射机制
- 2.1Java反射机制概述
2.2理解Class类并获取Class实例
2.3类的加载与ClassLoader
2.4创建运行时类的对象

反射机制

Java是静态语言，反射机制使得Java成为准动态语言

2.1Java反射机制概述

静态语言与动态语言

静态语言：在运行时可以改变其结构的语言
动态语言：在运行时不能改变其结构的语言
Java是静态语言，使用反射机制可以让Java获得类似于动态语言的特性。

Reflection 反射

反射机制允许Java在程序执行期间借助Reflection API取得任何类的内部信息，并能操作任意对象的内部属性和方法
Class c1 = Class.forName(java.lang.String);
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象)
这个对象包含了完整的类的结构信息，我们可以通过这个对象看到类的结构
这个对象就像一面镜子，透过这面镜子我们可以看到类的结构。所以形象地称之为：反射
正常方法：引入”包类 “——-> new实例化 ——-> 获得实例化对象
反射方法：实例化对象 ——-> getClass()方法 ——-> 获得完整的”包类”名称

Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理 (AOP面向切面编程)
……

反射的优点和缺点
优点：可以实现动态创建对象和编译，灵活。
缺点：影响性能，反射是一种解释操作，我们需要告诉JVM我们希望做什么，并让它满足我们的要求，这样的操作总是慢于直接执行相同的操作。

反射相关的主要API
java.lang.Class 代表一个类
java.lang.reflect.Method 代表类的方法
java.lang.reflect.Field 代表类的属性
java.lang.reflect.Constructor 代表类的构造器

获取反射对象
//通过反射获取类的Class对象 Class c1 = Class.forName(“com.lee.reflection.User”);

2.2理解Class类并获取Class实例

Class类
在Object类中有如下方法，该方法被所有子类继承
public final Class getClass()
返回的Class类是Java反射的源头。
对象照镜子(即getClass()方法)后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口对于每个类而言,JRE都为其保留一个不变的 Class类型的对象。一个 Class对象包含了特定某个结构的有关信息。
Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个 Class对象对应的是一个加载到JVM中的一个class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过 Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得相应的Class对象
Class类的常用方法
static Class.forName(String name)
Object newInstance()
getName()
Class getSuperclass()
Class getInterface()
ClassLoader getClassLoader()
Constructor[] getConstructors()
Method getMethod(String name,Class.. T)
Field[] getDeclaredFields()
获取Class类的实例

已知具体类通过类的class属性获取，安全可靠，性能最高Class c = Person.class;
已知某个类的实例，调用getClass()方法获取Class对象Class c = person.getClass();
已知一个类的全类名，且该类在类路径下，可以用Class类的静态方法forName()获取，可能抛出异常ClassNotFoundExceptionClass c = Class.forName(“com.lee.Student”);
内置基本数据类型可以使用类名.TYPEClass c = Integer.TYPE;
使用ClassLoader，详见2.3
哪些类型可以有Class对象

class 类
interface 接口
[] 数组
enum 枚举
annotation 注解
primitive type 基本数据类型
void

2.3类的加载与ClassLoader

Java内存分析

方法区是堆的一个逻辑部分，内存上属于堆但为了区分又叫非堆

类加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤对该类进行初始化

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
链接:将ava类的二进制代码合并到JVM的运行状态之中的过程。
验证:确保加载的类信息符合JVM规范没有安全方面的问题
准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配。
解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

初始化：执行类构造器< clinit>()方法的过程。

类构造器< clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构造器)
当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化。

虚拟机会保证一个类的方法在多线程环境中被正确加锁和同步

例子

public class Test05 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);

  /*<br />        1.加载到内存，产生一个Class对象<br />        2.链接 结束后m = 0<br />        3.初始化<br />            <clinit>(){<br />            static{<br />        System.out.println("A静态代码块初始化");<br />        m = 300;<br />        m = 100;<br />        }<br />         */<br />    }<br />}

class A{
static{
System.out.println(“A静态代码块初始化”);
m = 300;
}
static int m = 100;

public A(){<br />        System.out.println("A的无参构造器");<br />    }<br />}

分析图

类初始化

类的主动引用(一定会发生类的初始化)

当虚拟机启动,先初始 main方法所在的类
调用类的静态成员(除了final常量)和静态方法
使用java.lang.reflect包的方法对应类进行反射调用
当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类

类的被动引用(不会发生类的初始化)

当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
通过数组定义类引用,不会触发此类的初始化
引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

类加载器
Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：
引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader 。
扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader() 来获取它。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader 类的方式实现自己的类加载器，以满足一些特殊的需求。

双亲委派机制

当一个Hello.class这样的文件要被加载时。不考虑我们自定义类加载器，首先会在AppClassLoader(即system class loader)中检查是否加载过，如果有那就无需再加载了。如果没有，那么会拿到父加载器，然后调用父加载器的loadClass方法。父类中同理会先检查自己是否已经加载过，如果没有再往上。注意这个过程，知道到达Bootstrap classLoader之前，都是没有哪个加载器自己选择加载的。如果父加载器无法加载，会下沉到子加载器去加载，一直到最底层，如果没有任何加载器能加载，就会抛出ClassNotFoundException。
为什么要设计这种机制?
这种设计有个好处是，如果有人想替换系统级别的类：String.java。篡改它的实现，但是在这种机制下这些系统的类已经被Bootstrap classLoader加载过了，所以并不会再去加载，从一定程度上防止了危险代码的植入。

2.4创建运行时类的对象

获取运行时类结构

获取运行时类的完整结构或指定结构
通过反射获取运行时类的完整结构:
Field，Method，Constructor，Superclass，Interface，Annotation
代码
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException,NoSuchMethodException{
Class c1 = Class.forName(“com.lee.reflection.User”);
/
User user = new User();
c1 = user.getClass();
/
//获得类的名字
System.out.println(c1.getName());// 包名 + 类名
System.out.println(c1.getSimpleName());// 类名

    //获得类的属性<br />        System.out.println("===============================");<br />        Field[] fields = c1.getFields();//只能找到public方法<br />        for(Field field : fields){<br />            System.out.println(field);<br />        }
    Field[] declaredFields = c1.getDeclaredFields();//找到所有方法<br />        for(Field field : declaredFields){<br />            System.out.println(field);<br />        }<br />        //获得指定属性的值<br />        Field name = c1.getDeclaredField("name");<br />        System.out.println(name);
    //获得类的方法<br />        System.out.println("===============================");<br />        Method[] methods = c1.getMethods(); // 获得本类及父类的全部public方法<br />        for (Method method : methods) {<br />            System.out.println("正常的:" + method);<br />        }<br />        Method[] declaredMethods = c1.getDeclaredMethods();//获得本类的所有方法<br />        for (Method declaredMethod : declaredMethods) {<br />            System.out.println("Declared" + declaredMethod);<br />        }
    //获得指定的方法<br />        Method getName = c1.getMethod("getName", null);<br />        System.out.println(getName);<br />        Method setName = c1.getMethod("setName", String.class);<br />        System.out.println(setName);
    //获得指定的构造器<br />        System.out.println("===============================");<br />        Constructor[] constructors = c1.getConstructors(); // 获得public构造器<br />        for (Constructor constructor : constructors) {<br />            System.out.println(constructor);<br />        }
    Constructor[] declaredConstructors = c1.getDeclaredConstructors();// 获得全部的构造器<br />        for (Constructor declaredConstructor : declaredConstructors) {<br />            System.out.println("$ "+ declaredConstructor);<br />        }
    //获得指定的构造器<br />        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);<br />        System.out.println("指定 " + declaredConstructor);
}<br />}

代码中的User类
class User {
private String name;
private int id;
private int age;

public User(String name, int id, int age) {<br />        this.name = name;<br />        this.id = id;<br />        this.age = age;<br />    }
public User() {<br />    }
public String getName() {<br />        return name;<br />    }
public void setName(String name) {<br />        this.name = name;<br />    }
public int getId() {<br />        return id;<br />    }
public void setId(int id) {<br />        this.id = id;<br />    }
public int getAge() {<br />        return age;<br />    }
public void setAge(int age) {<br />        this.age = age;<br />    }
@Override<br />    public String toString() {<br />        return "User{" +<br />                "name='" + name + '\'' +<br />                ", id=" + id +<br />                ", age=" + age +<br />                '}';<br />    }<br />}

动态创建对象执行方法

创建对象：
调用Class对象的newInstance()方法

类必须有无参构造器
类的构造器必须有足够的权限

如果没有无参构造器，我们需要明确调用类中的构造器，并将参数传递进去，进行实例化。

通过Class类的getDeclaredConstructor(Class…parameterTypes)获取本类指定形参构造器
向构造器的形参中传递一个对象数组进去，里面包含了构造器所需的参数
通过Constructor来实例化对象

调用指定方法
通过反射，调用类中的方法，通过Method类完成

通过Class类的getMethod(…)方法获取Method对象，并设置操作此方法时所需参数类型。
之后使用Object invoke(…)进行调用，并传递object对象的参数信息。

Object invoke(Object obj, Object … args)

Object对应原方法的返回值，若无返回值则返回null
原方法若为静态方法，则形参Object obj可为null
原方法的参数列表为空，则Object[] args可为null
原方法声明为private则需要在调用invoke()前，显式调用方法对象的setAccessible(true)方法，然后可以访问private

SetAccessible

Method，Field，Constructor对象都有SetAccessible方法
SetAccessible方法的作用是启用或禁用安全访问检查的开关
参数设置为true，反射对象取消Java语言访问检查
- 提高反射效率，反射代码频繁调用，设置为true可以提示效率
- 使得原本无法访问的私有成员也可以访问
参数设置为false，反射对象实施Java语言访问检查

代码
//通过反射动态地创建对象
public class Test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获得Class对象
Class c1 = Class.forName(“com.lee.reflection.User”);
//构造一个user对象
User user = (User)c1.newInstance(); //本质是调用无参构造器没有的话会报错
System.out.println(user);

    //通过构造器创建对象<br />        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);<br />        User user2 = (User)declaredConstructor.newInstance("李华", 001, 18);<br />        System.out.println(user2);
    //通过反射调用普通方法<br />        User user3 = (User)c1.newInstance();<br />        //通过反射获取一个方法<br />        Method setName = c1.getDeclaredMethod("setName", String.class);<br />        //invoke 激活<br />        // (对象 ," 方法的值")<br />        setName.invoke(user3,"李明");<br />        System.out.println(user3.getName());
    //通过反射操作属性<br />        User user4 = (User)c1.newInstance();<br />        Field name = c1.getDeclaredField("name");
    //不能直接操作私有属性，我们需要关闭程序的安全检测<br />        //属性或方法 的setAccessible()方法设为true<br />        name.setAccessible(true);<br />        name.set(user4,"lee");<br />        System.out.println(user4.getName());<br />    }<br />}

User类前面已给出

获取泛型信息

Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅javac是给编译器使用的,确保数据的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除
为了通过反射操作这些类型,Java新增了ParameterizedType, GenericArrayType,TypeVariable和 WildcardType几种类型来代表不能被归一到 Class类中的类型但是又和原始类型齐名的类型
ParameterizedType:表示一种参数化类型,比如Collection
GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable:是各种类型变量的公共父接口
WildcardType:代表一种通配符类型表达式

获取步骤

获取当前类
获取目标字段
获取包含泛型类型的类型 getGenericType()
强转至子类ParameterizedType因为Type没有任何对应的方法
获得泛型真正的类型getActualTypeArguments()

代码
//通过反射获取泛型
public class Test10 {
public void test01(Map map, List list){
System.out.println(“test01”);
}

public Map<String,User> test02(){<br />        System.out.println("test02");<br />        return null;<br />    }
public static void main(String[] args) throws NoSuchMethodException {
    Method method = Test10.class.getMethod("test01", Map.class, List.class);
    Type[] genericParameterTypes = method.getGenericParameterTypes();<br />        for (Type genericParameterType : genericParameterTypes) {<br />            System.out.println("#" + genericParameterType);<br />            if (genericParameterType instanceof ParameterizedType){<br />                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();<br />                for (Type actualTypeArgument : actualTypeArguments) {<br />                    System.out.println(actualTypeArgument);<br />                }<br />            }<br />        }
    method = Test10.class.getMethod("test02",null);<br />        Type genericReturnType = method.getGenericReturnType();<br />        if (genericReturnType instanceof ParameterizedType){<br />            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();<br />            for (Type actualTypeArgument : actualTypeArguments) {<br />                System.out.println(actualTypeArgument);<br />            } <br />        }<br />    }<br />}

获取注解信息

ORM
Object Relationship Mapping 对象关系映射

类和表结构对应
属性和字段对应
对象和记录对应

利用注解和反射完成类和表的结构的映射关系
//获取注解的信息
public class Test11 {

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {<br />        Class c = Class.forName("com.lee.reflection.Student2");<br />        //通过反射获得注解<br />        Annotation[] annotations = c.getAnnotations();<br />        for (Annotation annotation : annotations) {<br />            System.out.println(annotation);<br />        }<br />        //通过反射获得注解的value的值<br />        MyTable table = (MyTable)c.getAnnotation(MyTable.class);<br />        String value = table.value();<br />        System.out.println(value);
    //获得类指定的注解<br />        Field field = c.getDeclaredField("name");<br />        MyField annotation = field.getAnnotation(MyField.class);<br />        System.out.println(annotation.columnName());<br />        System.out.println(annotation.length());<br />        System.out.println(annotation.type());<br />    }

}
@MyTable(“db_student”)
class Student2{
@MyField(columnName = “db_id”,type = “int”,length = 10)
private int id;
@MyField(columnName = “db_age”,type = “int”,length = 10)
private int age;
@MyField(columnName = “db_name”,type = “varchar”,length = 3)
private String name;

public Student2() {<br />    }
public Student2(int id, int age, String name) {<br />        this.id = id;<br />        this.age = age;<br />        this.name = name;<br />    }
public int getId() {<br />        return id;<br />    }
public void setId(int id) {<br />        this.id = id;<br />    }
public int getAge() {<br />        return age;<br />    }
public void setAge(int age) {<br />        this.age = age;<br />    }
public String getName() {<br />        return name;<br />    }
public void setName(String name) {<br />        this.name = name;<br />    }
@Override<br />    public String toString() {<br />        return "Student2{" +<br />                "id=" + id +<br />                ", age=" + age +<br />                ", name='" + name + '\'' +<br />                '}';<br />    }<br />}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyTable{
String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField{
String columnName();
String type();
int length();
}

/*
 * 类加载器：
 *      作用：（1）加载类（最基本最核心的作用）
 *         （2）加载类路径下的其他资源文件，例如：配置文件等
 * 
 * 类型：
 * （1）引导类加载器：根加载器   Bootstrap Classloader
 *         jre/rt.jar核心库
 * （2）扩展类加载器（Extension ClassLoader）
 *         jre/lib/ext扩展库
 * （3）应用程序类加载器（Application Classloader）
 *         项目的classpath路径下的类
 * （4）自定义类加载器
 * 
 * 关系：
 *      应用程序类加载器是把扩展类加载器称为父加载器，扩展类加载器把引导类加载器称为父加载器。
 *  这里的“父”不是继承，而是在应用程序类加载器中有一个成员变量是扩展类加载器类型，并且名称是parent。
 *              同样的在扩展类加载器中也有一个成员变量是引导类加载器类型，并且名称是parent。
 *  当我们调用getParent()方法时，可以获取父加载器。
 *  
 *  这种方式我们称为组合的关联关系，不是继承的关联关系。
 *  
 *  这种设计的目的是什么？
 *      Java的类加载器是双亲委托模式。
 *      过程：
 *          当下级的类加载器，例如 应用程序类加载器，接到加载某个类的任务时，
 *          （1）会先在内存中搜索这个类是否已经被加载过，如果加载过，就可以找到它的Class对象，那么直接返回这个Class对象就可以，不会重复加载。
 *          （2）如果在内存中并没有搜索到这个类的Class对象，说明这个类没有被加载过，它此时会把这个任务，提交给“父”加载器，
 *                  例如：应用程序类加载器，如果提交，就是给扩展类加载器
 *          当扩展类加载器接到任务时，重复刚才的操作（1）（2）
 *                  这里，扩展类加载器，如果提交，就是给引导类加载器
 *          当引导类加载器接到任务时，重复刚才的操作（1）（2）
 *          引导类加载器想要提交给父加载器时，发现没有父加载器了，然后在jre/rt.jar核心库先自己找一下，有没有这个类，如果找到了，就返回Class对象，
 *          如果引导类加载器，在jre/rt.jar核心库中没有找到，再把任务往会传，给扩展类加载器，
 *                  此时因为是引导类加载器把这个任务重新给你的，那么你要在你负责的路径下，即jre/lib/ext扩展库，如果找到了，就返回Class对象，
 *          如果扩展类加载器，在jre/lib/ext路径下没有找，再把任务继续往回传，给应用程序类加载器，
 *                  此时因为是扩展类加载器把这个任务重新给你的，那么你要在你你负责的路径下，即项目的classpath路径下的类，如果找到了，就返回Class对象，
 *          如果应用程序类加载器，在项目的classpath路径下也没有找到，就报ClassNotFoundException。
 *  
 *      为什么要这么干？
 *          目的：安全
 *          
 *  例如：我们自己写了一个类：java.lang.String
 *      如果此时没有“双亲委托模式”，应用程序类加载器先接到任务，加载“java.lang.String"，
 *          它在项目中直接就找到这个类，内存中，就会存在一个String类型Class对象。
 *      此时就会导致系统核心类库中的String类型失效了。
 *  
 *      而实际中有“双亲委托模式”，应用程序类加载器先接到任务，提交这个任务，一直到引导类加载器，引导类加载器会去jre/rt.jar核心库中找，可以找到，就返回，
 *      所以，应用程序类加载器就不会在自己负责的项目的classpath路径下去加载这个String类型。这样就可以保证核心类库的安全。
 *                  
 */
/*
 * 类的加载的结果：生成一个Class对象
 * 
 * 1、如何获取到这个Class对象？（必须记住）
 * (1)类型名.class
 * (2)对象.getClass()  获取某个对象的运行时类型
 * (3)Class.forName("类型全名称")
 * (4)ClassLoader对象.loadClass("类型全名称")
 * 
 * 开发中，写代码时，当前代码环境下，能用哪种就用哪中都可以。
 * 推荐大家首先考虑（3），具有解耦合优势
 * 
 * 
 * 2、哪些类型有Class对象？所有的Java类型都有Class
 * 
 * java.lang.Class<T>类型：
 *         Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
 *         枚举是一种类，注释是一种接口。
 *         每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
 *         基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。 
 * 
 * 
 * 3、每一种类型在内存中的Class对象是唯一的。
 * 
 * 4、如何获取某个类加载器对象？
 *      Class对象.getClassLoader()
 */

反射

反射机制

2.1Java反射机制概述

静态语言与动态语言

Reflection 反射

Java反射机制提供的功能

反射的优点和缺点

反射相关的主要API

获取反射对象

2.2理解Class类并获取Class实例

Class类

Class类的常用方法

获取Class类的实例

哪些类型可以有Class对象

2.3类的加载与ClassLoader

Java内存分析

类加载过程

例子

分析图