發表者

討論內容

冷日
(冷日)

發表時間：2019/4/19 8:08

Webmaster

註冊日: 2008/2/19
來自:
發表數: 15773

[轉貼]CGLIB(Code Generation Library)詳解

CGLIB(Code Generation Library)詳解

2017年04月19日 10:55:11

什麼是CGLIB

CGLIB是一個強大的、高性能的代碼生成庫。其被廣泛應用於AOP框架（Spring、dynaop）中，用以提供方法攔截操作。Hibernate作為一個比較受歡迎的ORM框架，同樣使用CGLIB來代理單端（多對一和一對一）關聯（延遲提取集合使用的另一種機制）。CGLIB作為一個開源項目，其代碼托管在github，地址為： https://github.com/cglib/cglib

為什麼使用CGLIB

CGLIB代理主要通過對字節碼的操作，為對像引入間接級別，以控制對象的訪問。我們知道Java中有一個動態代理也是做這個事情的，那我們為什麼不直接使用Java動態代理，而要使用CGLIB呢？答案是CGLIB相比於JDK動態代理更加強大，JDK動態代理雖然簡單易用，但是其有一個致命缺陷是，只能對接口進行代理。如果要代理的類為一個普通類、沒有接口，那麼Java動態代理就沒法使用了。關於Java動態代理，可以參者這裡 Java動態代理分析

CGLIB組成結構

CGLIB底層使用了ASM（一個短小精悍的字節碼操作框架）來操作字節碼生成新的類。除了CGLIB庫外，腳本語言（如Groovy何BeanShell）也使用ASM生成字節碼。ASM使用類似SAX的解析器來實現高性能。我們不鼓勵直接使用ASM，因為它需要對Java字節碼的格式足夠的瞭解

例子

說了這麼多，可能大家還是不知道CGLIB是幹什麼用的。下面我們將使用一個簡單的例子來演示如何使用CGLIB對一個方法進行攔截。
首先，我們需要在工程的POM文件中引入cglib的dependency，這裡我們使用的是2.2.2版本

dependency>
    groupId>
    artifactId>
    version>
dependency>

依賴包下載後，我們就可以幹活了，按照國際慣例，寫個hello world

class SampleClass {
    test(){
        System.);
    }
    main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(SampleClass.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.);
                Object result = proxy.invokeSuper(obj, args);
                System.);
                return result;
            }
        });
        SampleClass sample = (SampleClass) enhancer.create();
        sample.test();
    }
}

在mian函數中，我們通過一個Enhancer和一個MethodInterceptor來實現對方法的攔截，運行程序後輸出為：

run...
world
run...

在上面的程序中，我們引入了Enhancer和MethodInterceptor，可能有些讀者還不太瞭解。別急，我們後面將會一一進行介紹。就目前而言，一個使用CGLIB的小demo就完成了

常用的API

目前網絡上對CGLIB的介紹資料比較少，造成對cglib的學習困難。這裡我將對cglib中的常用類進行一個介紹。為了避免解釋的不清楚，我將為每個類都配有一個demo，用來做進一步的說明。首先就從Enhancer開始吧。

Enhancer

Enhancer可能是CGLIB中最常用的一個類，和Java1.3動態代理中引入的Proxy類差不多(如果對Proxy不懂，可以參考這裡)。和Proxy不同的是，Enhancer既能夠代理普通的class，也能夠代理接口。Enhancer創建一個被代理對象的子類並且攔截所有的方法調用（包括從Object中繼承的toString和hashCode方法）。Enhancer不能夠攔截final方法，例如Object.getClass()方法，這是由於Java final方法語義決定的。基於同樣的道理，Enhancer也不能對fianl類進行代理操作。這也是Hibernate為什麼不能持久化final class的原因。

class SampleClass {
    test(String input){
        ;
    }
}

下面我們將以這個類作為主要的測試類，來測試調用各種方法

@Test
testFixedValue(){
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(SampleClass.class);
    enhancer.setCallback(new FixedValue() {
        @Override
        loadObject() throws Exception {
            ;
        }
    });
    SampleClass proxy = (SampleClass) enhancer.create();
    System.//攔截test，輸出Hello cglib
    System.out.println(proxy.toString());
    System.out.println(proxy.getClass());
    System.out.println(proxy.hashCode());
}

程序的輸出為：

Hello cglib
Hello cglib
class .SampleClass$$EnhancerByCGLIB$$e3ea9b7
.Number
    at .hashCode(<generated>)
    ...

上述代碼中，FixedValue用來對所有攔截的方法返回相同的值，從輸出我們可以看出來，Enhancer對非final方法test()、toString()、hashCode()進行了攔截，沒有對getClass進行攔截。由於hashCode()方法需要返回一個Number，但是我們返回的是一個String，這解釋了上面的程序中為什麼會拋出異常。

Enhancer.setSuperclass用來設置父類型，從toString方法可以看出，使用CGLIB生成的類為被代理類的一個子類，形如：SampleClass $ $EnhancerByCGLIB $ $e3ea9b7

Enhancer.create(Object…)方法是用來創建增強對象的，其提供了很多不同參數的方法用來匹配被增強類的不同構造方法。（雖然類的構造放法只是Java字節碼層面的函數，但是Enhancer卻不能對其進行操作。Enhancer同樣不能操作static或者final類）。我們也可以先使用Enhancer.createClass()來創建字節碼(.class)，然後用字節碼動態的生成增強後的對象。

可以使用一個InvocationHandler(如果對InvocationHandler不懂，可以參考這裡)作為回調，使用invoke方法來替換直接訪問類的方法，但是你必須注意死循環。因為invoke中調用的任何原代理類方法，均會重新代理到invoke方法中。

throws Exception{
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(SampleClass.class);
    enhancer.setCallback(new InvocationHandler() {
        @Override
        throws Throwable {
            if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class){
                ;
            }else{
                );
            }
        }
    });
    SampleClass proxy = (SampleClass) enhancer.create();
    Assert.assertEquals(null));
    Assert.assertNotEquals(, proxy.toString());
}

為了避免這種死循環，我們可以使用MethodInterceptor，MethodInterceptor的例子在前面的hello world中已經介紹過了，這裡就不浪費時間了。

有些時候我們可能只想對特定的方法進行攔截，對其他的方法直接放行，不做任何操作，使用Enhancer處理這種需求同樣很簡單,只需要一個CallbackFilter即可：

@Test
throws Exception{
    Enhancer enhancer = new Enhancer();
    CallbackHelper callbackHelper = 0]) {
        @Override
        getCallback(Method method) {
            if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class){
                new FixedValue() {
                    @Override
                    throws Exception {
                        ;
                    }
                };
            }else{
                return NoOp.INSTANCE;
            }
        }
    };
    enhancer.setSuperclass(SampleClass.class);
    enhancer.setCallbackFilter(callbackHelper);
    enhancer.setCallbacks(callbackHelper.getCallbacks());
    SampleClass proxy = (SampleClass) enhancer.create();
    Assert.assertEquals(null));
    Assert.assertNotEquals(,proxy.toString());
    System.out.println(proxy.hashCode());
}

ImmutableBean

通過名字就可以知道，不可變的Bean。ImmutableBean允許創建一個原來對象的包裝類，這個包裝類是不可變的，任何改變底層對象的包裝類操作都會拋出IllegalStateException。但是我們可以通過直接操作底層對像來改變包裝類對象。這有點類似於Guava中的不可變視圖

為了對ImmutableBean進行測試，這裡需要再引入一個bean

class SampleBean {
    value;
    SampleBean() {
    }
    value) {
        value;
    }
    getValue() {
        value;
    }
    value) {
        value;
    }
}

然後編寫測試類如下：

@Test(expected = IllegalStateException.class)
throws Exception{
    SampleBean bean = new SampleBean();
    bean.setValue();
    SampleBean immutableBean = (SampleBean) ImmutableBean.create(bean); //創建不可變類
    Assert.assertEquals(,immutableBean.getValue());
    bean.setValue(//可以通過底層對像來進行修改
    Assert.assertEquals(, immutableBean.getValue());
    immutableBean.setValue(//直接修改將throw exception
}

Bean generator

cglib提供的一個操作bean的工具，使用它能夠在運行時動態的創建一個bean。

@Test
public void testBeanGenerator() throws Exception{
    BeanGenerator beanGenerator = new BeanGenerator();
    beanGenerator;
    Object myBean = beanGenerator;
    Method setter = myBean;
    setter;
    Method getter = myBean;
    Assert;
}

在上面的代碼中，我們使用cglib動態的創建了一個和SampleBean相同的Bean對象，包含一個屬性value以及getter、setter方法

Bean Copier

cglib提供的能夠從一個bean複製到另一個bean中，而且其還提供了一個轉換器，用來在轉換的時候對bean的屬性進行操作。

class OtherSampleBean {
    value;
    getValue() {
        value;
    }
    value) {
        value;
    }
}
@Test
testBeanCopier() throws Exception{
    BeanCopier copier = BeanCopier.create(SampleBean.class, OtherSampleBean.class, //設置為true，則使用converter
    SampleBean myBean = new SampleBean();
    myBean.setValue();
    OtherSampleBean otherBean = new OtherSampleBean();
    copier.copy(myBean, otherBean, //設置為true，則傳入converter指明怎麼進行轉換
   assertEquals(, otherBean.getValue());
}

BulkBean

相比於BeanCopier，BulkBean將copy的動作拆分為getPropertyValues和setPropertyValues兩個方法，允許自定義處理屬性

@Test
public void testBulkBean() throws Exception{
    BulkBean bulkBean = BulkBean.create(SampleBean.class,
            },
            },
            class});
    SampleBean bean = new SampleBean();
    bean.setValue();
    Object[] propertyValues = bulkBean.getPropertyValues(bean);
    assertEquals(1, bulkBean.getPropertyValues(bean).length);
    assertEquals(0]);
    bulkBean.setPropertyValues(bean,});
    assertEquals(, bean.getValue());
}

使用注意：
1. 避免每次進行BulkBean.create創建對象，一般將其聲明為static的
2. 應用場景：針對特定屬性的get,set操作，一般適用通過xml配置注入和注出的屬性，運行時才確定處理的Source,Target類，只需要關注屬性名即可。

BeanMap

BeanMap類實現了Java Map，將一個bean對像中的所有屬性轉換為一個String-to-Obejct的Java Map

@Test
public void testBeanMap() throws Exception{
    BeanGenerator generator = new BeanGenerator();
    generator;
    generator;
    Object bean = generator;
    Method setUserName = bean;
    Method setPassword = bean;
    setUserName;
    setPassword;
    BeanMap map = BeanMap;
    Assert;
    Assert;
}

我們使用BeanGenerator生成了一個含有兩個屬性的Java Bean，對其進行賦值操作後，生成了一個BeanMap對象，通過獲取值來進行驗證

keyFactory

keyFactory類用來動態生成接口的實例，接口需要只包含一個newInstance方法，返回一個Object。keyFactory為構造出來的實例動態生成了Object.equals和Object.hashCode方法，能夠確保相同的參數構造出的實例為單例的。

interface SampleKeyFactory {
    Object newInstance(String first, int second);
}

我們首先構造一個滿足條件的接口，然後進行測試

@Test
throws Exception{
    SampleKeyFactory keyFactory = (SampleKeyFactory) KeyFactory.create(SampleKeyFactory.class);
    Object key = keyFactory.newInstance(42);
    Object key1 = keyFactory.newInstance(42);
    Assert.assertEquals(key,key1);//測試參數相同，結果是否相等
}

Mixin(混合)

Mixin能夠讓我們將多個對象整合到一個對像中去，前提是這些對像必須是接口的實現。可能這樣說比較晦澀，以代碼為例：

MixinInterfaceTest {
    Interface1{
        String first();
    }
    Interface2{
        String second();
    }
    Interface1{
        @Override
        public String first() {
            ;
        }
    }
    Interface2{
        @Override
        public String second() {
            ;
        }
    }
    Interface2{
    }
    @Test
    Exception{
        Mixin mixin = Mixin.create(Class[]{Interface1.class, Interface2.class,
                        MixinInterface.class}, new Class2()});
        MixinInterface mixinDelegate = (MixinInterface) mixin;
        assertEquals(, mixinDelegate.first());
        assertEquals(, mixinDelegate.second());
    }
}

Mixin類比較尷尬，因為他要求Minix的類（例如MixinInterface）實現一些接口。既然被Minix的類已經實現了相應的接口，那麼我就直接可以通過純Java的方式實現，沒有必要使用Minix類。

String switcher

用來模擬一個String到int類型的Map類型。如果在Java7以後的版本中，類似一個switch語句。

@Test
throws Exception{
    String[] strings = };
    20};
    StringSwitcher stringSwitcher = StringSwitcher.create(strings,values,true);
    assertEquals());
    assertEquals());
    assertEquals(-));
}

Interface Maker

正如名字所言，Interface Maker用來創建一個新的Interface

@Test
throws Exception{
    Signature signature = new Type[]{Type.INT_TYPE});
    InterfaceMaker interfaceMaker = new InterfaceMaker();
    interfaceMaker.add(signature, 0]);
    Class iface = interfaceMaker.create();
    assertEquals(1, iface.getMethods().length);
    assertEquals(0].getName());
    assertEquals(0].getReturnType());
}

上述的Interface Maker創建的接口中只含有一個方法，簽名為double foo(int)。Interface Maker與上面介紹的其他類不同，它依賴ASM中的Type類型。由於接口僅僅只用做在編譯時期進行類型檢查，因此在一個運行的應用中動態的創建接口沒有什麼作用。但是InterfaceMaker可以用來自動生成代碼，為以後的開發做準備。

Method delegate

MethodDelegate主要用來對方法進行代理

interface BeanDelegate{
    String getValueFromDelegate();
}
@Test
testMethodDelegate()  throws Exception{
    SampleBean bean = new SampleBean();
    bean.setValue();
    BeanDelegate , BeanDelegate.class);
    assertEquals(delegate.getValueFromDelegate());
}

關於Method.create的參數說明：
1. 第二個參數為即將被代理的方法
2. 第一個參數必須是一個無參數構造的bean。因此MethodDelegate.create並不是你想像的那麼有用
3. 第三個參數為只含有一個方法的接口。當這個接口中的方法被調用的時候，將會調用第一個參數所指向bean的第二個參數方法

缺點：
1. 為每一個代理類創建了一個新的類，這樣可能會佔用大量的永久代堆內存
2. 你不能代理需要參數的方法
3. 如果你定義的接口中的方法需要參數，那麼代理將不會工作，並且也不會拋出異常；如果你的接口中方法需要其他的返回類型，那麼將拋出IllegalArgumentException

MulticastDelegate

多重代理和方法代理差不多，都是將代理類方法的調用委託給被代理類。使用前提是需要一個接口，以及一個類實現了該接口
通過這種interface的繼承關係，我們能夠將接口上方法的調用分散給各個實現類上面去。
多重代理的缺點是接口只能含有一個方法，如果被代理的方法擁有返回值，那麼調用代理類的返回值為最後一個添加的被代理類的方法返回值

DelegatationProvider {
    void setValue(String value);
}
DelegatationProvider {
    private String value;
    @Override
    setValue(String value) {
        this.value = value;
    }
    getValue() {
        return value;
    }
}
@Test
throws Exception{
    MulticastDelegate multicastDelegate = MulticastDelegate.create(DelegatationProvider.class);
    SimpleMulticastBean first = new SimpleMulticastBean();
    SimpleMulticastBean second = new SimpleMulticastBean();
    multicastDelegate = multicastDelegate.add(first);
    multicastDelegate  = multicastDelegate.add(second);
    DelegatationProvider provider = (DelegatationProvider) multicastDelegate;
    provider.setValue();
    assertEquals(, first.getValue());
    assertEquals(, second.getValue());
}

Constructor delegate

為了對構造函數進行代理，我們需要一個接口，這個接口只含有一個Object newInstance(…)方法，用來調用相應的構造函數

interface SampleBeanConstructorDelegate{
    Object newInstance(String value);
}
/**
 * 對構造函數進行代理
 * @throws Exception
 */
@Test
throws Exception{
    SampleBeanConstructorDelegate constructorDelegate = (SampleBeanConstructorDelegate) ConstructorDelegate.create(
            SampleBean.class, SampleBeanConstructorDelegate.class);
    SampleBean bean = (SampleBean) constructorDelegate.newInstance();
    assertTrue(SampleBean.class.isAssignableFrom(bean.getClass()));
    System.out.println(bean.getValue());
}

Parallel Sorter(並行排序器)

能夠對多個數組同時進行排序，目前實現的算法有歸並排序和快速排序

@Test
testParallelSorter() throws Exception{
    Integer[][] value = {
            {0},
            {0}
    };
    ParallelSorter.create(0);
    value){
        1;
        int val : row){
            assertTrue(former < val);
            former = val;
        }
    }
}

FastClass

顧明思義，FastClass就是對Class對像進行特定的處理，比如通過數組保存method引用，因此FastClass引出了一個index下標的新概念，比如getIndex(String name, Class[] parameterTypes)就是以前的獲取method的方法。通過數組存儲method,constructor等class信息，從而將原先的反射調用，轉化為class.index的直接調用，從而體現所謂的FastClass。

@Test
throws Exception{
    FastClass fastClass = FastClass.create(SampleBean.class);
    FastMethod fastMethod = fastClass.getMethod(0]);
    SampleBean bean = new SampleBean();
    bean.setValue();
    assertEquals(0]));
}

注意

由於CGLIB的大部分類是直接對Java字節碼進行操作，這樣生成的類會在Java的永久堆中。如果動態代理操作過多，容易造成永久堆滿，觸發OutOfMemory異常。

CGLIB和Java動態代理的區別

Java動態代理只能夠對接口進行代理，不能對普通的類進行代理（因為所有生成的代理類的父類為Proxy，Java類繼承機制不允許多重繼承）；CGLIB能夠代理普通類；
Java動態代理使用Java原生的反射API進行操作，在生成類上比較高效；CGLIB使用ASM框架直接對字節碼進行操作，在類的執行過程中比較高效

原文出處：CGLIB(Code Generation Library)详解 - 小楼一夜听春雨 - CSDN博客

回覆

平面展開

前一個主題 | 下一個主題 | |