Java:反射机制

1. Java反射机制概述

1.1 动态语言与反射

动态语言

是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进,已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构

主要动态语言:Object-C、C#、JavaScript、PHP、Python、Erlang

反射

Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法

加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息,我们可以通过这个对象看到类的结构。

这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们形象的称之为:反射

1.2 反射提供功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法,包括私有
  • 在运行时处理注解
  • 生成动态代理

1.3 反射相关API

  • java.lang.Class:代表一个类
  • java.lang.reflect.Method:代表类的方法
  • java.lang.reflect.Field:代表类的成员变量
  • java.lang.reflect.Constructor:代表类的构造器
  • … …

2. 理解Class类并获取Class实例

2.1 java.lang.Class类的理解

  1. 类的加载过程
    • 程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)
    • 接着我们使用java.exe命令对某个字节码文件进行解释运行,即把某个字节码文件加载到内存中,此过程称为类的加载
    • 加载到内存中的类,我们就称为运行时类,此运行时类,就作为Class的一个实例
  2. 换句话说,Class的实例就对应着一个运行时类
  3. 加载到内存中的运行时类,会缓存一定的时间,在此时间之前,我们可以通过不同的方式来获取此运行时类

2.2 获取Class实例

四种方法获取Class类的实例:

  • 方式一:调用运行时类的属性:.class
  • 方式二:通过运行时类的对象,调用getClass()
  • 方式三:调用Class的静态方法:forName(String classPath)
  • 方式四:使用类的加载器:ClassLoader (了解)
//导入的包有:import org.junit.Test;

public class ReflectionTest1 {
    @Test
    public void test1() throws ClassNotFoundException {
        //方式一:调用运行时类的属性:.class
        Class clazz1 = String.class;
        System.out.println(clazz1);//class java.lang.String

        //方式二:通过运行时类的对象,调用getClass()
        String s1 = new String();
        Class clazz2 = s1.getClass();
        System.out.println(clazz2);//class java.lang.String

        //方式三:调用Class的静态方法:forName(String classPath)
        Class clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);//class java.lang.String

        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true

        //方式四:使用类的加载器:ClassLoader (了解)
        ClassLoader classLoader = ReflectionTest1.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("java.lang.String");
        System.out.println(clazz4);//class java.lang.String
        System.out.println(clazz1 == clazz4);//true
    }
}

除了类以外,接口、数组、枚举、注解基本数据类型、void也可以作为Class类的实例

3. 类的加载与ClassLoader的理解

3.1 类的加载

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

3.2 ClassLoader的理解

类加载器的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口

JVM 规范定义了如下类型的类的加载器:

  • 引导类加载器:该加载器无法获取
  • 扩展类加载器
  • 系统类加载器
//导入的包有:import org.junit.Test;

public class ClassLoaderTest {
    @Test
    public void test1(){
        //对于自定义类:使用系统类加载器进行加载
        ClassLoader classLoader1 = ClassLoaderTest.class.getClassLoader();

        //调用系统加载器的getParent():获取扩展类加载器
        System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
        ClassLoader classLoader2 = classLoader1.getParent();

        //调用扩展类加载器的getParent():无法获取引导类加载器
        //引导类加载器主要负责加载Java的核心类库,无法加载自定义类
        System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@a09ee92
        ClassLoader classLoader3 = classLoader2.getParent();
        System.out.println(classLoader3);//null
    }
}

4. 创建运行时类的对象

通过反射,创建运行时类的对象

//导入的包有:import org.junit.Test;

public class ClassLoaderTest {
    @Test
    public void test2() throws IllegalAccessException, InstantiationException {
        Class clazz = String.class;
        /*
        * newInstance():调用此方法,创建对应的运行时类的对象,其内部调用了运行时类的空参构造器
        *
        * 要想此方法正常的创建运行时类的对象,要求
        * 1.运行时类必须提供空参的构造器
        * 2.空参的构造器的访问权限足够,通常设置为public
        */
        //由于创建Class类的对象时,规定了泛型,所以此处自动转换类型
        String obj = clazz.newInstance();
        System.out.println(obj);
    }
}

5. 获取运行时类的完整结构

5.1 获取属性结构

当我们创建好Class对象后,可以获得其所有属性

//导入的包有:import org.junit.Test;import java.lang.reflect.Field;import java.lang.reflect.Modifier;

public class Test1 {
    @Test
    public void test1(){
        Class clazz = String.class;

        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        }

        //getDeclaredFields():获取当前运行时类中声明的所有属性,不包含父类中声明的属性
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
    }
    @Test
    public void test2(){
        Class clazz = String.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            //1.获取权限修饰符
            int modifier = f.getModifiers();
            System.out.println(Modifier.toString(modifier));

            //2.获取数据类型
            Class type = f.getType();
            System.out.println(type.getName());

            //3.获取变量名
            String fName = f.getName();
            System.out.println(fName);
        }
    }
}

5.2 获取方法结构

当我们创建好Class对象后,可以获得其所有方法

//导入的包有:import org.junit.Test;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.Modifier;

public class Test1 {
    @Test
    public void test3(){
        Class clazz = String.class;
        
        //getMethods():获取当前运行时类一起所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }
        
        //getDeclaredMethods():获取当前运行时类中声明的所有方法,不包含父类中声明的方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }
    }
}

我们也可以获取方法的权限修饰符,返回值类型,方法名,参数,注解,异常,由于使用不多,这里不展开叙述

5.3 获取构造器结构

当我们创建好Class对象后,可以获得其构造器

//导入的包有:import org.junit.Test;import java.lang.reflect.Constructor;

public class Test1 {
    @Test
    public void test4(){
        //getConstructors():获取当前运行时类中声明为public的构造器
        Class clazz = String.class;
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c : constructors){
            System.out.println(c);
        }

        //getDeclaredConstructors():获取当前运行时类中声明的所有构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c);
        }
    }
}

还可以获得运行时类的父类及其父类的泛型、接口、所在包、注解,这里不在一一演示

6. 调用运行时类的指定结构

6.1 调用运行时类的指定属性

//导入的包有:import org.junit.Test;import java.lang.reflect.Field;

//现在假设有一Person类,具有一般类所具有的属性,方法,构造器
public class ReflectionTest2 {
    @Test
    public void test1() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1.getDeclaredField(String name):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //还有一种方式获取运行时类中的指定变量,但一般不使用,因为只能获得Public属性
      //Field name = clazz.getFueld("name")


        //2.保证当前属性时可访问的
        name.setAccessible(true);
        //3.获取、设置指定对象的此属性
        name.set(p,"Tom");
        //4.输出当前属性的值
        System.out.println(name.get(p));
    }
}

6.2 调用运行时类的指定方法

//导入的包有:import org.junit.Test;import java.lang.reflect.Method;

//现在假设有一Person类,具有一般类所具有的属性,方法,构造器
public class ReflectionTest2 {
    @Test
    public void test2() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        /*
         1.获取某个指定方法
         getDeclaredMethod():参数1:指明获取方法的名称,参数2:指明获取的方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前方法是可访问的
        show.setAccessible(true);
        /*
        3.调用方法的invoke():参数1:方法的调用者,参数2:给方法形参赋值的实参
        invoke()的返回值即为对应类中调用的方法的返回值
        若调用运行时类的静态方法,则传入的参数1为Person.class
         */
        Object returnValue = show.invoke(p, "China");
    }
}

还可以调用运行时类的指定构造器,但是用非常少,这里不再演示

7. 反射的应用:动态代理

7.1 代理模式概述

代理设计模式的原理

  • 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象
  • 任何对原始对象的调用都要通过代理
  • 代理对象决定是否以及何时将方法调用转到原始对象上

代理模式分为静态和动态

  • 静态代理,特征是代理类和目标对象的类都是在编译期间确定下来,不利于程序的扩展。同时,每一个代理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理
  • 动态代理,是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象,可以更加灵活和统一的处理众多的方法

7.2 静态代理举例

interface ClothFactory{
    void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;//用被代理对象进行实例化
    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }
    @Override
    public void produceCloth() {
        System.out.println("代理工厂做准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做后续工作");
    }
}
//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}
public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        NikeClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}
/*代理工厂做准备工作
Nike工厂生产一批运动服
代理工厂做后续工作*/

你可能感兴趣的:(Java:反射机制)