反射代理

关于代码块

代码块有两种，静态代码块，和普通代码块。

静态代码块属于类级别的，加载的时候执行，普通代码块属于对象级别，创建对象的时候执行。而且普通代码块优先于构造函数执行。

package mytest.Proxy.reflect;   public class Main {       public static void main(String[] args) throws InterruptedException {         //System.out.println(ZYP.name+":");         for(int i=0;i<2;i++){             Thread.currentThread().sleep(100);             System.out.println("\t第"+i+"次睡眠。");         }         ZYP zyp = new ZYP();         ZYP zyp1 = new ZYP();         ZYP zyp2 = new ZYP();     } } class ZYP {     static String name="zsc";     static{         System.out.println("静态代码块");     }     {         System.out.println("普通代码块");     }     public ZYP(){         System.out.println("构造方法");     } }

 

解释：静态代码块属于类级别的，普通代码块数据属于对象级别的。在程序运行的过程中说明了一下几点。

1. 程序启动时并不加载全部文件，在用到时就会去加载文件。加载完数据就会形成类的类对象存入内存。因为静态代码属于类级别，所以在加载的时候会执行静态代码块的代码。（新体会：Java程序之所以封装在函数里面就是要触发或着调用这个方法，然后这个触发的代码。而在代码块中的代码无需触发，就会在动执行。）
2. 在新创建实例的时候并不会再次加载文件，而是通过已经存在的类的类对象创建对象。（反射思考：在通过反射实现对象的时候，会根据类的路径先去找这个类的类对象，如果找到就通过类的类对象直接实例化一个对象，找不带就去加载文件，先有类的类对象，再通过这个类类对象创建类实例返回）。

 

 

资料：

要想理解反射的原理，首先要了解什么是类型信息。Java让我们在运行时识别对象和类的信息，主要有2种方式：一种是传统的RTTI，它假定我们在编译时已经知道了所有的类型信息；另一种是反射机制，它允许我们在运行时发现和使用类的信息。

理解RTTI在Java中的工作原理，首先需要知道类型信息在运行时是如何表示的，这是由Class对象来完成的，它包含了与类有关的信息。Class对象就是用来创建所有“常规”对象的，Java使用Class对象来执行RTTI，即使你正在执行的是类似类型转换这样的操作。

每个类都会产生一个对应的Class对象，也就是保存在.class文件。所有类都是在对其第一次使用时，动态加载到JVM的，当程序创建一个对类的静态成员的引用时，就会加载这个类。Class对象（类的class文件）仅在需要的时候才会加载，static初始化是在类加载时进行的。

创建对象的过程：

类加载器首先会检查这个类的Class对象是否已被加载过，如果尚未加载，默认的类加载器就会根据类名查找对应的.class文件。

想在运行时使用类型信息（使用类信息干什么？创建对象，调用静态方法，参数等），必须获取对象(比如类Base对象)的Class对象的引用，使用功能Class.forName(“ZYP”)可以实现该目的，或者使用ZYP.class。注意，有一点很有趣，使用功能”.class”来创建Class对象的引用时，不会自动初始化该Class对象，使用forName()会自动初始化该Class对象。（初始化class对象是指，目前我知道的是执行静态代码块这种东西）。

为了使用类而做的准备工作一般有以下3个步骤：

• 加载：由类加载器完成，找到对应的字节码，创建一个Class对象
• 链接：验证类中的字节码，为静态域分配空间
• 初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块

 

Class类与java.lang.reflect类库一起对反射进行了支持，该类库包含Field、Method和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。这样的话就可以使用Contructor创建新的对象，用get()和set()方法获取和修改类中与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。另外，还可以调用getFields()、getMethods()和getConstructors()等许多便利的方法，以返回表示字段、方法、以及构造器对象的数组，这样，对象信息可以在运行时被完全确定下来，而在编译时不需要知道关于类的任何事情。

　　反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于RTTI和反射之间的真正区别只在于：

• RTTI，编译器在编译时打开和检查.class文件
• 反射，运行时打开和检查.class文件

public class TestMath {             static{            System.out.println("类初始化了");       }             public static void beanClass(String zsc){            System.out.println("这个方法是类触发的");       }         public void beanMath(String zyp){            System.out.println("这个方法是对象触发的");       } }     public class ClassMain {       public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {        //Class class1 = TestMath.class;               Class<?> forName = Class.forName("mytest.Proxy.bean.TestMath");        System.out.println("--------加载完成---创建对象----------");        Object newInstance = forName.newInstance();        System.out.println("基类"+newInstance.getClass().getSuperclass().getName());        Method[] methods = forName.getDeclaredMethods();        for(Method m:methods){            System.out.println("方法："+m.getName());            Class<?>[] parameterTypes = m.getParameterTypes();            for(Class<?> o:parameterTypes){               System.out.println(o.getName());            }        }       }   }

 

问题

对象创建的过程。

在创建实例对象的时候，类加载器首先会检验该类的类类型是否被加载（就是.class文件），如果没有加载就会回根据类名字找到相应的class文件并加载到内存，形成对象。由加载的class对象创建对象。

 

Java的一切皆对象

从jvm的类加载器是对象，这个对象加载class文件形成类的类的class对象由这些对象创建普通的对象。而这些类型的类对象也是有对象组成，可以拿到class对象的方法对象，成员变量对象，构造器对象，方法参数对象，返回值对象。

 

 

代理

Java中源码已经实现了相应的动态代理，我们只需要编写下插件，组装机可。

InvocationHandler 接口的invoke方法需要自己实现，这个方法就是在被代理调用方法是的时候就会走这个invoke方法。

Proxy类主要是给接口返回一个代理的对象。

 

通过反射和动态代理简单模拟一个rpc

Java方法，需要被代理的类

//接口 public interface Animal {         String eat(String fool); }   class Lion implements Animal {     @Override     public String eat(String fool) {        return "lion eat "+fool;     } }

反射工具类

public class ReflectUtill {     public static class MyInvocatioHandler2 implements InvocationHandler{        Class<?> clazz= null;        /*public MyInvocatioHandler2(Class<?> clazz) {            this.clazz = clazz;        }*/          @Override        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            /*Method[] declaredMethods = proxy.getClass().getDeclaredMethods();            for(Method m:declaredMethods){               System.out.println(m.getName());            }            System.out.println("----------------");*/            System.out.println(proxy.getClass().isInterface());            Object sendMessg = SocketUtill.sendMessg(proxy.getClass().getName(), method.getName(), 1,2,3,4,5);            return sendMessg;        }     }          public static Object getProxy(Class<?>[] clazz){         ClassLoader loader = Thread.currentThread().getContextClassLoader();         Object newProxyInstance = Proxy.newProxyInstance(loader, clazz, new MyInvocatioHandler2());        return newProxyInstance;      }     }

 

通信工具类（模拟的）

public class SocketUtill {       /**这个方法模拟远程的方法，运行需要运行的类，运行的方法，运行需要的参数作为运行条件，      * 这个方法可以作为客户端，远端是服务端，此客户端的将运行条件传到服务端，服务端得到运行条件，根据需要到运行的类      * 反射出该类的对象，得到需要运行的方法，和运行需要的参数，运行方法得到结果，将结果传回客户端。      * @param objects      * @return      */     public static Object sendMessg(String clazz,String method,Integer... objects){        System.out.println("需要运行的类："+clazz+",运行的方法："+method);        Integer sum = sum(objects);               return Integer.toString(sum);     }         public static Integer sum(Integer... objects){        int sum1 = 0;        for(int i=0;i<objects.length;i++){            sum1+=objects[i];        }        return sum1;     } }

运行类

public class RPCMain {       public static void main(String[] args) {        Class<?>[] clazz=new Class<?>[1];        clazz[0]=Animal.class;        Animal animal= (Animal) ReflectUtill.getProxy(clazz);        String eat = animal.eat("参数");        System.out.println(eat);       }   }

运行结果是15.

因为我在接口的invoke方法里面执行了通信的方法，这个方法是加了几个数，这里想说明的是，当被代理的对象执行调用方法时，其实执行的是invoke的代码，所以被代理对象的执行结果主要的是看invoke方法怎么执行代码。