Java_AOP原理

AOP :

面向切面編程

在程序設計中,我們需要滿足低耦合高內聚,所以編程需滿足六大原則,一個法則.

AOP面向切面編程正是為了滿足這些原則的一種編程思想.

一.裝飾者模式:

當我們需要給對象增加功能時,為了滿足單一職責原則,可利用裝飾者模式編程,創建一個類用來裝飾原來的類,這個類寫需要在原來的功能上增加的功能.

比如:一個類里面有一個增加圖書的功能,

@Service
public class BookSericeImpl implements BookSerice {
    @Override
    public void addOne(BokBean bokBean) {
        System.out.println("執行邏輯:插入一本書");
    }
    @Override
    public void deletOne(Long bookId) {
        System.out.println("執行邏輯:刪除一本書");
    }
}

我們需要在這個基礎上新增打印日志的功能,

public class BooklogServiceImpl implements BookSerice {
    private BookSerice bookSerice;
    public BooklogServiceImpl(BookSerice bookSerice) {
        this.bookSerice = bookSerice;
    }
    @Override
    public void addOne(BokBean bokBean) {

        System.out.println("准備新增一本書");
        this.bookSerice.addOne(bokBean);
        System.out.println("新增一本書完成");
    }
    @Override
    public void deletOne(Long bookId) {

        System.out.println("准備刪除一本書");
        this.bookSerice.deletOne(323L);
        System.out.println("刪除一本書完成");
    }
}

下面我們調用這個增強過后的的對象

   public void test1(){

        //Aop :面向切面編程

        //使用裝飾者模式設計對象
        BookSerice bookSerice = new BookSericeImpl();
        //把原來功能的對象通過構造方傳給新增功能的類,並把新增功能類的對象賦給原來對象
        //這里新增功能類和原來的類都是實現了同一個接口.
        bookSerice = new BooklogServiceImpl(bookSerice);
        //調用新增功能類的方法,在這個方法里讓構造方法傳過去的對象調用原來的功能
        bookSerice.addOne(new BokBean());
    }

這樣我們就在不改變原來代碼的基礎上新增了功能,並且也滿足單一職責的原則,降低了代碼的耦合性.

但是如果接口里面有很多方法,如果每個方法都需要增加日志功能,這樣就會出現很多重復代碼,並且裝飾者模式不能同時為多個沒有關系的類同時增強

所以java引入動態代理技術來增加功能.

 

二.動態代理

在java里動態代理有兩個實現方式:

①針對有接口的類的代理,使用jdk中反射包下的動態代理

②針對沒有接口的類的代理,使用第三方的jar包Enhancer

如果一個類既沒有接口,又是final,那么不能進行增強

 

1.第一種實現: reflect包下的Proxy

基於接口的動態代理,使用java內部反射包增強

這種方式創建對象是目標對象的兄弟對象.

 

同樣上面是實現了接口的兩個功能的類:

@Service
public class BookSericeImpl implements BookSerice {
    @Override
    public void addOne(BokBean bokBean) {
        System.out.println("執行邏輯:插入一本書");
    }
    @Override
    public void deletOne(Long bookId) {
        System.out.println("執行邏輯:刪除一本書");
    }
}

調用通過對象調用上面兩個方法:

public void test2(){

    //創建需要代理的對象
    BookSerice bookSerice = new BookSericeImpl();
    //根據對象的類獲取類加載器
    ClassLoader classLoader = bookSerice.getClass().getClassLoader();
    //獲取被代理對象說實現的所有接口
    Class<?>[] interfaces = bookSerice.getClass().getInterfaces();
    //新建代理對象,里面參數需要(類加載器,一個對象所實現的接口,InvocationHandler接口類的對象)
    bookSerice = (BookSerice) Proxy.newProxyInstance(classLoader, interfaces, new LogHandler(bookSerice)); 
    bookSerice.addOne(new BokBean());
    bookSerice.deletOne(232L);
}

在創建代理對象的時候需要一個InvocationHandler接口類的對象,下面創建一個該類的實現類

public class LogHandler implements InvocationHandler {

    //通過構造方法接受一個沒有被代理的原來的對象
    //通過下面的方法名的反射找到這個對象對應方法
    private Object target;
    public LogHandler(Object target) {
        this.target = target;
    }
    //當代理對象調用原方法的時候,就會調用這個invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String classname = target.getClass().getName();
        String methodName = method.getName();
        System.out.println(classname+"."+methodName+"方法開始執行");
        //這里實際是Method類通過方法名反射調用了原方法(addone)
        Object value = method.invoke(target, args);
        System.out.println(classname+"."+methodName+"方法執行完畢");
        return value;

    }
}

這樣實現了動態代理之后,不管實現的接口里有多少個方法,你只需調用該方法,就會增強該方法,而不需要針對每個方法寫一遍增強功能,

並且這個增強類LogHandler類和原來的實現類BookSericeImpl類並沒有耦合性,這就是說不管你是什么接口類的實現類,只需要對該類的對象進行代理即可,就能對該類的方法添加上這個新增的功能

總的來說,這種動態代理實現方式就是利用反射技術,找到調用的方法名,針對這個方法進行增強.

如果當不需要對某方法增加功能時,就不用不帶.

 

2.第二種實現:cglib包下的Enhancer類

基於類的動態代理,使用cglib框架.
這種方式創建的代理對象是目標對象的子類對象

 第二種方式是利用第三方jar包來實現,下載CGLIB包:

利用jar包中的Enhancer類創建增強對象.

創建增強對象需要根據原對象的類名創建類增強器,還需要根據原對象的類型創建子類代理對象

屬性通過增強對象set方法賦值,上一種方式是通過調用方法Proxy.newProxyInstance傳參.

  public void test3(){

        //創建需要代理增強的對象
        BookSerice bookSerice = new BookSericeImpl();
        Enhancer enhancer = new Enhancer();
        //用增強器對象創建類增強器
        enhancer.setClassLoader(bookSerice.getClass().getClassLoader());

        //因為創建的代理對象是目標對象的子類,所以這里填的就是目標對象的類
        enhancer.setSuperclass(bookSerice.getClass());

        //創建代理對象,這里需要的參數是Callback接口的對象,所以需要創建一個接口的實現類.
        enhancer.setCallback(new TimeMethodInterceptor(bookSerice));
        //把代理對象賦給原對象
        bookSerice = (BookSerice) enhancer.create();
        bookSerice.addOne(new BokBean());
        bookSerice.deletOne(1l);
        
    }

創建Callback接口的實現類,也就是功能增強部分,

這一部分跟第一種方式的實現是一樣的,都是通過反射在添加功能過程中調用原方法.

//Callback接口沒有實現方法,所以這里實現的是他的子接口
public class TimeMethodInterceptor implements MethodInterceptor {

    private  Object target;

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

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //記錄當前系統時間
        //這個時間是從1970年1月1日 0點0分到現在的毫秒數
        long start = System.currentTimeMillis();
        Object value = method.invoke(target, objects);
        long time = System.currentTimeMillis() - start;
        System.out.println("當前時長"+time+"毫秒");
        return null;
    }
}

 

總結:

兩種方法的區別:

第一種是用jdk內部方法創建代理對象,由於創建過程中需要一個對象的接口,所以只能針對有接口類的對象進行代理.

第二種是利用第三方jar包中的增強器(Enhancer)創建代理對象,通過set方法給需要的屬性賦值.由於沒有接口實現,所以創建的是對象的子類代理對象.