JAVA反射笔记

女爷i 2022-12-26 09:14 159阅读 0赞

# JAVA反射机制 #

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期  
借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内  
部属性及方法。  
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个  
类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可  
以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看  
到类的结构，所以，我们形象的称之为： 反射。  
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动  
态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。

## 获取Class 类的实例( 四种方法) ##

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

## 反射的应用举例 ##

• String str = “test4.Person”;  
• Class clazz = Class.forName(str);  
• Object obj = clazz.newInstance();  
• Field field = clazz.getField(“name”);  
• field.set(obj, “Peter”);  
• Object name = field.get(obj);  
• System.out.println(name);  
注：test4.Person是test4包下的Person类

## java.lang.Class类的理解 ##

1.加载过程  
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class)，再使用java.exe命令对某个字节码文件进行解释运行 相当于将某个字节码文件加载到内存中，此过程就称为类的加载。加载到内存中的类称为运行时类，此运行时类就作为Class的一个实例  
可以通过类造对象，而类本身也是Class的对象

## 类的加载与ClassLoaderd的理解 ##

类的加载过程：  
1.类的加载(Load)：将类的class字节码文件通过java.exe读入内存，并为之创建一个java.lang.Class对象。此过程由类加载  
器完成  
2.类的链接(Link)：将类的二进制数据合并到JRE中  
3.类的初始化(Initialize)：JVM负责对类进行初始化  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY5MTIyNw_size_16_color_FFFFFF_t_70_pic_center]  
类加载器的作用：

*  类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方  
    法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为  
    方法区中类数据的访问入口。
 *  类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器  
    中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

## 创建运行时类的对象 ##

创建 类的对象：调用Class对象的newInstance()方法  
要求：  
1）类必须有一个无参数的构造器。  
2）类的构造器的访问权限需要足够(大于private)。

在javabean中要求调用一个空参构造器，原因：  
1.便于通过反射，创建运行时类的对象  
2.便于子类继承此运行时类时，默认调用super()时保证父类有此构造器

## 获取运行时类的完整结构 ##

**以获取全部属性Field为例：**  
Class clazz = Person.class;

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

## 调用运行时类的属性结构 ##

Class clazz = Person.class;  
Person p = clazz.newInstance();  
Field Fieldname = clazz.getDeclaredField(“Fieldname”);  
//如果属性是private的  
Fieldname.setAccessable(true);  
Fieldname.invoke(p,args…);

## 反射的应用：动态代理 ##

静态代理，特征是代理类和目标  
对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代  
理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。 最  
好可以通过一个代理类完成全部的代理功能。

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时  
根据需要动态创建目标类的代理对象。  
动态代理相比于静态代理的优点：  
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中  
处理，这样，我们可以更加灵活和统一的处理众多的方法。

### 动态代理步骤 ###

/**
     * 动态代理举例：
     *
     *
     * @author yellowfish
     * @create 2020-12-07-14:49
     */
    interface Human{
        
        String getBelief();
        void eat(String food);
    
    }
    //被代理类
    class SuperMan implements Human{
        
        @Override
        public String getBelief() {
        
            return "I believe I can fly";
        }
    
        @Override
        public void eat(String food) {
        
            System.out.println("我喜欢吃"+food);
        }
    }
    /*
    要想实现动态代理所需解决的问题：
    问题一：如何根据加载到内存的被代理类，动态的创建一个代理类及其对象
    问题二：当通过代理类的对象调用方法时，如何动态的调用被代理类的同名方法
     */
    
    //代理工厂：为被代理类提供普适的代理方式
    class ProxyFactory {
        
        //调用此方法返回一个代理类的对象,解决问题一
        public static Object getProxyInstance(Object obj) {
        //obj:被代理类的对象
            MyInvocationHandler handler = new MyInvocationHandler();
            handler.bind(obj);
            //Proxy.newProxyInstance()：三个参数：被代理类的类加载器 被代理类实现的接口
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    
        }
    }
    class  MyInvocationHandler implements InvocationHandler{
        
        //创建被代理类对象
        private Object obj;
        //被代理类赋值的方法
        public void bind(Object obj){
        
            this.obj = obj;
        }
            //当我们通过代理类的对象，调用方法a时，就会自动调用如下方法：invoke()
        //将被代理类a方法要执行的功能声明在invoke中
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            //method即为代理类对象调用的方法，此方法也就作为了被代理类对象调用的方法
            Object invoke = method.invoke(obj,args);
            return invoke;
        }
    }
    
    
    public class ProxyTest {
        
        public static void main(String[] args) {
        
            SuperMan superMan = new SuperMan();
            //proxyInstance:代理类的对象
            Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
            String belief = proxyInstance.getBelief();
            System.out.println(belief);
            proxyInstance.eat("快餐");

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY5MTIyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/904638cd1a2c488d9f1edea55f1dc2f0.png