彻底搞懂java反射机制

最新推荐文章于 2021-12-05 22:46:33 发布

zhangshk_

最新推荐文章于 2021-12-05 22:46:33 发布

阅读量378

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/zhangshk_/article/details/82719349

版权

java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

是什么？（概念）
为什么？（java中为什么需要这种机制，它可以解决什么问题）
可以干什么？（场景分析）
怎么干？ (卷起袖子撸)
总结

1. 是什么？

通俗的讲就是反射可以在运行时根据指定的类名获得类的信息。

（Java 反射机制是在运行状态中，对于任意一个类，都能够获得这个类的所有属性和方法，对于任意一个对象都能够调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态调用对象的方法的功能称为 Java 的反射机制。）

2. 为什么？

1.反射能够做什么：

在运行时检测对象的类型；（三种方式 Obeject.getClass() ; 类.class ; Class.forName(com.zsk.XXX)）
动态构造某个类的对象；（.newInstance()）
检测类的属性和方法； (.getFields(),.getMethods())
任意调用对象的方法； (.invoke())
修改构造函数、方法、属性的可见性；(.setAccessible(true);
)
以及其他。

2.反射能够解决那些实际的问题？

反射是框架中常用的方法。

例如，JUnit通过反射来遍历包含 @Test 注解的方法，并在运行单元测试时调用它们。（这个连接中包含了一些JUnit的使用案例）

对于Web框架，开发人员在配置文件中定义他们对各种接口和类的实现。通过反射机制，框架能够快速地动态初始化所需要的类。

例如，Spring框架使用如下的配置文件：

<beanid="someID"class="com.programcreek.Foo">

<propertyname="someField"value="someValue"/>

</bean>

当Spring容器处理<bean>元素时，会使用Class.forName("com.programcreek.Foo")来初始化这个类，并再次使用反射获取<property>元素对应的setter方法，为对象的属性赋值。

Servlet也会使用相同的机制：

<servlet>

<servlet-name>someServlet</servlet-name>

<servlet-class>com.programcreek.WhyReflectionServlet</servlet-class>

<servlet>

3. 可以干什么？（场景分析）

先从某个代码案例上来解释（套用一篇博文的一个例子：http://blog.csdn.net/justdoit_potato/article/details/51011843）

　　若是不用反射，它是这样的

interface fruit{  
    public abstract void eat();  

}  

class Apple implements fruit{  
    public void eat(){  
        System.out.println("Apple");  
    }  
}  
   
class Orange implements fruit{  
    public void eat(){  
        System.out.println("Orange");  
    }  
}  

// 构造工厂类  
// 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了  
class Factory{  
    public static fruit getInstance(String fruitName){  
        fruit f=null;  
        if("Apple".equals(fruitName)){  
            f=new Apple();  
        }  
        if("Orange".equals(fruitName)){  
            f=new Orange();  
        }  
        return f;  
    }  
}  
class Test{  
    public static void main(String[] a){  
        fruit f=Factory.getInstance("Orange");  
        f.eat();  
    }  

}

可以发现，每当我们要添加一种新的水果的时候，我们将不得不改变Factory中的源码，而往往改变原有正确代码是一种十分危险的行为。而且随着水果种类的增加，你会发现你的factory类会越来越臃肿，

而反射无疑是一种聪明的办法，看代码。

interface fruit{  
    public abstract void eat();  
}  
   
class Apple implements fruit{  
    public void eat(){  
        System.out.println("Apple");  
    }  
}  
   
class Orange implements fruit{  
    public void eat(){  
        System.out.println("Orange");  
    }  
}  
   
class Factory{  
    public static fruit getInstance(String ClassName){  
        fruit f=null;  
        try{  
            f=(fruit)Class.forName(ClassName).newInstance();  
        }catch (Exception e) {  
            e.printStackTrace();  
        }  
        return f;  
    }  
}  
class hello{  
    public static void main(String[] a){  
        fruit f=Factory.getInstance("Reflect.Apple");  
        if(f!=null){  
            f.eat();  
        }  
    }  
}

　　在出现新品种水果的时候，你完全不用去修改工厂的代码，只需要添加新的水果类就行了。

　我们实际开发中，会这么干嘛？

不是的，这还不是最终做法，开发种，我们一般会把水果类，放到配置文件中。当需要添加一种水果的时候，只需要在 config.properties文件中，声明相应的水果就可以了。我们的工厂类会通过类加载器加载这个配置文件。

package com.zsk;

public interface Fruit {}
class Apple implements Fruit{}
class Orange implements Fruit{}

加载的配置文件 config.properties：

Apple=com.zsk.Apple
Orange=com.zsk.Orange

工厂类 BasicFactory ：

package com.jas.reflect;

import java.io.FileReader;
import java.util.Properties;

public class BasicFactory {
    private BasicFactory(){}

    private static BasicFactory bf = new BasicFactory();
    private static Properties pro = null;

    static{
        pro = new Properties();
        try{    
            //通过类加载器加载配置文件
            pro.load(new FileReader(BasicFactory.class.getClassLoader().
                    getResource("config.properties").getPath()));
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static BasicFactory getFactory(){
        return bf;
    }

    //使用泛型获得通用的对象
    public  <T> T newInstance(Class<T> clazz){
        String cName = clazz.getSimpleName();   //获得字节码对象的类名
        String clmplName = pro.getProperty(cName);   //根据字节码对象的类名通过配置文件获得类的全限定名

        try{
            return (T)Class.forName(clmplName).newInstance();   //根据类的全限定名创建实例对象
        }catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
}

创建对象实例：

package com.jas.reflect;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        Apple apple= BasicFactory.getFactory().newInstance(Apple.class);
        Orange orange= BasicFactory.getFactory().newInstance(Orange.class);
        System.out.println(apple);
        System.out.println(orange);
    }
}

上面这个实例通过一个工厂创建不同对象的实例，通过这种方式可以降低代码的耦合度，代码得到了很大程度的扩展，以前要创建 Apple 对象需要通过 new 关键字创建 Apple 对象，如果我们也要创建 Orange 对象呢？是不是也要通过 new 关键字创建实例并向上转型为 Fruit ，这样做是麻烦的。

现在我们直接有一个工厂，你只要在配置文件中配置你要创建对象的信息，你就可以创建任何类型你想要的对象，是不是简单很多了呢？可见反射机制的价值是很惊人的。

4. 怎么干？

首先我们有一个Person类

public class Person {
     //私有属性
     private String name = "Tom";
     //公有属性
     public int age = 18;
     //构造方法
     public Person() {    
     }
     //私有方法
     private void say(String sth){
         System.out.println("private say()..."+sth);
     }
     //公有方法
     public void work(){
         System.out.println("public work()...");
     }
 }

1、得到 Class 的三种方式

 //1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
 //   类型的对象，而我不知道你具体是什么类，用这种方法
  　　Person p1 = new Person();
  　　Class c1 = p1.getClass();
          
 //2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
 //   这说明任何一个类都有一个隐含的静态成员变量 class
  　　Class c2 = Person.class;
          
 //3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
 //   但可能抛出 ClassNotFoundException 异常
 　　  Class c3 = Class.forName("com.ys.reflex.Person");

2、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

查阅 API 可以看到 Class 有很多方法：

　　getName()：获得类的完整名字。
　　getFields()：获得类的public类型的属性。
　　getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类
　　getMethods()：获得类的public类型的方法。
　　getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类
　　getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
　　getConstructors()：获得类的public类型的构造方法。
　　getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
　　newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

我们通过一个例子来综合演示上面的方法：

 //获得类完整的名字
 String className = c2.getName();
 System.out.println(className);//输出com.ys.reflex.Person
         
 //获得类的public类型的属性。
 Field[] fields = c2.getFields();
 for(Field field : fields){
    System.out.println(field.getName());//age
 }
         
 //获得类的所有属性。包括私有的
 Field [] allFields = c2.getDeclaredFields();
 for(Field field : allFields){
     System.out.println(field.getName());//name    age
 }
         
 //获得类的public类型的方法。这里包括 Object 类的一些方法
 Method [] methods = c2.getMethods();
 for(Method method : methods){
     System.out.println(method.getName());//work waid equls toString hashCode等
 }
         
 //获得类的所有方法。
 Method [] allMethods = c2.getDeclaredMethods();
 for(Method method : allMethods){
     System.out.println(method.getName());//work say
 }
         
 //获得指定的属性
 Field f1 = c2.getField("age");
 System.out.println(f1);
 //获得指定的私有属性
 Field f2 = c2.getDeclaredField("name");
 //启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
 f2.setAccessible(true);
 System.out.println(f2);
                 
 //创建这个类的一个对象
 Object p2 =  c2.newInstance();
 //将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
 f2.set(p2,"Bob");
 //使用反射机制可以打破封装性，导致了java对象的属性不安全。 
 System.out.println(f2.get(p2)); //Bob
         
 //获取构造方法
 Constructor [] constructors = c2.getConstructors();
 for(Constructor constructor : constructors){
     System.out.println(constructor.toString());//public com.ys.reflex.Person()
 }

我们通过一个例子来综合演示上面的方法：

3、通过 Class 类获取并调用成员变量、成员方法

获取并修改成员变量


Field f = c2.getField("name");
调用字段时：需要传递两个参数：
Object obj = c2.getConstructors().newInstance();
//为字段设置值
f.set(obj, "jack");
第一个参数：要传入设置的对象，第二个参数：要传入实参

获取并调用成员方法

m = stuClass.getDeclaredMethod("say", String.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, "hello");//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);//

5. 总结

灵活使用反射能让我们代码更加灵活，这里比如JDBC原生代码注册驱动，hibernate 的实体类，Spring 的 AOP等等都有反射的实现。但是凡事都有两面性，反射也会消耗系统的性能，增加复杂性等，合理使用才是真！

参考文章：

https://blog.csdn.net/sinat_38259539/article/details/71799078

https://www.cnblogs.com/yrstudy/p/6500982.html

https://blog.csdn.net/hupoling/article/details/72357217

https://www.cnblogs.com/ysocean/p/6516248.html

zhangshk_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
彻底搞懂java反射机制

是什么？（概念）为什么？（java中为什么需要这种机制，它可以解决什么问题）可以干什么？（场景分析）怎么干？ (卷起袖子撸) 总结 1. 是什么？通俗的讲就是反射可以在运行时根据指定的类名获得类的信息。（Java 反射机制是在运行状态中，对于任意一个类，都能够获得这个类的所有属性和方法，对于任意一个对象都能够调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态...
复制链接

扫一扫