2. 程式人生 > >jdk代理和cglib代理區別和例子

jdk代理和cglib代理區別和例子

阿新 • • 發佈：2019-01-02

代理目標

給某一個物件提供一個代理或佔位符，並由代理物件來控制對原物件的訪問，這句話的重點在於控制。

如何實現

既然要控制那麼如何實現呢？在方法執行之前、之後加上自己的邏輯處理就可以了。比如許可權檢查：如果一個方法在執行之前我們使用許可權代理去檢查一下這個人有沒有執行某個方法的許可權，如果有就執行，沒有就直接return返回或者報錯，這樣就可以達到控制的目的。

實現方式

定義一個介面和實現類

Hello介面：

package com.bsx.test.proxy;

public interface Hello {
    void say(String name);
}

HelloImpl實現類：

package com.bsx.test.proxy;

class HelloImpl implements Hello {
    @Override
    public void say(String name) {
        System.out.println("Hello! " + name);
    }
}

1.靜態代理

package com.bsx.test.proxy;

public class StaticProxy implements Hello {
    private Hello hello;

    public
 
 StaticProxy(Hello hello) {
        this.hello = hello;
    }

    private void before() {
        System.out.println("static proxy before ...");
    }

    private void after() {
        System.out.println("static proxy after ...");
    }

    @Override
    public void say(String name) {
        before();
        hello.say(name);
        after();
    }
}

2.jdk 動態代理

package com.bsx.test.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 介面動態代理需要2步
 * 第一步：定義額外的操作
 *  通過實現 InvocationHandler 介面，來定義在執行代理物件方法前後自己的動作。
 * 第二步：獲取代理物件
 *  通過 Proxy.newProxyInstance 獲取代理物件，這一步的作用是根據指定的1.classLoader，2.要代理的介面，以及3.傳遞進來的處理者。來生成真正的代理物件。
 */
public class InterfaceProxy implements InvocationHandler {
    // 獲取代理物件
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    private Object target;

    public InterfaceProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object object = method.invoke(target, args);
        after();
        return object;
    }

    private void before() {
        System.out.println("interface proxy before ...");
    }

    private void after() {
        System.out.println("interface proxy after ...");
    }
}

3.CGLIB動態代理

package com.bsx.test.proxy;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Cglib 動態代理需要2步：
 * 第一步：定義額外的操作
 *  通過實現 MethodInterceptor 介面，來定義在執行代理物件方法前後自己的動作。
 * 第二步：獲取代理物件
 *  通過 Enhancer.create 獲取代理物件，因為這個只需要。
 */
public class CglibProxy implements MethodInterceptor {
    // 獲取代理物件
    public <T> T getProxy(Class<T> clazz) {
        return (T) Enhancer.create(clazz, this);
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o, objects);
        after();
        return result;
    }

    private void before() {
        System.out.println("cglib proxy before ...");
    }

    private void after() {
        System.out.println("cglib proxy after ...");
    }
}

4.測試例子

package com.bsx.test.proxy;

public class TestProxy {
    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();
        //1.靜態代理
        StaticProxy staticProxy = new StaticProxy(helloImpl);
        staticProxy.say("dada");
        System.out.println("==========");
        //2.jdk 動態代理
        InterfaceProxy interfaceProxy = new InterfaceProxy(helloImpl);
        // 注意動態代理返回的是介面型別的物件
        // 所以，使用介面來標記改物件是可以的，
        // 如果使用實現類來接收該型別是會報錯的
        // 這就像是說人是動物是正確的，但是動物是人就不對了
        Hello hello = interfaceProxy.getProxy();
        hello.say("dada");
        System.out.println("==========");
        // 3.cglib 動態代理
        CglibProxy cglibProxy = new CglibProxy();
        // cglib 代理的是類，它的實現方式是通過繼承一個類作為它的子類來覆蓋父類中的方法
        HelloImpl helloProxy = cglibProxy.getProxy(HelloImpl.class);
        helloProxy.say("dada");
    }
}

升級代理為單例模式

jdk 單利模式

package com.bsx.test.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 介面動態代理需要2步
 * 第一步：定義額外的操作
 *  通過實現 InvocationHandler 介面，來定義在執行代理物件方法前後自己的動作。
 * 第二步：獲取代理物件
 *  通過 Proxy.newProxyInstance 獲取代理物件，這一步的作用是根據指定的1.classLoader，2.要代理的介面，以及3.傳遞進來的處理者。來生成真正的代理物件。
 */
public class InterfaceProxy implements InvocationHandler {
    private static final InterfaceProxy instance = new InterfaceProxy();

    public static InterfaceProxy getInstance() {
        return instance;
    }

    private InterfaceProxy() {
    }

    public <T> T getProxy(Object target) {
        this.target = target;
        return (T) Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
    }
    private Object target;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object object = method.invoke(target, args);
        after();
        return object;
    }

    private void before() {
        System.out.println("interface proxy before ...");
    }

    private void after() {
        System.out.println("interface proxy after ...");
    }
}

CGLIB代理

package com.bsx.test.proxy;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Cglib 動態代理需要2步：
 * 第一步：定義額外的操作
 *  通過實現 MethodInterceptor 介面，來定義在執行代理物件方法前後自己的動作。
 * 第二步：獲取代理物件
 *  通過 Enhancer.create 獲取代理物件，因為這個只需要。
 */
public class CglibProxy implements MethodInterceptor {
    private static final CglibProxy instance = new CglibProxy();

    public static CglibProxy getInstance() {
        return instance;
    }

    public <T> T getProxy(Class<T> clazz) {
        return (T) Enhancer.create(clazz, this);
    }

    private CglibProxy() {
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o, objects);
        after();
        return result;
    }

    private void before() {
        System.out.println("cglib proxy before ...");
    }

    private void after() {
        System.out.println("cglib proxy after ...");
    }
}

測試例子

從下面的測試更能夠清楚的看到，對於jdk代理來說，需要傳遞的引數就一個介面的實現類，而對於CGLIB代理來說，只需要傳遞被代理類的型別就可以了，因為jdk代理針對的是物件，而CGLIB代理針對的是類，所以不需要傳遞物件。

package com.bsx.test.proxy;

public class TestProxy {
    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();
        //1.靜態代理
        StaticProxy staticProxy = new StaticProxy(helloImpl);
        staticProxy.say("dada");
        System.out.println("==========");
        //2.jdk 動態代理
        Hello hello = InterfaceProxy.getInstance().getProxy(new HelloImpl());
        hello.say("dada");
        System.out.println("==========");
        // 3.cglib 動態代理
        HelloImpl helloProxy = CglibProxy.getInstance().getProxy(HelloImpl.class);
        helloProxy.say("dada");
    }
}

jdk代理和CGLIB代理的區別

一、簡單來說：

　　JDK動態代理只能對實現了介面的類生成代理，而不能針對類。

　　CGLIB是針對類實現代理，主要是對指定的類生成一個子類，覆蓋其中的方法（繼承）。

二、Spring在選擇用JDK還是CGLiB的依據：

  • (1)當Bean實現介面時，Spring就會用JDK的動態代理。
  • (2)當Bean沒有實現介面時，Spring使用CGlib實現。
  • (3)可以強制使用CGlib（在spring配置中加入）

三、CGlib比JDK快？

　 (1)使用CGLib實現動態代理，CGLib底層採用ASM位元組碼生成框架，使用位元組碼技術生成代理類，比使用Java反射效率要高。唯一需要注意的是，CGLib不能對宣告為final的方法進行代理，因為CGLib原理是動態生成被代理類的子類。

　 (2)在對JDK動態代理與CGlib動態代理的程式碼實驗中看，1W次執行下，JDK7及8的動態代理效能比CGlib要好20%左右。

相關推薦

jdk代理和cglib代理區別和例子

代理目標 給某一個物件提供一個代理或佔位符，並由代理物件來控制對原物件的訪問，這句話的重點在於控制。 如何實現 既然要控制那麼如何實現呢？在方法執行之前、之後加上自己的邏輯處理就可以了。比如許可權檢查：如果一個方法在執行之前我們使用許可權代理去檢查一下

Spring通過註解annotation方式注入Bean時，採用動態代理，那麼JDK代理和CGLIB代理區別？

切面程式設計是Spring中非常重要的一個模組，切面程式設計的實現原理是動態代理，那麼動態代理又有兩種實現方式：一種方法是直接實現JDK中的InvocationHandler介面，另一種方法是繼承CGLIB。 首先如果不是很清楚兩者的區別的話，記住一般情況下Invocati

JDK代理和Cglib代理實現和區別

一.JDK代理實現介面類public interface UserManager { void addUser(@NotBlank String username, @NotNull(message = "javax.validation.constraints.No

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

沒有 asm info 生成 字節 依據 技術分享 clas inf 代理模式：代理類和被代理類實現共同的接口（或繼承），代理類中存有指向被代理類的索引，實際執行時通過調用代理類的方法、實際執行的是被代理類的方法。 而AOP，是通過動態代理實現的。 一、簡單來說： 　　J

Spring的兩種代理JDK和CGLIB的區別淺談

一、原理區別： java動態代理是利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。 而cglib動態代理是利用asm開源包，對代理物件類的class檔案

JDK動態代理和cglib代理詳解

JDK動態代理 　　先做一下簡單的描述，通過代理之後返回的物件已並非原類所new出來的物件，而是代理物件。JDK的動態代理是基於介面的，也就是說，被代理類必須實現一個或多個介面。主要原因是JDK的代理原理是建立一個與被代理類同等級別（具有同樣的繼承或實現體系）的類，這裡稱之為代理類。那麼該代理類就

JDK代理和CGLIB代理 （springboot proxyTargetClass=true）

    首先總結下兩種代理的區別：          jdk的Proxy代理(必須傳入介面)  --spring預設使用         cglib(可以是類

JDK動態代理和cglib代理

tint append odi all require declared dad ava fun 寫一個簡單的測試用例，Pig實現了Shout接口 public class MyInvocation implements InvocationHandler { O

Spring原始碼分析總結(三)-JDK動態代理和CGLIB代理以及攔截器

   一、JDK動態代理和CGLIB代理方式:      1、如果目標物件實現了介面,預設會採用JDK代理實現AOP,也可以通過配置強制使用CGLIB實現       2、如果目標物件沒有實現介面，必須採用CGLIB庫，Spring會自動在JDK方式和CGLIB方式之前轉

jdk代理和cglib代理源代碼之我見

import emp pub fix efault 代理 rest mean violate 以前值是讀過一遍jdk和cglib的代理，時間長了，都忘記入口在哪裏了，值是記得其中的一些重點了，今天寫一篇博客，當作是筆記。和以前一樣，關鍵代碼，我會用紅色標記出來。 首先，先

關於jdk代理和cglib代理

implement ole start interface spa lib 調用方法 管理 todo 簡單的說說兩個代理的不同，CGLIB代理可以視為JDK代理的補充，JDK的代理是基於接口來實現的，也就是說使用JDK代理的類必須包含至少一個接口，調用代理的方法時，會不

java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總 Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）

若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。 一、概述1. 什麼是代理我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為

靜態代理，動態代理和CGLIB代理模式

代理模式 一、概述 　　代理是一種模式，提供了對目標物件的間接訪問方式，即通過代理訪問目標物件。如此便於在目標實現的基礎上增加額外的功能操作，前攔截，後攔截等，以滿足自身的業務需求，同時代理模式便於擴充套件目標物件功能的特點也為多人所用。 二、圖形描述 三、程式碼

jdk動態代理與CGLib的區別

jdk動態代理與CGLib的區別 2017年09月20日 22:31:10 E_k_in 閱讀數：5151 動態代理proxy與CGLib的區別 標籤： 代理模式 2013-09-03 08:50 19977人閱讀 評論(4)&nbs

java設定模式---代理模式--動態代理模式和cglib代理模式詳解

代理模式使用場景 代理模式的定義：什麼是代理模式呢？代理模式是常用的Java設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理消息等。代理類和委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物

代理、nsnotification和kvo的區別和用法

個人在網上瀏覽一些文件發現蠻有意思的，現轉載下來供大家學習檢視。 1.效率肯定是delegate比nsnotification高。 2. delegate方法比notification更加直接。 最典型的特徵是，delegate方法往往需要關注返回值

代理模式靜態代理 動態代理(JDK代理、cglib代理)

面向物件的設計原則: 開閉原則:對於修改來說是關閉,對於擴充套件來說是開放的 單一職責原則: 一個專案的功能單一 一個模組的功能單一 一個介面/類的功能單一 一個方法的功能單一 一個變數的功能單一 代理設計模

Unix和Linux的區別和聯系

源代碼 linux 操作系統 軟件 硬件 }區別：}1） UNIX系統大多是與硬件配套的，而Linux則可運行在多種硬件平臺上. }2） UNIX是商業軟件，而Linux是自由軟件，免費、公開源代碼的. }聯系：}Linux的思想源於Unix }遵從POSIX（可移植操作系統環境）規範的一

Java == ,equals 和 hashcode 的區別和聯系

應對 哈希表 返回對象 com 總結 子類 return 地址 內存 1. == java中的==是比較兩個對象在JVM中的地址。比較好理解。看下面的代碼： public class ComAddr{ public static void main(St

視圖和表的區別和聯系

比較 方式 使用 連接 算法 他在 集合 區別 存在可更新 數據庫中的數據都是存儲在表中的，而視圖只是一個或多個表依照某個條件組合而成的結果集，一般來說你可以用update，insert，delete等sql語句修改表中的數據，而對視圖只能進行select操作。但是也存在可