什么是設計模式（Design Pattern）？

設計模式是一套被反復使用，多數人知曉的，經過分類編目的，代碼設計經驗的總結。

代理模式的定義？

代理模式就是為其他對象提供一種代理，以控制對這個對象的訪問。

代理對象起到中介作用，可去掉功能服務或增加額外的服務。

代理對象和目標對象的關系？

代理對象：增強后的對象

目標對象：被增強的對象

他們不是絕對的，會根據情況發生變化。

代理模式的兩種實現方式？

1.靜態代理：代理和被代理對象在代理之前是確定的，它們都實現相同的接口或者繼承相同的抽象類。

2.動態代理：JDK通過接口反射得到字節碼，然后把字節碼轉換成class（通過native方法）

靜態代理實現的兩種方式？

使用繼承方式實現和使用聚合方式實現。

繼承：代理對象繼承目標對象，重寫需要增強的方法。缺點：代理類過多，產生類爆炸。

聚合：目標對象和代理對象實現同一個接口，代理對象當中要包含目標對象。

動態代理的實現方式？

Java動態代理類位于java.lang.reflect包下，一般主要涉及到以下兩個類：

1.Interface InvocationHandler : 該接口中僅定義了一個方法，public Object invoke(Object obj,Method method,Object[] args)，在實際使用時，第一個參數obj一般是指代理類，method是被代理的方法，args是該方法的參數數組，這個抽象方法在代理類中動態實現。

2.Proxy 該類即為動態代理類，static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h):返回代理類的一個實例，返回后的代理類可以當做被代理類使用(可使用被代理類在接口中聲明過的方法)

所謂的動態代理是這樣一種class：它是在運行時生成的class，該class需要實現一組interface，使用動態代理類時，必須實現InvocationHandler接口。

JDK動態代理和CGLIB動態代理的區別？

1.JDK動態代理只能代理實現了接口的類，沒有實現接口的類不能實現JDK的動態代理。

2.CGLIB動態代理針對類來實現代理的，對指定目標類產生一個子類，通過方法攔截技術攔截所有的父類方法的調用。

動態代理實現的思路：

1.聲明一段源碼（動態產生代理）

2.編譯源碼（JDK Compiler API ），產生新的類（代理類）

3.將這個類load到內存中，產生一個新的對象（代理對象）

4.return 代理對象。

使用靜態代理的例子：

1.首先創建業務邏輯接口

/** * 接口 * @author Administrator * */public interface Moveable { /** * * 接口中的方法 * @Description: TODO * @returnType： void */ void move();}

2.創建實現類，實現接口中的方法

/** * 實現類 * @author Administrator * */public class Car implements Moveable { @Override public void move() { //實現開車 try { Thread.sleep(new Random().nextInt(1000)); System.out.println('汽車行駛中...'); } catch (InterruptedException e) { e.printStackTrace(); } }}

3.使用繼承方式實現對實現類的代理

/** * 使用繼承方式實現代理 * @author Administrator * */public class Car2 extends Car { /* (non-Javadoc) * @see com.wk.design.proxy.Car#move() * 直接調用父類的move方法，這樣就形成了一個Car2對Car的代理 */ @Override public void move() { long startTime = System.currentTimeMillis(); System.out.println('汽車開始行駛...'); //使用繼承的方式調用父類的move（）方法 super.move(); long endTime = System.currentTimeMillis(); System.out.println('汽車行駛結束... 汽車行駛時間：'+(endTime-startTime)+'毫秒。'); }}

4.創建測試類

/** * 測試類 * @author Administrator * */public class Test { public static void main(String[] args) {// Car car = new Car();// car.move(); //使用繼承方式實現代理 Moveable car2 = new Car2(); car2.move(); //使用聚合方式實現代理// Car car = new Car();// Moveable car3 = new Car3(car);// car3.move(); }}

5.使用聚合方式實現對實現類的代理

日志代理類

/** * * 日志代理類 * @author Administrator * */public class CarLogProxy implements Moveable { /** * 使用接口聲明代理類 */ private Moveable m; /** * 通過構造方法的參數傳入代理類 * @param m */ public CarLogProxy(Moveable m) { super(); this.m = m; } @Override public void move() { System.out.println('日志開始'); //調用代理類的方法 m.move(); System.out.println('日志結束'); }}

時間代理類

/** * 時間代理類 * @author Administrator * */public class CarTimeProxy implements Moveable { /** * 使用接口聲明代理類 */ private Moveable m; /** * 通過構造方法的參數傳入代理類 * @param m */ public CarTimeProxy(Moveable m) { super(); this.m = m; } @Override public void move() { long startTime = System.currentTimeMillis(); System.out.println('汽車開始行駛...'); //調用代理類的方法 m.move(); long endTime = System.currentTimeMillis(); System.out.println('汽車行駛結束... 汽車行駛時間：'+(endTime-startTime)+'毫秒。'); }}

6.創建聚合方式測試類

/** * 聚合代理測試類 * @author Administrator * */public class TestJuHeProxy { public static void main(String[] args) { Car car = new Car(); //先記錄日志，再記錄時間// CarTimeProxy ctp = new CarTimeProxy(car);// CarLogProxy clp = new CarLogProxy(ctp);// clp.move(); //先記錄時間，再記錄日志 CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); }}

使用JDK動態代理實現的例子：

1.創建一個實現接口InvocationHandler的類，它必須實現invoke（）方法。

2.創建被代理類及接口

3.調用Proxy的靜態方法，創建一個代理類

4.通過代理調用方法

/** * 使用jdk的動態代理 * @author Administrator * */public class TimeHandler implements InvocationHandler { /** * 被代理對象 */ private Object target; public TimeHandler(Object target) { super(); this.target = target; } /** * 參數： * proxy ： 被代理對象 * method ： 被代理對象的方法 * args ： 方法的參數 * 返回值： * Object 方法的返回值 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //在執行被代理對象的方法之前執行自己的邏輯 long startTime = System.currentTimeMillis(); System.out.println('汽車開始行駛...'); //執行被代理對象的方法 method.invoke(target); //在執行被代理對象的方法之后執行自己的邏輯 long endTime = System.currentTimeMillis(); System.out.println('汽車行駛結束... 汽車行駛時間：'+(endTime-startTime)+'毫秒。'); return null; }}

/** * JDK動態代理測試類 * @author Administrator * */ public class JdkProxyTest { public static void main(String[] args) { Car car = new Car(); InvocationHandler h = new TimeHandler(car); Class<?> cls = car.getClass(); /** * 參數： * loader : 類加載器 * interfaces ： 實現接口 * h InvocationHandler */ Moveable m= (Moveable)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h); //執行被代理類的方法 m.move(); } }

使用CGLIB動態代理實現的例子：

1.創建代理類，實現MethodInterceptor接口

2.使用Enhancer類創建代理方法

3.創建被代理類，并編寫代理方法

4.通過代理調用方法

/** * 使用cglib動態代理 * @author Administrator * */public class Train { public void move(){ System.out.println('火車行駛中。。。'); }}

public class CglibProxy implements MethodInterceptor { private Enhancer enhancer = new Enhancer(); //創建代理類方法 public Object getProxy(Class clazz){ //設置創建子類的類 enhancer.setSuperclass(clazz); //回調函數 enhancer.setCallback(this); //創建并返回子類的實例 return enhancer.create(); } /** * 作用：攔截所有目標類方法的調用 * obj ： 目標類的實例 * m ： 目標方法的反射對象 * args ： 方法的參數 * proxy ： 代理類的實例 */ @Override public Object intercept(Object obj, Method m, Object[] args, MethodProxy proxy) throws Throwable { //在調用方法時實現自己的業務邏輯 System.out.println('日志開始...'); //代理類調用父類的方法 proxy.invokeSuper(obj, args); //調用方法之后實現自己的業務邏輯 System.out.println('日志結束...'); return null; }}

/** * 使用cglib動態代理的測試類 * @author Administrator * */ public class CglibProxyTest { public static void main(String[] args) { CglibProxy proxy = new CglibProxy(); //傳入要代理的類 Train t = (Train)proxy.getProxy(Train.class); //執行方法 t.move(); } }

以上就是詳解JAVA設計模式之代理模式的詳細內容，更多關于JAVA 代理模式的資料請關注好吧啦網其它相關文章！