java两种动态代理方式的理解

package com.xdx.learn;public interface IOrder {
void delivery();//发货
void confirmReceipt();//确认收货
}

package com.xdx.learn;public class Order implements IOrder {
public void delivery() {
System.out.println("delivering the commodity");
} public void confirmReceipt() {
System.out.println("confirmReceipt the commodity"); }}

package com.xdx.learn;public class OrderProxy implements IOrder {
private Order order;//注入原来的Order类 public Order getOrder() {
return order;
} public void setOrder(Order order) {
this.order = order;
} public void delivery() {
System.out.println("do some log");//添加一些关于日志的操作
order.delivery();//目标类（被代理类）的业务逻辑 } public void confirmReceipt() {
System.out.println("do some log");//添加一些关于日志的操作
order.confirmReceipt();//目标类（被代理类）的业务逻辑
}}

public static void main(String args[]){
Order order=new Order();//目标类对象
OrderProxy proxy=new OrderProxy();//代理类对象
proxy.setOrder(order);//注入
proxy.delivery();//带有日志功能的发货操作
proxy.confirmReceipt();//带有日志功能的确认收货操作
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class OrderHander implements InvocationHandler {
private Object target;// 目标类对象，即被代理的对象 public OrderHander(Object target) {
this.target = target;
} public Object Bind() {
// 绑定操作，生成一个target的代理类对象，该代理类与目标类实现相同的接口，所以需要传入接口的参数。
，并且将该代理对象与this，也就是该OrderHander对象绑定
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
} /**
* 该方法是InvocationHandler的唯一的方法，当与该OrderHander类对象绑定的代理类的方法被调用的时候，
* 就会执行该方法，并且传入代理对象，方法对象，以及方法的参数。这样我们才可以用反射机制来调用目标类的方法。
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("do some log");
method.invoke(target, args);// 注意这边的第一个参数target，即目标类，而非代理类。因为执行的是目标类的业务逻辑。
System.out.println(method);
return null;
}
}

/**
* {@code InvocationHandler} is the interface implemented by
* the <i>invocation handler</i> of a proxy instance.
*
* <p>Each proxy instance has an associated invocation handler.
* When a method is invoked on a proxy instance, the method
* invocation is encoded and dispatched to the {@code invoke}
* method of its invocation handler.

public static void main(String args[]){
Order order=new Order();//目标对象
System.out.println(order);
OrderHander orderHander=new OrderHander(order);//调用处理器对象
IOrder orderProxy=(IOrder) orderHander.Bind();//生成代理对象,注意这里是IOrder对象，可以理解为多态吧，并且与orderHander绑定了
orderProxy.delivery();
orderProxy.confirmReceipt();
}

<!-- 动态代理cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.5</version>
</dependency>

package com.xdx.learn;public class Order {
public void delivery(){
System.out.println("delivering the commodity");
}
public void confirmRecipet(){
System.out.println("confirmRecipeting the commodity");
}}

package com.xdx.learn;import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;public class CglibInterceptor implements MethodInterceptor {
// 增强器，它的作用是对目标类对象增强，生成一个代理类，并且指定一个回调对象，这个回调对象一般是一个MethodInterceptor对象。
// 通过MethodInterceptor对象的拦截功能，即intercept方法，我们可以做一些增强工作。
private Enhancer enhancer = new Enhancer(); // 以下方法生成一个代理对象，它以目标对象的子类的形式存在
public Object getProxy(Class clazz) {
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);// 设置当前MethodInterceptor对象为enhancer对象的回调对象，这个步骤至关重要
return enhancer.create();// 调用create()方法生成一个子类（代理类，增强类）。
} /**
* 所有代理类调用的方法都会被这个方法所拦截，前提是该代理类设置的回调对象是该CglibInterceptor对象本身
*
* @param obj
* 代理类，也就是被增强的类
* @param method
* 被拦截的方法
* @param args
* 方法参数
* @param proxy
* 用于调用目标类（也就是父类）的方法
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("do some log");
System.out.println(obj.getClass().getName());
System.out.println(method);// System.out.println("使用MethodProxy对象调用父类的方法");
proxy.invokeSuper(obj, args);
return null;
}}

/**
* Generates dynamic subclasses to enable method interception. This
* class started as a substitute for the standard Dynamic Proxy support
* included with JDK 1.3, but one that allowed the proxies to extend a
* concrete base class, in addition to implementing interfaces. The dynamically
* generated subclasses override the non-final methods of the superclass and
* have hooks which callback to user-defined interceptor
* implementations.
* <p>
* The original and most general callback type is the {@link MethodInterceptor}, which
* in AOP terms enables "around advice"--that is, you can invoke custom code both before
* and after the invocation of the "super" method. In addition you can modify the
* arguments before calling the super method, or not call it at all.
* <p>

/**
* General-purpose {@link Enhancer} callback which provides for "around advice".
* @author Juozas Baliuka <a href="mailto:baliuka@mwm.lt">baliuka@mwm.lt</a>
* @version $Id: MethodInterceptor.java,v 1.8 2004/06/24 21:15:20 herbyderby Exp $
*/
public interface MethodInterceptor
extends Callback
{
/**
* All generated proxied methods call this method instead of the original method.
* The original method may either be invoked by normal reflection using the Method object,
* or by using the MethodProxy (faster).
* @param obj "this", the enhanced object
* @param method intercepted Method
* @param args argument array; primitive types are wrapped
* @param proxy used to invoke super (non-intercepted method); may be called
* as many times as needed
* @throws Throwable any exception may be thrown; if so, super method will not be invoked
* @return any value compatible with the signature of the proxied method. Method returning void will ignore this value.
* @see MethodProxy
*/
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
MethodProxy proxy) throws Throwable;}

public static void main(String args[]){
CglibInterceptor interceptor=new CglibInterceptor();
Order order=(Order) interceptor.getProxy(Order.class);//生成一个增强对象，并且已经指定了interceptor为callback对象
order.delivery();
order.confirmRecipet();
}