反射

最新推荐文章于 2024-04-02 21:18:56 发布

学习使我可乐

最新推荐文章于 2024-04-02 21:18:56 发布

阅读量80

点赞数

分类专栏： java

原文链接：https://www.zhihu.com/question/24304289/answer/147529485

版权

java 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

作者：CaryTseng
链接：https://www.zhihu.com/question/24304289/answer/147529485
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

针对题主，重新修改下答案！首先看书要理解反射，很难完全理解，这关系到Java的语言特性，jvm的内存细节，当初我看反射，就像高票答案那样，照着写一遍，结果是你并没有理解，你只是照猫画虎，要想真正理解，我建议题主，不断深入探究，当你踩得足够深回过头来，你会柳暗花明！

这里我不打算像别的答案上来就上代码，给你讲怎么用，是啥是啥，老实说那样比较像培训java程序员的感觉，一点对知识的好奇心都没有，如果是想速成反射的，大家看别的答案吧。

写答案，可能会有默认知识现象，就是有些知识点，我知道，但你不知道，可以评论！这里我试着简单粗暴地解释一波！

首先我们了解一下JVM，什么是JVM，Java的虚拟机，java之所以能跨平台就是因为这个东西，你可以理解成一个进程，程序，只不过他的作用是用来跑你的代码的。上图是java的内存模型，我们关注的点，一个方法区，一个栈，一个堆，初学的时候老师不深入的话只告诉你java的内存分为堆和栈，易懂点吧！

假如你写了一段代码：Object o=new Object();

运行了起来！

首先JVM会启动，你的代码会编译成一个.class文件，然后被类加载器加载进jvm的内存中，你的类Object加载到方法区中，创建了Object类的class对象到堆中，注意这个不是new出来的对象，而是类的类型对象，每个类只有一个class对象，作为方法区类的数据结构的接口。jvm创建对象前，会先检查类是否加载，寻找类对应的class对象，若加载好，则为你的对象分配内存，初始化也就是代码:new Object()。

上面的流程就是你自己写好的代码扔给jvm去跑，跑完就over了，jvm关闭，你的程序也停止了。

为什么要讲这个呢？因为要理解反射必须知道它在什么场景下使用。

题主想想上面的程序对象是自己new的，程序相当于写死了给jvm去跑。假如一个服务器上突然遇到某个请求哦要用到某个类，哎呀但没加载进jvm，是不是要停下来自己写段代码，new一下，哦启动一下服务器，（脑残）！

反射是什么呢？当我们的程序在运行时，需要动态的加载一些类这些类可能之前用不到所以不用加载到jvm，而是在运行时根据需要才加载，这样的好处对于服务器来说不言而喻，举个例子我们的项目底层有时是用mysql，有时用oracle，需要动态地根据实际情况加载驱动类，这个时候反射就有用了，假设 com.java.dbtest.myqlConnection，com.java.dbtest.oracleConnection这两个类我们要用，这时候我们的程序就写得比较动态化，通过Class tc = Class.forName("com.java.dbtest.TestConnection");通过类的全类名让jvm在服务器中找到并加载这个类，而如果是oracle则传入的参数就变成另一个了。这时候就可以看到反射的好处了，这个动态性就体现出java的特性了！举多个例子，大家如果接触过spring，会发现当你配置各种各样的bean时，是以配置文件的形式配置的，你需要用到哪些bean就配哪些，spring容器就会根据你的需求去动态加载，你的程序就能健壮地运行。

答案比较粗糙，点到为止!

更新一个实例辅助更好地理解

在使用Spring写业务代码的时候，我们经常会用到注解来进行类的实例化，我们自定义一个注解

GPService

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPService {
    String value() default "";
}

我们的业务类QuerySerivce，这里就是模拟Spring的Service注解，我们用一个自定义注解。

@GPService
public class QuerySerivce implements IQueryService {
    public String query(String name) {
        return "query service result";
    }
}

然后我们在容器初始化的时候，我们需要扫描标有service注解的类，然后实例化后放进容器内。大概的代码如下：

//拿到全类名，用于定位类，这一步一般Spring是通过扫描项目路径来获取，这一步是动态获取的，反射的作用其实就在这里，思考下如果不用反射，我们要怎么实例化，不可能一个类一个类去定位，然后实例化
String className = "com.demo.QueryService";
//反射获取类的Class对象
Class<?> clazz=Class.forName(className);
//如果该类标注有GPService注解，我们就实例化这个类
if(clazz.isAnnotationPresent(GPService.class){
   Object instance = clazz.newInstance();
   //用map来模拟容器
   map.put(clazz.getSimpleName(),instance);
}

个人的博客地址：

每个类都有一个 Class 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。

类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 Class.forName("com.mysql.jdbc.Driver") 这种方式来控制类的加载，该方法会返回一个 Class 对象。

反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。

Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：

Field ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
Method ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
Constructor ：可以用 Constructor 的 newInstance() 创建新的对象。

反射的优点：

可扩展性：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
类浏览器和可视化开发环境：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
调试器和测试工具：调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。

反射的缺点：

尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。

18. 反射使用的步骤？

具体可以看下面的例子：

复制代码

public class Apple {

private int price;

public int getPrice() {

return price;

}

public void setPrice(int price) {

this.price = price;

}

public static void main(String[] args) throws Exception{

//正常的调用

Apple apple = new Apple();

apple.setPrice(5);

System.out.println("Apple Price:" + apple.getPrice());

//使用反射调用

Class clz = Class.forName("com.chenshuyi.api.Apple");

Method setPriceMethod = clz.getMethod("setPrice", int.class);

Constructor appleConstructor = clz.getConstructor();

Object appleObj = appleConstructor.newInstance();

setPriceMethod.invoke(appleObj, 14);

Method getPriceMethod = clz.getMethod("getPrice");

System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));

}

从代码中可以看到我们使用反射调用了 setPrice 方法，并传递了 14 的值。之后使用反射调用了 getPrice 方法，输出其价格。上面的代码整个的输出结果是：

复制代码

1 2	`Apple Price:5` `Apple Price:14`

从这个简单的例子可以看出，一般情况下我们使用反射获取一个对象的步骤：

复制代码

1	`Class clz = Class.forName("com.zhenai.api.Apple");`

复制代码

1	`Constructor appleConstructor = clz.getConstructor();`

复制代码

1	`Object appleObj = appleConstructor.newInstance();`

而如果要调用某一个方法，则需要经过下面的步骤：

复制代码

1	`Method setPriceMethod = clz.getMethod("setPrice",` `int.class);`

复制代码

1	`setPriceMethod.invoke(appleObj,` `14);`

19. 为什么引入反射概念？反射机制的应用有哪些？

我们来看一下 Oracle 官方文档中对反射的描述：

从 Oracle 官方文档中可以看出，反射主要应用在以下几方面：

也就是说，Oracle 希望开发者将反射作为一个工具，用来帮助程序员实现本不可能实现的功能。

举两个最常见使用反射的例子，来说明反射机制的强大之处：

第一种：JDBC 的数据库的连接

在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成

复制代码

public class ConnectionJDBC {

/**

* @param args

*/

//驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中

public static final String DBDRIVER = "com.mysql.jdbc.Driver";

//连接地址是由各个数据库生产商单独提供的，所以需要单独记住

public static final String DBURL = "jdbc:mysql://localhost:3306/test";

//连接数据库的用户名

public static final String DBUSER = "root";

//连接数据库的密码

public static final String DBPASS = "";

public static void main(String[] args) throws Exception {

Connection con = null; //表示数据库的连接对象

Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现

con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库

System.out.println(con);

con.close(); // 3、关闭数据库

}

第二种：Spring 框架的使用，最经典的就是xml的配置模式。

Spring 通过 XML 配置模式装载 Bean 的过程：

Spring这样做的好处是：

Class actionClass=Class.forName(“MyClass”);

Object action=actionClass.newInstance();

Method method = actionClass.getMethod(“myMethod”,null);

method.invoke(action,null);

上面就是最常见的反射使用的例子，前两行实现了类的装载、链接和初始化（newInstance方法实际上也是使用反射调用了<init>方法），后两行实现了从class对象中获取到method对象然后执行反射调用。</init>

因反射原理较复杂，下面简要描述下流程，想要详细了解的小伙伴，可以看这篇文章：https://www.cnblogs.com/yougewe/p/10125073.html

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称作根对象。

每次getMethod获取到的Method对象都持有对根对象的引用，因为一些重量级的Method的成员变量（主要是MethodAccessor），我们不希望每次创建Method对象都要重新初始化，于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor，每一次创建都会调用根对象的copy方法复制一份：

复制代码

Method copy() {

Method res = new Method(clazz, name, parameterTypes, returnType,

exceptionTypes, modifiers, slot, signature,

annotations, parameterAnnotations, annotationDefault);

res.root = this;

res.methodAccessor = methodAccessor;

return res;

}

调用Method.invoke之后，会直接去调MethodAccessor.invoke。MethodAccessor就是上面提到的所有同名method共享的一个实例，由ReflectionFactory创建。

创建机制采用了一种名为inflation的方式（JDK1.4之后）：如果该方法的累计调用次数<=15，会创建出NativeMethodAccessorImpl，它的实现就是直接调用native方法实现反射；如果该方法的累计调用次数>15，会由java代码创建出字节码组装而成的MethodAccessorImpl。（是否采用inflation和15这个数字都可以在jvm参数中调整）
以调用MyClass.myMethod(String s)为例，生成出的MethodAccessorImpl字节码翻译成Java代码大致如下：

复制代码

public class GeneratedMethodAccessor1 extends MethodAccessorImpl {

public Object invoke(Object obj, Object[] args) throws Exception {

try {

MyClass target = (MyClass) obj;

String arg0 = (String) args[0];

target.myMethod(arg0);

} catch (Throwable t) {

throw new InvocationTargetException(t);

}

模拟 Spring 加载 XML 配置文件：

复制代码

public class BeanFactory {

private Map<String, Object> beanMap = new HashMap<String, Object>();

/**

* bean工厂的初始化.

* @param xml xml配置文件

*/

public void init(String xml) {

try {

//读取指定的配置文件

SAXReader reader = new SAXReader();

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

//从class目录下获取指定的xml文件

InputStream ins = classLoader.getResourceAsStream(xml);

Document doc = reader.read(ins);

Element root = doc.getRootElement();

Element foo;

//遍历bean

for (Iterator i = root.elementIterator("bean"); i.hasNext();) {

foo = (Element) i.next();

//获取bean的属性id和class

Attribute id = foo.attribute("id");

Attribute cls = foo.attribute("class");

//利用Java反射机制，通过class的名称获取Class对象

Class bean = Class.forName(cls.getText());

//获取对应class的信息

java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);

//获取其属性描述

java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();

//设置值的方法

Method mSet = null;

//创建一个对象

Object obj = bean.newInstance();

//遍历该bean的property属性

for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {

Element foo2 = (Element) ite.next();

//获取该property的name属性

Attribute name = foo2.attribute("name");

String value = null;

//获取该property的子元素value的值

for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {

Element node = (Element) ite1.next();

value = node.getText();

break;

}

for (int k = 0; k < pd.length; k++) {

if (pd[k].getName().equalsIgnoreCase(name.getText())) {

mSet = pd[k].getWriteMethod();

//利用Java的反射极致调用对象的某个set方法，并将值设置进去

mSet.invoke(obj, value);

}

//将对象放入beanMap中，其中key为id值，value为对象

beanMap.put(id.getText(), obj);

}

} catch (Exception e) {

System.out.println(e.toString());

}

//other codes

}

20. 反射机制的原理是什么？

复制代码

性能开销：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
安全限制：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
内部暴露：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。

作者：程序员库森
链接：https://www.nowcoder.com/discuss/601272
来源：牛客网

反射 API 用来生成 JVM 中的类、接口或则对象的信息。
Class 类：反射的核心类，可以获取类的属性，方法等信息。
Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
Method 类：Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
Constructor 类：Java.lang.reflec 包中的类，表示类的构造方法。
获取想要操作的类的Class对象，这是反射的核心，通过Class对象我们可以任意调用类的方法。
调用 Class 类中的方法，既就是反射的使用阶段。
使用反射 API 来操作这些信息。
获取类的 Class 对象实例
根据 Class 对象实例获取 Constructor 对象
使用 Constructor 对象的 newInstance 方法获取反射类对象
获取方法的 Method 对象
利用 invoke 方法调用方法
反射让开发人员可以通过外部类的全路径名创建对象，并使用这些类，实现一些扩展的功能。
反射让开发人员可以枚举出类的全部成员，包括构造函数、属性、方法。以帮助开发者写出正确的代码。
测试时可以利用反射 API 访问类的私有成员，以保证测试代码覆盖率。
通过Class.forName()加载数据库的驱动程序（通过反射加载，前提是引入相关了Jar包）；
通过 DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码；
通过Connection 接口接收连接。
将程序内所有 XML 或 Properties 配置文件加载入内存中；
Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息；
使用反射机制，根据这个字符串获得某个类的Class实例；
动态配置实例的属性。
不用每一次都要在代码里面去new或者做其他的事情；
以后要改的话直接改配置文件，代码维护起来就很方便了；
有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现。
反射获取类实例 Class.forName()，并没有将实现留给了java,而是交给了jvm去加载！主要是先获取 ClassLoader, 然后调用 native 方法，获取信息，加载类则是回调 java.lang.ClassLoader。最后，jvm又会回调 ClassLoader 进类加载！
newInstance() 主要做了三件事：
- 权限检测，如果不通过直接抛出异常；
- 查找无参构造器，并将其缓存起来；
- 调用具体方法的无参构造方法，生成实例并返回。
获取Method对象，
调用invoke()方法。调用invoke方法的流程如下：