Java反射与动态代理-蒲公英云

1.反射对象

1.1 通过反射构建无参数对象

public class ReflectServiceImpl { public void sayHello(String name){ System.err.println("Hello "+name); } public ReflectServiceImpl getInstance(){ ReflectServiceImpl object = null; try { //给类加载器注册一个类ReflectServiceImpl的全限定类名，然后通过newInstance方法初始化一个类对象 object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return object; } }

1.2 通过反射生成带有参数的构建方法

public class ReflectServiceImpl2 { private String name; public ReflectServiceImpl2(String name){ this.name = name; } public void sayHello(String name){ System.err.println("Hello "+name); } public ReflectServiceImpl2 getInstance(){ ReflectServiceImpl2 object = null; try { /* 想通过forName加载到类的加载器。然后通过getConstructor方法，他的参数可以是多个， 这里定义为String.class，意为有且只有一个参数类型为String的构建方法 通过这个方法可以对重名方法进行排除，此时再用newInstance方法生成对象，只是newIntstance方法也多了一个参数而已 实际就等于object=new ReflectServiceImpl2("迪丽热巴"); */ Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl2").getConstructor(String.class).newInstance("迪丽热巴"); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return object; } }

反射的优点是只要配置就可以生成对象，可以解除程序的耦合度，比较灵活。反射的缺点是运行比较慢。但是大部分情况下为了灵活度，降低程序的耦合度，我们还是会使用反射的。比如Spring IoC容器

2.反射方法

public class ReflectServiceImpl { public void sayHello(String name){ System.err.println("Hello "+name); } public ReflectServiceImpl getInstance(){ ReflectServiceImpl object = null; try { //给类加载器注册一个类ReflectServiceImpl的全限定类名，然后通过newInstance方法初始化一个类对象 object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return object; } //获取和反射方法 public Object reflectMethod(){ Object obj = null; ReflectServiceImpl target = new ReflectServiceImpl(); try { /* * 当有了具体的对象target,而不知道具体是哪个类时，也可以使用 * target.getClass().getMethod("sayHello", String.class);来代替他 * 其中第一个参数是方法名称，第二个参数是参数类型，是一个列表，多个参数可以继续编写多个类型，这样便能获得放射的方法对象 * * */ Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class); /* * 放射方法 是运用obj=method.invoke(target,"迪丽热巴");代码完成的 * 第一个参数是target ,就是确定用哪个对象调用方法，而"迪丽热巴"是参数 * 就等同于target.sayHello("迪丽热巴") * */ obj=method.invoke(target,"迪丽热巴"); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return obj; } }

3.实例

通过实例来看看如何放射生成对象和反射调度方法

public static Object reflect(){ ReflectServiceImpl object = null; try { //反射得到ReflectServiceImpl对象 object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance(); //反射得到sayHello方法 Method method = object.getClass().getMethod("sayHello", String.class); try { //相当于object.sayHello method.invoke(object,"迪丽热巴"); } catch (InvocationTargetException e) { e.printStackTrace(); } } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } return object; }

获取放射对象需要使用类加载器，获取放射方法需要知道是哪个对象

2.动态代理模式

动态代理的意义在于生成一个占位(又称代理对象)，来代理真实对象，从而控制真实对象的访问

先来谈谈什么是代理模式。假设这样的一个场景，你的公司是一家软件公司，你是一位软件工程师。客户带着需求去找公司显然不会直接和你谈，而是去找商务谈，此时客户会认为商务就代表公司。

让我们用一张图来表示代理模式的含义

显然客户是通过商务区访问软件工程师的，那么商务(代理对象)的意义在于什么呢?

商务可以进行谈判，比如项目启动前的商务谈判，软件的价格，交付进度的时间节点等，

或者项目完成后的商务追讨收账款等。

代理的作用就是：在真实对象访问之前或者之后加入对应的逻辑，或者根据其他的规则控制是否使用真实对象

经过上面的论述，我们知道商务和软件工程师是代理和被代理的关系，客户是经过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。

所以，我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须分为两个步骤

代理对象和真实对象建立代理关系
实现代理对象的代理逻辑方法

在Java中有多种动态代理技术，比如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种:一种是JDK动态代理，这是JDK自带的功能；另一种是CGLIB，这是第三方提供的一个技术。目前Spring常用JDK和CGLIB,而mybatis还是用了Javassist,无论哪种代理技术，他们的理念都是相似的。

在JDK动态代理中，我们必须使用接口，而CGLIB不需要。

2.1 JDK动态代理

JDK动态代理是 java.lang.reflect.*包提供的方式，他必须借助一个接口才能产生代理对象

定义接口

public interface HelloWorld { public void sayHelloWorld(); }

实现接口

public class HelloWordImpl implements HelloWorld { public void sayHelloWorld() { System.out.println("Hello World"); } }

这是最简单的Java接口和实现类的关系，此时可以开始动态代理了。按照我们之前的分析，先要建立起代理对象和真实服务对象的关系，然后实现代理逻辑，所以一共分为两步

在JDK动态代理中，要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，他里面定义了一个invoke方法，并提供接口数组用于下挂代理对象

//创建代理对象，必须实现InvocationHandler接口 public class JdkProxy implements InvocationHandler { //真实对象 private Object target = null; /** * 建立代理对象和真实对象的代理关系，并返回代理对象 * @param target 真实对象 * @return 代理对象 */ public Object bind(Object target){ //用于保存真实对象 this.target=target; //返回的是代理对象 return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this); } /** *代理方法逻辑 * @param proxy 代理对象 * @param method 当前调度方法 * @param args 当前方法参数 * @return 代理返回结果 * @throws Throwable 异常 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("进入代理逻辑方法"); System.out.println("在调度真实对象前的服务"); //相当于调度真实对象的方法，只是通过反射实现而已 Object obj = method.invoke(target, args); System.out.println("在调度真实对象之后的服务"); return obj; } }

第一步，建立代理对象和真实对象的关系。

newProxyInstance方法包含三个参数。

第一个是类加载器

第二个是把动态代理挂在哪个接口上

第三个是定义实现方法逻辑的代理类，this表示当前对象，他必须实现InvocationHandler接口的invoke方法，他就是代理逻辑方法的现实方法

第二步，实现代理逻辑方法，invoke方法可以实现代理逻辑，invoke方法的有3个参数

proxy,代理对象，就是bind方法生成的对象

method，当前调度的方法

args，调度方法的参数

测试动态代理

public static void testJdkProxy(){ JdkProxy jdk = new JdkProxy(); //绑定关系，因为挂在接口HelloWorld下，所以声明对象HelloWorld proxy HelloWorld proxy =(HelloWorld)jdk.bind(new HelloWordImpl()); //注意，此时HelloWorld对象已经是一个代理对象，他会进入代理的逻辑方法invoke里 proxy.sayHelloWorld(); }

CGLIB动态代理

JDK动态代理必须提供接口才能使用，在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理。他的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理

public class CglibProxy implements MethodInterceptor { /** * 生成CGLIB代理对象 * @param cls Class类 * @return Class类的CGLIB代理对象 */ public Object getProxy(Class cls){ //CGLIB enhancer 增强类对象 Enhancer enhancer = new Enhancer(); //设置增强类型 enhancer.setSuperclass(cls); //定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法 enhancer.setCallback(this); //生成代理对象并返回9 return enhancer.create(); } /** * * @param proxy 代理对象 * @param method 方法 * @param args 方法参数 * @param methodProxy 方法代理 * @return 代理逻辑返回 * @throws Throwable 异常 */ public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("调用真实对象前"); //CGLIB反射调用真实对象方法 Object result = methodProxy.invokeSuper(proxy,args); System.out.println("调用真实对象后"); return result; } }

这里用了CGLIB的加强者，通过设置超类的方法(setSuperclass)，然后通过setCallback(方法)设置哪个类为它的代理类。其中，参数为this就意味着当前对象，那就要求用this这个对象实现接口MethodInterceptor的方法——intercept，然后返回代理对象。

那么此时当前类的intercept方法就是其代理逻辑方法，其参数内容见代码注解，我们在反射真实对象前后进行了打印，CGLIB是通过如下代码完成的

Object result = methodProxy.invokeSuper(proxy,args);

测试一下CGLIB动态代理

public static void testCGLIBProxy(){ CglibProxy cp = new CglibProxy(); ReflectServiceImpl obj=(ReflectServiceImpl) cp.getProxy(ReflectServiceImpl.class); obj.sayHello("迪丽热巴"); }