淺析spring中的AOP（面向切面編程）

* 它用來生成代理對象
 * 它需要所有的參數
 * * 目標對象
 * * 增強
 * @author cxf
 */
/**
 * 1. 創建代理工廠
 * 2. 給工廠設置三樣東西：
 *   * 目標對象：setTargetObject(xxx);
 *   * 前置增強：setBeforeAdvice(該接口的實現)
 *   * 後置增強：setAfterAdvice(該接口的實現)
 * 3. 調用createProxy()得到代理對象
 *   * 執行代理對象方法時：
 *   > 執行BeforeAdvice的before()
 *   > 目標對象的目標方法
 *   > 執行AfterAdvice的after()
 * @author cxf
 *
 */
public class ProxyFactory {
private Object targetObject;//目標對象
private BeforeAdvice beforeAdvice;//前置增強
private AfterAdvice afterAdvice;//後置增強


/**
* 用來生成代理對象
* @return
*/
public Object createProxy() {
/*
* 1. 給出三大參數
*/
ClassLoader loader = this.getClass().getClassLoader();
Class[] interfaces = targetObject.getClass().getInterfaces();
InvocationHandler h = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
/*
* 在調用代理對象的方法時會執行這裏的內容
*/
// 執行前置增強
if(beforeAdvice != null) {
beforeAdvice.before();
}

Object result = method.invoke(targetObject, args);//執行目標對象的目標方法
// 執行後置增強
if(afterAdvice != null) {
afterAdvice.after();
}

// 返回目標對象的返回值
return result;
}
};
/*
* 2. 得到代理對象
*/
Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h);
return proxyObject;
}


public Object getTargetObject() {
return targetObject;
}
public void setTargetObject(Object targetObject) {
this.targetObject = targetObject;
}
public BeforeAdvice getBeforeAdvice() {
return beforeAdvice;
}
public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
this.beforeAdvice = beforeAdvice;
}
public AfterAdvice getAfterAdvice() {
return afterAdvice;
}
public void setAfterAdvice(AfterAdvice afterAdvice) {
this.afterAdvice = afterAdvice;
}
}

// 服務員接口
public interface Waiter {
// 服務
public void serve();

public void shouQian();
}

// 服務員實現類

public class ManWaiter implements Waiter {
public void serve() {
System.out.println("服務中...");
}

public void shouQian() {
System.out.println("收錢！");
}
}

// 前置增強接口

public interface BeforeAdvice {
public void before();
}

// 後置增強接口

public interface AfterAdvice {
public void after();
}

/*
 * 目標是讓目標對象和增強都可以切換！
 */
public class Demo3 {
@Test
public void fun1() {
ProxyFactory factory = new ProxyFactory();//創建工廠
factory.setTargetObject(new ManWaiter());//設置目標對象
factory.setBeforeAdvice(new BeforeAdvice() {//設置前置增強
public void before() {
System.out.println("您好！");
}
});

factory.setAfterAdvice(new AfterAdvice() {//設置後置增強
public void after() {
System.out.println("再見！");
}
});

Waiter waiter = (Waiter)factory.createProxy();
waiter.shouQian();
waiter.serve();
}

1、AOP 是什麼？

都知道面向對象無非是封裝、繼承、多態，根據某一個類，實例化一個對象，然後操作這一個對象。

AOP  按我自己的理解就是，面向多個對象，或是面向N個對象。

比如我們在service中，可能要對所有的DML操作添加一個transaction，如果說service很少的話，我們可以直接在service中添加一個transaction，那麼如果再開發中，有幾十個甚至幾百個service都需要給他們添加一個transaction，難道我們就寫上幾十遍、上百遍的transaction。當然不是，在spring中，提供了一個AOP，面向切面的編程，說白了就是面向N個對象的編程，就是將這所有的service中的共同部分提取出來，比如將所有的transaction提取出來，寫成一個通知，然後織入（注意別寫錯字），織入action的代理對象之中，這個actionproxy會先執行織入的通知，然後執行其他。

2、首先明白幾個概念（概念可以先略過，還是先後面代碼，再來明白吧），

代理模式:代理模式的英文叫做Proxy或Surrogate，中文都可譯爲”代理“，所謂代理，就是一個人或者一個機構代表另一個人或者另一個機構採取行動。在一些情況下，一個客戶不想或者不能夠直接引用一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用

Aspect(切面):是通知和切入點的結合,通知和切入點共同定義了關於切面的全部內容---它的功能、在何時和何地完成其功能

joinpoint(連接點):所謂連接點是指那些被攔截到的點。在spring中,這些點指的是方法,因爲spring只支持方法類型的連接點.

Pointcut(切入點):所謂切入點是指我們要對哪些joinpoint進行攔截的定義.

   通知定義了切面的”什麼”和”何時”，切入點就定義了”何地”.

Advice(通知):所謂通知是指攔截到joinpoint之後所要做的事情就是通知.通知分爲前置通知,後置通知,異常通知,最終通知,環繞通知(切面要完成的功能)

Target(目標對象):代理的目標對象

Weaving(織入):是指把切面應用到目標對象來創建新的代理對象的過程.切面在指定的連接點織入到目標對象

Introduction(引入):在不修改類代碼的前提下, Introduction可以在運行期爲類動態地添加一些方法或Field.

spring在運行期創建代理,不需要特殊的編譯器.

spring有兩種代理方式：

1.若目標對象實現了若干接口，spring使用JDK的Java.lang.reflect.Proxy類代理。

2.若目標對象沒有實現任何接口，spring使用CGLIB庫生成目標對象的子類。

   使用該方式時需要注意:

          1.對接口創建代理優於對類創建代理，因爲會產生更加鬆耦合的系統。

             對類代理是讓遺留系統或無法實現接口的第三方類庫同樣可以得到通知，

            這種方式應該是備用方案。

          2.標記爲final的方法不能夠被通知。spring是爲目標類產生子類。任何需要

             被通知的方法都被複寫，將通知織入。final方法是不允許重寫的。

   spring只支持方法連接點：不提供屬性接入點，spring的觀點是屬性攔截破壞了

  封裝。面向對象的概念是對象自己處理工作，其他對象只能通過方法調用的得到的

  結果。

3、概念可以先略過。下面寫個簡單的，來描述下（前置通知）。

比如實現一個功能，就是在所有請求到達action之前爲這個請求添加一個日誌(先導入spring的必備的jar包)，下面的5段代碼放在同一個包中即可運行，直接用Java application運行就行

* com.springsource.NET.sf.cglib-2.2.0.jar
cglib代理
* com.springsource.org.aopalliance-1.0.0.jar
* com.springsource.org.aspectj.tools-1.6.6.RELEASE.jar
* org.springframework.aop-3.0.2.RELEASE.jar
spring的面向切面編程,提供AOP(面向切面編程)實現
* org.springframework.aspects-3.0.2.RELEASE.jar
spring提供對AspectJ框架的整合

定義接口

TestInterface1

package com.niit.spring.aop;

/**
 * @author Emine_wang
 */
public interface TestInterface1 {
    public void sayHello();
    public void sayh();

}

實現：

TestInterface1Impl

package com.niit.spring.aop;

/**
 * @author Emine_wang
 */
public class TestInterface1Impl implements TestInterface1 {

    @Override
    public void sayHello() {
        // TODO Auto-generated method stub

        System.out.println("Hello Emine");

    }
    public void sayh(){

        System.out.println("Hello Wang");
    }
}

通知（就是概念中的Advice）：

MyMethodBeforeAdvice.java

別忘了繼承org.springframework.aop.MethodBeforeAdvice;需要導包

package com.niit.spring.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * @author Emine_wang
 *  編寫通知，advice
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice{
    @Override
    public void before(Method method, Object[] args, Object object)
            throws Throwable {
        /**
         * method指表示被調用的方法
         * args給這個method方法傳遞的參數
         * object目標對象
         * 其實是利用反射機制得到方法中的名字、參數等信息
         *
         */
        System.out.println("記錄日誌"+method.getName());
    }

}

配值spring的配置文件beans.xml

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 配置目標對象（被代理對象） -->
    <bean id="TestInterface1Impl" class="com.niit.spring.aop.TestInterface1Impl">
    </bean>

    <!-- 配置前置通知 -->
    <bean id="MyMethodBeforeAdvice" class="com.niit.spring.aop.MyMethodBeforeAdvice"></bean>

    <!-- 配置代理對象 -->

    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">

        <!-- 配置代理的接口集 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.niit.spring.aop.TestInterface1</value>
            </list>
        </property>

        <!-- 把通知織入到代理對象 -->

        <property name="interceptorNames">
        <!-- 相當於把前置通知 MyMethodBeforeAdvice和代理對象關聯起來，我們也可以把通知看成是攔截器
        struts2核心攔截器
        -->
            <value>MyMethodBeforeAdvice</value>
        </property>

        <!-- 配置被代理對象，沒有被代理對象，那麼context.getBean("proxyFactoryBean")爲空 -->

        <property name="target" ref="TestInterface1Impl"></property>


     </bean>






</beans>

測試：

package com.niit.spring.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.niit.spring.bean.User;

public class TestAop {

    /**
     * @param Emine_Wang
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ApplicationContext  context = new ClassPathXmlApplicationContext("com/niit/spring/aop/beans.xml");//加載beans配置文件

//      TestInterface1Impl testInterface1Impl =  (TestInterface1Impl) context.getBean("TestInterface1Impl");//這樣寫相當於沒有用到代理對象，當然不會執行通知了
//      testInterface1Impl.sayHello();
        TestInterface1 testInterface1 = (TestInterface1)context.getBean("proxyFactoryBean");//反射生成代理對象
//      System.out.println(testInterface1.getClass());

        testInterface1.sayHello();
        testInterface1.sayh();
    }

}

結果：

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
記錄日誌sayHello
Hello Emine
記錄日誌sayh
Hello Wang

我們會發現，我並沒有在TestInterface1Impl中的sayHello()和sayh()方法中打印”記錄日誌“，卻發現這裏打印了。說明，通知advice已經被執行，是由代理對象幫我們執行。