JAVA 反射机制

最新推荐文章于 2022-04-09 16:36:45 发布
最新推荐文章于 2022-04-09 16:36:45 发布
阅读量136 收藏
点赞数 1
分类专栏： Java反射 java 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42789301/article/details/114028529
版权

java反射机制是在运行状态中，对于任何类都能够得知这个类中的属性和方法。
对于任意一个对象，都能够调用它的任意一个方法和属性。

JAVA反射机制的功能：

  1. 在运行时判断任意属性类；
  2. 在运行时构造任意一个类方法；
  3. 在运行时判断任意一个类所具有的方法及属性；
  4. 在运行时调动任意一个类方法;
  5. 生成动态代理。

JAVA反射查看类信息：

  1. 使用Class类的forName(String className)静态方法。该方法需要传入字符串参数，该字符串参数的值是某个类的全限定名;
  2. 调用某个类的class属性来获取该类对应的Class对象;
  3. 调用某个对象的getClass()方法。该方法是java.lang.Object类中的一个方法。
 Class<?> aClass = Class.forName("com.demo.Reflect");
 Class<?> reflectClass= Reflect.class;
 Reflect reflect = new Reflect();
 Class<? extends Reflect> aClass1 = reflect.getClass();

获取Class成员变量

//获取所有属性
Field[] fields = aClass.getDeclaredFields();

//获取 public 属性
Field[] fields = aClass.getFields();
//获取所有指定属性
Field name = aClass.getDeclaredField("name");
//获取public 指定属性
Field brand = aClass.getField("textBack");
brand.set(obj,new String("我需要修改一个测试"));
String te = (String) brand.get(obj);
System.out.println("\n textBack = "+te);

获取Class对象方法

try {
            Class<?> aClass = Class.forName("com.demo.Reflect");
            Object obj = aClass.newInstance();
            //获取所有的方法
            Method[] declaredMethods = aClass.getDeclaredMethods();
           for (Method declaredMethod : declaredMethods) {
                String name = declaredMethod.getName();
                AnnotatedType annotatedReturnType = declaredMethod.getAnnotatedReturnType();
                System.out.println(name + "\n annotatedType = " + annotatedReturnType.getType());
            }

            //获取所有 public 方法
            Method[] methods = aClass.getMethods();
            for (Method method : methods) {
                String name = method.getName();
                AnnotatedType returnType = method.getAnnotatedReturnType();
                Type type = returnType.getType();
                System.out.println(name + "\n type = " + type);
            }
            Method reflect = aClass.getDeclaredMethod("testReflect", String.class);
            reflect.setAccessible(true);//打开修改私有方法权限
            reflect.invoke(obj, "你好呀");//第一个参数对应调用该方法的实例对象，第二个参数对应该方法的参数
            Method getRef = aClass.getDeclaredMethod("getRef");
            String invoke = (String) getRef.invoke(obj);
            System.out.println(invoke);
            return obj;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

public class Reflect implements Furniture {
    private String ref;
    private String name;
    private double price;
    private String brand;
    private double discounts;
    private String materials;
    private String colors;

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public double getPrice() {
        return price;
    }

    @Override
    public String getBrand() {
        return brand;
    }

    @Override
    public double getDiscounts() {
        return discounts;
    }

    @Override
    public String getMaterials() {
        return materials;
    }

    @Override
    public String getColor() {
        return colors;
    }

    public String textBack = "我要做测试";

    public void testBack(String test) {
        textBack = test;
    }

    private String annotatedReflect(String ref) {
        return ref;
    }

    private void testReflect(String ref) {
        this.ref= ref;
        System.out.println(ref);
    }
}

代理模式 给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问。

代理模式分类：

  1. 动态代理模式；
    运行时生成的。Java编译完成后并没有实际的class文件。而是在运行时动态生成字节码文件，并加载到JVM。
  2. 静态代理模式；
    在编译时就已经实现好。Java编译完成后代理类是一个实际的class文件。

静态代理实现：
RealSubject 对象以及Proxy对象 都实现了 接口Subject。在Proxy对象中，通过构造函数传递目标对象，然后重写接口Subject方法 request()，在该方法中调用RealSubject对象的request()方法。并可以在方法前后添加其他方法。

  RealSubject subject = new RealSubject();
  com.demo.Proxy proxy = new com.demo.Proxy(subject);
  proxy.request();

public class RealSubject implements Subject {
    private static String name = "";
    @Override
    public void request() {
        System.out.println("subject");
    }

    @Override
    public RealSubject reTrue(String str) {
        System.out.println(str);
        this.name = str;
        return this;
    }

    public String getName() {
        return name;
    }
}


public class Proxy implements Subject {
    private Subject subject;

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("proxySubject");
        subject.request();
        System.out.println("proxySubject2");
    }

    @Override
    public Proxy reTrue(String str) {

        return this;
    }
}

代理模式好处： 降低代码耦合度，方便维护。

动态代理：
动态代理主要涉及两个类。一个是 java.lang.reflect.Proxy代理类，另一个是java.lang.reflect.InvocationHandler调用处理器接口，通过重写invoke()方法来执行具体内容。
示例：
第一种方式

   RealSubject subject = new RealSubject();
        //创建一个 InvocationHandler对象
        InvocationHandler proxyHandler = new ProxyHandler(subject);

        Class<?> proxyClass = Proxy.getProxyClass(RealSubject.class.getClassLoader(),
                RealSubject.class.getInterfaces());
        try {
            Constructor<?> constructor = proxyClass.getConstructor(InvocationHandler.class);
            Subject realSubject = (Subject) constructor.newInstance(proxyHandler);
            realSubject.request();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

public interface Subject {
    void request();
    Subject reTrue(String str);
}

public class RealSubject implements Subject {
    private static String name = "";
    @Override
    public void request() {
        System.out.println("subject");
    }

    @Override
    public RealSubject reTrue(String str) {
        System.out.println(str);
        this.name = str;
        return this;
    }

    public String getName() {
        return name;
    }
}

public class ProxyHandler implements InvocationHandler {
        private Subject subject;

    public ProxyHandler(Subject subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //定义预处理的工作
        System.out.println("=======before=========");
        Object result =null;
        try {
//            method.invoke(subject,"我的天哪");
            if (method.getName().equals("reTrue")) {
                result = method.invoke(subject, "5555");

            }else{
                result = method.invoke(subject, args);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("=======after=========");
        return result;
    }
}

第二种方式:

 private static void instance() {
 RealSubject subject = new RealSubject();
        //创建一个 InvocationHandler对象
        ProxyHandler proxyHandler = new ProxyHandler(subject);
        //创建一个动态实例 getClassLoader()将生成的字节码加载到JVM中,getInterfaces()实现所有接口,创建Class对象.
        //自定义InvocationHandler
        Subject sbj = (Subject) Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
                RealSubject.class.getInterfaces(), proxyHandler);
        //调用对象方法
        sbj.request();
        RealSubject RealSubject = (RealSubject)sbj.reTrue("ddd");
        System.out.println(RealSubject.getName());
}



public interface Subject {
    void request();
    Subject reTrue(String str);
}

public class RealSubject implements Subject {
    private static String name = "";
    @Override
    public void request() {
        System.out.println("subject");
    }

    @Override
    public RealSubject reTrue(String str) {
        System.out.println(str);
        this.name = str;
        return this;
    }

    public String getName() {
        return name;
    }
}

public class ProxyHandler implements InvocationHandler {
        private Subject subject;

    public ProxyHandler(Subject subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //定义预处理的工作
        System.out.println("=======before=========");
        Object result =null;
        try {
//            method.invoke(subject,"我的天哪");
            if (method.getName().equals("reTrue")) {
                result = method.invoke(subject, "5555");

            }else{
                result = method.invoke(subject, args);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("=======after=========");
        return result;
    }
}
汪
关注
专栏目录
Java中的反射
张子又
01-07 297
反射的应用场合 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息 反射的作用 通过反射可以使程序代码访问装载到JVM 中的类的内部信息 获取已装载类的属性信息 获取已装载类的方法 获取已装载类的构造方法信息 在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中 —Class类：代表一个类 —Construct...
Java 反射机制
最新发布
水w的博客
10-08 1064
Java 反射机制
JAVA中的反射
qfc8930858的博客
04-30 1128
一 概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 反射就是把java类中...
Java 中的反射
ShadowySpirits的博客
07-06 1192
反射(Reflection)是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。  简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。 程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建...
java 反射机制
05-09
### Java反射机制深入理解 #### 一、反射机制概述 Java反射机制是一种强大的工具，它允许程序在运行时检查和操作任何类、方法、构造函数和字段等元素。这种能力对于构建灵活的应用程序和框架非常有用，特别是那些...
Java 反射机制实例详解
08-29
Java 反射机制实例详解 Java 反射机制实例详解是一种动态语言机制，允许在程序运行时加载、探知和使用编译期间完全不知道的类、生成其对象实体，调用其方法或者对属性设值。下面是 Java 反射机制实例详解的知识点：...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
利用java反射机制实现自动调用类的简单方法
09-01
Java反射机制是Java语言提供的一种强大功能，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在上述示例中，通过反射机制实现了动态调用类的方法，这种方式在某些场景下非常有用，比如插件...
java中的反射
sober_chen的博客
04-09 409
反射是什么？ java的反射是基于class对象也就是字节码文件生成实例对象的过程。由于字节码文件内记录这个对象的所有的方法，属性，因此可以通过class对象生成实例对象。 class对象内到底存了些什么？ 1、属性 class文件内存放代码内定义的所有属性，不管是什么修饰符修饰的都会记录下来。 2、方法 class文件内存放代码内定义的所有方法，不管是什么修饰符修饰的都会记录下来。 3、常量池 常量池相当于class文件的资源库，存储了后面字段、接口、方法等需要的字符串，后面结构使用只
Java基础之—反射（非常重要）
热门推荐
敬业小码哥的博客
05-13 75万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值