12 反射

反射机制：前提：jvm已经加载这个类，通过一个抽象的类名能够在自己记忆（加载类的内存）中找到相匹配的类的具体信息

  • JAVA reflection
    反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

Java反射机制提供的功能
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

反射相关的主要API：
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法

Class类

在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头， 实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称

通过Class类反射可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。

实例化Class类对象的四种方法

  1. 前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
    实例：Class clazz = String.class;
  2. 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
    实例：Class clazz = “www.xyd.com”.getClass();
  3. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，最常用的方法
    实例：Class clazz = Class.forName(“java.lang.String”);
  4. 其他方式(不做要求)
    ClassLoader cl = this.getClass().getClassLoader();
    Class clazz4 = cl.loadClass(“类的全类名”);

通过反射调用类的完整结构：
通过反射可以取得：

  1. 获得实现的所有接口
Class clazz = Class.forName("com.ying.javaBase.Student1"); // 通过包名.类名的字符串，获取指定类的class实例
Class[] interfaces = clazz.getInterfaces(); // 获取当前类的所有接口
      for (Class anInterface : interfaces) {
        System.out.println("接口: " + anInterface.getName());
      }
输出：
接口: com.ying.javaBase.Move
接口: com.ying.javaBase.Study
  1. 获取所继承的父类
Class clazz = Class.forName("com.ying.javaBase.Student1"); // 通过包名.类名的字符串，获取指定类的class实例
Class superClazz = clazz.getSuperclass(); // 获取父类
System.out.println("父类: " + superClazz.getName());
输出：
父类: com.ying.javaBase.Person1
  1. 获取全部的构造器
    public Constructor<T>[] getConstructors()
    返回此 Class 对象所表示的类的所有public构造方法。
    public Constructor<T>[] getDeclaredConstructors()
    返回此 Class 对象表示的类声明的所有构造方法。包括私有和公有
    Constructor类中：
    取得修饰符: public int getModifiers();
    取得方法名称: public String getName();
    取得参数的类型：public Class<?>[] getParameterTypes();
//测试获取类的所有构造方法，包括公有和私有
      Constructor[] cons1 = clazz.getDeclaredConstructors();
      for (Constructor con : cons1) {
        System.out.println("---------------------------");
        System.out.println("构造方法名称： " + con.getName());//取得方法名称
        //返回修饰符，返回数字1代表public，返回数字2,代表private
        System.out.println("构造方法" + con.getName() + "的修饰符名称： " + con.getModifiers()); //取得方法修饰符
        for (Class parameterType : con.getParameterTypes()) {
          System.out.println("参数类型之一是：　" +parameterType.getName());
        }
        System.out.println("---------------------------");
      }
输出：
---------------------------
构造方法名称： com.ying.javaBase.Student1
构造方法com.ying.javaBase.Student1的修饰符名称： 1
---------------------------
---------------------------
构造方法名称： com.ying.javaBase.Student1
构造方法com.ying.javaBase.Student1的修饰符名称： 2
参数类型之一是：　java.lang.String
参数类型之一是：　int
---------------------------
---------------------------
构造方法名称： com.ying.javaBase.Student1
构造方法com.ying.javaBase.Student1的修饰符名称： 1
参数类型之一是：　java.lang.String
---------------------------
  • 用反射的构造方法创建对象
  1. 获取默认的无参的构造方法
Class clazz = Class.forName("com.ying.javaBase.Student1"); // 通过包名.类名的字符串，获取指定类的class实例
 //通过反射的构造方法来创建对象
Object o = clazz.newInstance();//相当于调用Student1的无产，公有的构造方法
Student1 stu = (Student1) o;

java.lang.reflect.Constructor:代表类的构造方法

  1. 获取指定的公有的构造方法来创建对象
Constructor c = clazz.getConstructor(String.class);//指定获取有一个参数为String类型的，公有的构造方法//
Student1 stu1 = (Student1) c.newInstance("第一中学");
System.out.println(stu1.school);
  1. 获取私有的构造方法来创建对象
Constructor c = clazz.getDeclaredConstructor(String.class, int.class);//指定获取带有两个参数的构造方法
      c.setAccessible(true);//解除私有的封装，便可以强制调用私有构造方法
      Student1 stu = (Student1) c.newInstance("张三", 12);

  • 通过反射获取所有的方法
    public Method[] getDeclaredMethods()
    返回此Class对象所表示的类或接口的全部方法，不包括父类的
    public Method[] getMethods()
    返回此Class对象所表示的类或接口的public的方法，包括父类的

    Method类中：
    public Class<?> getReturnType()取得全部的返回值
    public Class<?>[] getParameterTypes()取得全部的参数
    public int getModifiers()取得修饰符

  • 通过反射获取类的属性

public Field[] getFields()
返回此Class对象所表示的类或接口的public的Field。，包括父类的
public Field[] getDeclaredFields()
返回此Class对象所表示的类或接口的全部Field。不包括父类的

Field方法中：
public int getModifiers() 以整数形式返回此Field的修饰符
public Class<?> getType() 得到Field的属性类型
public String getName() 返回Field的名称。

  • 通过反射获取类的包
    Package getPackage()

java.lang.reflect.Method:代表类的方法

  • 通过反射获取指定方法
Constructor con = clazz.getConstructor();//获取无参构造
      Object obj = con.newInstance();//使用无参构造创建对象
      Student1 stu = (Student1)obj;
      //得到名称是公有的setInfo，参数是string string的方法
      Method m = clazz.getMethod("setInfo", String.class, String.class);
      m.invoke(stu, "张三", "第一中学");//参数一对象，后面的参数是调用当前方法的实际参数
      //如果想要调用私有方法
      Method m1 = clazz.getDeclaredMethod("test", String.class);
      m1.setAccessible(true); //解除私有的封装
      m1.invoke(stu, "李四");

      //调用重载方法
      Method m2 = clazz.getMethod("setInfo", int.class);
      m2.invoke(stu, 2);

      //有返回值的方法
      Method m3 = clazz.getMethod("getSchool");//获取方法名为getSchool，没有参数的方法
      System.out.println(m3.invoke(stu));

java.lang.reflect.Field:代表类的成员变量

Constructor con = clazz.getConstructor();
      Student1 stu = (Student1) con.newInstance();
      Field f = clazz.getDeclaredField("school");//获取名称为school的属性
      f.setAccessible(true);
      f.set(stu, "第三中学");//对stu对象的school属性设置值
      String school = (String) f.get(stu);
      System.out.println(school);

java动态代理

Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
创建一个动态代理类所对应的Class对象

  • 动态代理步骤：
    1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。
public class ProxyDemo implements InvocationHandler {

    Object obj;//被代理的对象

    public ProxyDemo(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println(method.getName() + "方法开始执行");
        Object result = method.invoke(this.obj, args);//执行的是指定代理对象的指定方法
        System.out.println(method.getName() + "方法执行完毕");


        return result;
    }
}

2.创建被代理的类以及接口
/**

  • 注意：如果一个对象想要通过Proxy.newProxyInstance方法被代理，
  • 那么这个对象的类一定要有相应的接口
  • 就像本类中的ITestDemo接口和实现类TestDemoImpl
    */
public interface ITestDemo {
    void test1();
    void test2();

}
public class TestDemoImpl implements ITestDemo{
    @Override
    public void test1() {
        System.out.println("执行test1()方案");
    }

    @Override
    public void test2() {
        System.out.println("执行test2()方案");
    }
}

3.通过Proxy的静态方法
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
4.通过 Subject代理调用RealSubject实现类的方法

ITestDemo test = new TestDemoImpl();
 /**
       * 需求：
       * 在执行方法前，打印 方法开始执行
       * 在执行方法后，打印 方法执行完毕
       * 打印的方法名和方法保持一致
       */
      InvocationHandler handler = new ProxyDemo(test);
      /**
       * newProxyInstance(ClassLoader, interface, h)
       * 参数一:ClassLoader: 代理对象的类加载器
       * 参数二：interface：被代理对象的接口
       * 参数三：H 代理对象
       * 返回值：成功被代理后的对象
       */
      ITestDemo t = (ITestDemo) Proxy.newProxyInstance(handler.getClass().getClassLoader(), test.getClass().getInterfaces(), handler);
      t.test1();
      System.out.println("-------------");
      t.test2();
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容