代理模式的认知

就官方描述来说：

java的常用设计模式，代理类与委托类都同样的一个接口，代理类主要为委托类  做预处理消息，消息过滤，消息转发给委托类，以及事后消息处理等。代理类与委托类存在管理关系，代理对象与委托对象有管理，代理对象并不实现服务，代理对象通过调用委托对象的相关方法实现服务。

代理模式的作用：为其他对象提供一种代理用来控制对该对象的访问，客户端不想直接或者不能直接对目标对象的方法进行访问，代理对象就是客户端与目标对象之间的桥梁。

动态代理重要的接口 InvocationHandler

该接口需实现以下方法

public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {// TODO Auto-generated method stubreturn null;}

参数解读：

proxy:被代理的对象。

method:实现真实服务的方法

args:实现方法的参数

动态代理重要类：Proxy

Proxy类是专门完美代理的操作类，可以通过此类动态生成一个或者多个接口的实现类。提供了静态方法如下：

public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException 

参数解读：

ClassLoader loader :类加载器，用于找到被代理的类。

Class[] interfaces：得到全部接口，一个或者多个接口。

invocationHandler h：得到接口的子类（接口的实现类）

静态代理类代码说明

/*** 接口,包含方法 sellClother()* @author javadev**/public interface SellClotherInterface {public void sellClother();}

/*** 委托类，实现类接口sellClother,服务的真正实现类，包含实现方法* @author javadev**/public class BossFactoryService implements SellClotherInterface {@Overridepublic void sellClother() {// TODO Auto-generated method stubSystem.out.println("委托类实现卖出衣服操作");}}

/** * 静态代理类，实现接口SellClotherInterface, * 使用构造方法注入委托类. * 重写方法sellClother(),方法内通过委托类对象调用委托类方法实现服务。 * */public class staticProxy implements SellClotherInterface {private BossFactoryService bossSerive;public staticProxy(BossFactoryService bossSerive) {this.bossSerive = bossSerive;}@Overridepublic void sellClother() {System.out.println("买家在代理商确认购买衣服,下订单...");System.out.println("代理类调用委托类的方法...");bossSerive.sellClother();}public static void main(String[] args) {// TODO Auto-generated method stubBossFactoryService bossSellClothes = new BossFactoryService();//委托类实例SellClotherInterface scif = new staticProxy(bossSellClothes);// 代理类对象       scif.sellClother();// 代理类对象调用sellClother()方法卖衣服}}

动态代理类（JDK）：

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;/** * 动态代理类，实现接口InvocationHandler, * @author javadev * */public class SelClotherlProxy implements InvocationHandler {//目标委托类private Object target;//生成代理类public Object buildProxy(Object target){this.target = target;return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);//通过类加载器找到目标类，找到目标类的所有接口，找到invocationHandler接口的实现类(即代理类)。通过该类的方法newProxyInstance生成代理对象。}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {System.out.println("买家在代理商方确认购买衣服,下订单...");System.out.println("通过动态代理调用委托类的方法");Object result = method.invoke(target, args);System.out.println("买家收到货交易结束...");return result;}public static void main(String[] args) {// TODO Auto-generated method stubSelClotherlProxy proxy = new SelClotherlProxy();SellClotherInterface scif = (SellClotherInterface) proxy.buildProxy(new BossFactoryService());  scif.sellClother();}}

动态代理（cglib）

JDK代理是实现是依靠了接口的，但是有些类并没有接口，所以就不能使用JDK代理，cglib动态代理弥补了这一点。cgilib动态代理是对目标类生产一个子类

并覆盖其中的方法实现增强，因为是类的继承，所以不能对final修饰的类进行代理。

import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;/** * 使用cglib动态代理 */public class SellClotherProxy2 implements MethodInterceptor{private Object target;public Object buildProxy(Object target) {         this.target = target;         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(this.target.getClass());           // 回调方法         enhancer.setCallback(this);           // 创建代理对象          return enhancer.create();    }@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {        System.out.println("确认信息，确定下单...");       proxy.invokeSuper(obj, args);       System.out.println("买家收到货交易结束...");       return null;    }   public static void main(String[] args) {// TODO Auto-generated method stubSellClotherProxy2 proxy = new SellClotherProxy2();SellClotherInterface scif = (SellClotherInterface) proxy.buildProxy(new BossFactoryService());       scif.sellClother();}}