大佬,到底什么是Java的反射?「终于解决」

大佬,到底什么是Java的反射?「终于解决」上面两种方式的效果是一样的,都是创建了Order对象,调用Order对象的getPrice方法,只不过一个是普通调用、一个是反射调用。

欢迎大家来到IT世界,在知识的湖畔探索吧!

大佬,到底什么是Java的反射?「终于解决」

什么是反射

JAVA反射机制是在运行状态中,对于任何一个类,都能够知道这个类的所有属性和方法;对于任何一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

一般情况下,我们使用类来创建对象都是一开始就知道具体的类型以及类的用途,直接通过类来创建对象

Order order = new Order(new BigDecimal(4.32));
order.getPrice();

欢迎大家来到IT世界,在知识的湖畔探索吧!

而反射是一开始不知道我需要初始化的类是什么,到实际运行的时候才知道具体的类型,此时只能通过反射的API来创建对象

欢迎大家来到IT世界,在知识的湖畔探索吧!Class clazz = Class.forName("org.kxg.reflection.Order");
Method method = clazz.getMethod("getPrice");
Constructor constructor = clazz.getConstructor(BigDecimal.class);
Object object = constructor.newInstance(new BigDecimal(4.4));
method.invoke(object);

上面两种方式的效果是一样的,都是创建了Order对象,调用Order对象的getPrice()方法,只不过一个是普通调用、一个是反射调用

所以简单来说,反射就是在运行时才知道要操作的类是什么,并且可以在运行时获取类的完整构造,并调用对应的方法

为什么需要反射

Java在不同的时期可以分成两种编译类型:

  • 静态编译:就是我们常用的方式,在编译时就确定的类型
  • 动态编译:在编译时无法确认类型,到运行才确定类型

动态编译发挥了Java的灵活性,体现了多态的应用,可以减低类之间的耦合性

Java反射是Java被视为动态语言的一个关键性质。

这个机制允许程序在运行时通过反射取得任何一个已知名称的class的内部信息,包括其modifiers(诸如public、static等)、superclass(例如Object)、实现之interfaces(例如Cloneable),也包括fields和methods的所有信息,并可于运行时改变fields内容或唤起methods。

Reflection可以在运行时加载、探知、使用编译期间完全未知的classes。

即Java程序可以加载一个运行时才得知名称的class,获取其完整构造,并生成其对象实体、或对其fields设值、或唤起其methods

反射是解决什么问题?

反射(reflection)允许静态语言在运行时(runtime)检查、修改程序的结构与行为。 在静态语言中,使用一个变量时,必须知道它的类型。在Java中,变量的类型信息在编译时都保存到了class文件中,这样在运行时才能保证准确无误;换句话说,程序在运行时的行为都是固定的。如果想在运行时改变,就需要反射这东西了

一句话概括就是使用反射可以赋予jvm动态编译的能力,否则类的元数据信息只能用静态编译的方式实现,例如热加载,Tomcat的classloader等等都没法支持

反射常用API

1、反射获取Class对象

//方式一:通过Class.forName()获取Class
Class c1 = Class.forName("org.kxg.reflection.Order");

//方式二:使用.class方法
Class c2 = Order.class;

//方式三:通过getClass()方法
Order o = new Order(new BigDecimal(1));
Class c3 = o.getClass();

2、通过反射创建类对象

欢迎大家来到IT世界,在知识的湖畔探索吧!//方式一:通过Class对象的newInstace()方法创建对象
Class c1 = Class.forName("org.kxg.reflection.Order");
Order o1 = (Order) c1.newInstance();

//方式二:通过Constructor对象的newInstance()方法创建对象
Class c2 = Order.class;
Constructor constructor = c2.getConstructor(Order.class);
Order o2 = (Order) constructor.newInstance();

3、获取类的属性

Order o = new Order(new BigDecimal(1));
Class c3 = o.getClass();

//只能获取除私有以外的属性
Field[] fields = c3.getFields();
//获取所有属性
Field[] fields1 = c3.getFields();

4、获取类方法

Order o = new Order(new BigDecimal(1));
Class c3 = o.getClass();
Method[] methods = c3.getMethods();

5、获取注解

Order o = new Order(new BigDecimal(1));
Class c3 = o.getClass();
Annotation[] annotations = c3.getAnnotations();

反射实现动态代理

实现方式:利用Java的反射机制,在java.lang.reflect 包下提供了Proxy类和InvocationHandler 接口来实现动态代理

下面以增加日志的需求来演示一下JDK动态代理的用法

//抽象对象
public interface CustService {
  public void editCust();
}

//真实对象
public class CustServiceImpl implements CustService {
  public void editCust() {
    System.out.println("edit cust ----");
  }
}

//日志对象
public class LogService {
  public void addLog(){
    System.out.println("add log ----");
  }
}

//动态代理对象
public class JDKProxyCustService implements InvocationHandler {

  private Object target;
  private LogService logService = new LogService();

  public JDKProxyCustService(Object target){
    this.target = target;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();
    System.out.println("methodName:" + methodName );
    logService.addLog();
    Object o = method.invoke(target,args);
    logService.addLog();
    return o;
  }
}

//测试
public class TestJDKProxy {

  public static void main(String[] args){
    CustService custService = new CustServiceImpl();
    Class c = custService.getClass();
    ClassLoader classLoader = c.getClassLoader();//目标对象的类加载器
    Class[] interfaces = c.getInterfaces();//目标对象实现的所有接口
    InvocationHandler h = new JDKProxyCustService(custService);//获取一个InvocationHandler,并将custService对象传入

    /**
     * 参数说明:
     * 1.classLoader表示目标对象的类加载器
     * 2.interfaces表示目标对象实现的所有接口
     * 3.InvocationHandler接口的实现
     */
    CustService proxy = (CustService) Proxy.newProxyInstance(classLoader,interfaces,h);
    proxy.editCust();
  }
}

运行结果:
methodName:editCust
add log ----
edit cust ----
add log ----

每个动态代理类(JDKProxyCustService)都必须实现InvocationHandler接口,当我们通过代理对象调用方法时,调用会被转到InvocationHandler接口的invoke方法。

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

proxy:被代理的真实对象 method:调用真实对象的某个方法 args:调用真实对象某个方法所传的参数

实际上,真正有用的代码是:

Object o = method.invoke(target,args);

利用Java的反射机制,动态的去调用目标对象的方法。 再来看看Proxy类,我们在测试类中真正有用的代码是:

CustService proxy = (CustService) Proxy.newProxyInstance(classLoader,interfaces,h);

Proxy类的作用就是创建一个动态代理对象的类,newProxyInstance方法的作用是创建一个动态代理的对象 参数说明: classLoader:目标对象的类加载器 interfaces:目标对象所实现的所有接口 h:InvocationHandler接口的实现

还有这句:

InvocationHandler h = new JDKProxyCustService(custService);

传入需要代理的真实对象,实现调用的就是真实对象的方法

参考:

https://www.cnblogs.com/chanshuyi/p/head_first_of_reflection.html

https://blog.csdn.net/grandgrandpa/article/details/84832343

免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://itzsg.com/17713.html

(0)

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

联系我们YX

mu99908888

在线咨询: 微信交谈

邮件:itzsgw@126.com

工作时间:时刻准备着!

关注微信