3、Spring的AOP詳解和案例

AOP（Aspect Oriented Programming），即面向切面編程。

1、OOP回顧

       在介紹AOP之前先來回顧一下大家都比較熟悉的OOP（Object Oriented Programming）。OOP主要是為了實現編程的重用性、靈活性和擴展性。它的幾個特征分別是繼承、封裝、多態和抽象。OOP重點體現在編程架構，強調的是類之間的層次關系。

2、OOP缺陷

       為了更好的說明OOP的概念，我們接下來講一個OOP的實例，重點分析OOP存在哪些缺陷，以便更好的理解AOP的相關內容。

       先看如下的一張圖：

 

       上面這張圖有三個類：Dog，Cat和Duck，他們都有一個方法run。按照OOP的設計理念，我們很容易就會想到抽象出一個Animal父類，同時讓這三個子類繼承Animal父類。這樣的設計可以用如下的圖示表示：

 

       在OOP思想中，我們會使用大量的類似上圖的編程方式，對類進行抽象、繼承、封裝和多態來實現編程的重用性、靈活性和擴展性。但是這樣的編程仍然有一定的局限性，有時候，OOP並不能很好解決我們再實際開發中遇到的問題。為了說明這個問題，看下面的圖示：

 

       看到上面的圖，我們暫時還不能發現有什么問題。為了大家便於理解，接下來我來給大家講解一下上面類圖的實現過程。描述如下：馬戲團有一條表演的小狗，這條小狗可以跑和跳，但是它完成跑和跳兩個動作之前必須是在接到馴獸師發出的命令后，同時完成跑和跳的動作之后，馴獸師會給與響應的獎勵，比如一塊肉。

       了解了實現過程之后，我們在來看一下具體的代碼。 

    public class Dog {   
        public void run() {
            System.out.println("馴獸師發出命令！")
            System.out.println("小狗開始跑！");
            System.out.pringln("馴獸師給與獎勵");
        }  
        public void jump() {
            System.out.println("馴獸師發出命令！")
            System.out.println("小狗開始跳！");
            System.out.pringln("馴獸師給與獎勵");
        }
    }

    仔細看上面的代碼，我們可以看出在run方法和jump方法中，存在一些相同的內容（馴獸師發出命令和給與獎勵），這些內容並不能完全進行抽象，即不能按照OOP編程思想進行處理。類似這樣的情況同樣會出現在我們編程中的很多地方，例如：日志記錄、性能統計、安全控制、事務處理、異常處理等等。但是這樣的情況該如何解決呢？這就引入了AOP編程思想。

 

3、AOP簡介

       AOP為Aspect Oriented Programming的縮寫，即面向切面編程（也叫面向方面），是一種可以通過預編譯方式和運行期動態代理實現在不修改源代碼的情況下給程序動態統一添加功能的一種技術。

 

4、AOP實現實例

      為了大家更好的理解AOP如何實現，接下來我們優化一下上述代碼。

      首先是Dog類

    public interface Animal {
        public void run();
        public void jump();
    }
    
    public class Dog implements Animal{
        public void run(){
            System.out.println("小狗開始跑！");
        }    
        public void jump(){
            System.out.println("小狗開始跳！");
        }        
    }

     對比之前的代碼我們可以明顯看出，我們將關於馴獸師的相關內容從run和jump中進行了抽取，接下來，我們如何在程序運行中將關於馴獸師的動作加入到程序中呢？這就是我們這次用到的AOP實現的核心技術動態代理（Dynamic Proxy）。具體代碼如下：

    public class MyProxy  implements InvocationHandler{
        private Object targetObject;        
        public Object createProxyInstance(Object targetObject) {
            this.targetObject = targetObject;
            return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), 
                                   targetObject.getClass().getInterfaces(), 
                                   this);
        }
        
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            command();        
            Object ret = method.invoke(targetObject, args);
            award();
            return ret;
        }
        
        private void command() {
            System.out.println("馴獸師發出命令！");
        }
        
        private void award(){
            System.out.println("馴獸師給與獎勵！");
        }
    }

  上述代碼實現完成之后，我們改如何調用呢？參考代碼如下：

    public class Client {
        public static void main(String[] args) {
            MyProxy hander = new MyProxy();
            Animal dog = (Animal)hander.createProxyInstance(new Dog());
            dog.run();
            dog.jump();
        }
    }

  執行結果如下：

 

       關於AOP編程的實例演示就完成了，接下來重新回顧一下AOP與OOP的相關概念。

 

5、AOP與OOP的關系

       OOP針對業務處理過程的實體（Dog、Cat、Duck）及其屬性和行為（run）進行抽象封裝，以獲得更加清晰高效的邏輯單元划分。而AOP則是針對業務處理過程中（run或jump）的切面（command和award）進行提取，它所面對的是處理過程中的某個步驟或階段，以獲得邏輯過程中各部分之間低耦合性的隔離效果。這兩種設計思想在目標上有着本質的差異。

 

一、AOP案例如下：

1、創建如下項目結構

2、在com.entity包下創建User.java

package com.entity;

public class User {
    private Integer id; // 用戶ID
    private String username; // 用戶名
    private String password; // 密碼
    private String email; // 電子郵件

    // getter & setter
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User [email=" + email + ", id=" + id + ", password=" + password
                + ", username=" + username + "]";
    }



}

3、在com.dao包下創建IUserDao.java

package com.dao;

import com.entity.User;

public interface IUserDao {
    public void save(User user);
}

4、在com.dao.impl包下創建UserDaoImpl.java

package com.dao.impl;

import com.dao.IUserDao;
import com.entity.User;
/**
 * 用戶DAO類，實現IDao接口，負責User類的持久化操作
 */
public class UserDaoImpl implements IUserDao{
     /**
      * 保存
      */
    public void save(User user) {
        // 這里並未實現完整的數據庫操作，僅為說明問題
        System.out.println("保存用戶信息到數據庫");
    }
}

5、在com.biz包下創建IUserBiz.java

package com.biz;

import com.entity.User;

public interface IUserBiz {
    public void addNewUser(User user);
}

6、在com.biz.impl包下創建UserBizImpl.java

package com.biz.impl;

import com.biz.IUserBiz;
import com.dao.impl.UserDaoImpl;
import com.entity.User;


/**
 * 用戶業務類，實現對User功能的業務管理
 */
public class UserBizImpl implements IUserBiz {

    // 聲明接口類型的引用，和具體實現類解耦合
    private UserDaoImpl dao;
    

    public void addNewUser(User user) {
        //調用用戶dao的方法保存用戶信息
        dao.save(user);
        
    }

    public UserDaoImpl getDao() {
        return dao;
    }

    public void setDao(UserDaoImpl dao) {
        this.dao = dao;
    }
   
    
    public UserBizImpl() {
    }

    public UserBizImpl(UserDaoImpl dao) {
        this.dao = dao;
    }
    
    

    
}

7、在com.aop包下創建LoggerBefore.java

package com.aop;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.apache.log4j.Logger;
import org.springframework.aop.MethodBeforeAdvice;

/**
 * 通過MethodBeforeAdvice實現前置增強
 */
public class LoggerBefore implements MethodBeforeAdvice {
    private static final Logger log = Logger.getLogger(LoggerBefore.class);

    public void before(Method method, Object[] arguments, Object target)
            throws Throwable {
        // Arrays.toString()數組內容轉換為字符串
        log.info("調用 " + target + "的" + method.getName() + "方法。方法傳入參數："
                + Arrays.toString(arguments));
    }

}

8、在com.aop包下創建LoggerAfterReturning.java

package com.aop;

import java.lang.reflect.Method;
import org.apache.log4j.Logger;
import org.springframework.aop.AfterReturningAdvice;
/**
 * 通過AfterReturningAdvice實現后置增強
 */
public class LoggerAfterReturning implements AfterReturningAdvice {
    private static final Logger log = Logger.getLogger(LoggerAfterReturning.class);

    public void afterReturning(Object returnValue, Method method,
            Object[] arguments, Object target) throws Throwable {
        log.info("調用 " + target + "的" + method.getName() + " 方法方法返回值為"
                + returnValue);
    }

}

9、在src下創建applicationContext.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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">
    <!-- 實例化接口對象 -->
    <bean id="userDao" class="com.dao.impl.UserDaoImpl"></bean>
    
    <!-- 實例化業務對象 -->
    <bean id="biz" class="com.biz.impl.UserBizImpl">
        <!-- 注入方式1：設置注入接口對象 -->
        <!--  
        <property name="dao" ref="userDao"/>
        -->
        <!-- 注入方式2：構造注入對象 -->
        <!-- type表示參數的類型，index表示參數的位置索引 -->
        <constructor-arg index="0" ref="userDao" />
    </bean> 
   
    <!-- 由於默認走jdk代理，有時可能找不到代理，所以此處指定走cglib代理 -->
    <aop:aspectj-autoproxy  proxy-target-class="true"/>


     
     <!-- 實例化日志前置增強對象 -->
    <bean id="loggerBefore" class="com.aop.LoggerBefore"></bean>
    
    <!-- 實例化日志后置增強對象 -->
    <bean id="loggerAfterReturning" class="com.aop.LoggerAfterReturning"></bean>
    
    <!--
      面向切面編程的配置即將某個功能動態的配置到某個流程中，而不改變后台代碼 
      實現業務代碼和日志代碼是完全分離的，經過配置后，不做任何代碼的修改，就在addNewUser方法前后實現了日志輸出
    -->
    <aop:config>
        <!-- 切入點的配置 -->
        <aop:pointcut id="pointcut"
            expression="execution(public void addNewUser(com.entity.User))" />
       <!-- 將增強處理和切入點結合， -->        
        <aop:advisor pointcut-ref="pointcut" advice-ref="loggerBefore" />
        <aop:advisor pointcut-ref="pointcut" advice-ref="loggerAfterReturning" />
    </aop:config>
</beans>

applicationContext.xml

 

10、在src下創建log4j.properties

# rootLogger是所有日志的根日志,修改該日志屬性將對所有日志起作用
# 下面的屬性配置中,所有日志的輸出級別是info,輸出源是console
log4j.rootLogger=info,console
# 定義輸出源的輸入位置是控制台
log4j.appender.console=org.apache.log4j.ConsoleAppender
# 定義輸出日志的布局采用的類
log4j.appender.console.layout=org.apache.log4j.PatternLayout
# 定義日志輸出布局
log4j.appender.console.layout.ConversionPattern=%d %p [%c]%n - %m%n

11、在com.test包下創建Test.java

package com.test;

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

import com.biz.IUserBiz;
import com.entity.User;

public class Test {

    public static void main(String[] args) {
        //讀取和加載xml配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //獲取配置文件的bean的實例
        IUserBiz biz = (IUserBiz) ctx.getBean("biz");
        
        //實例化User對象
        User user = new User();
        user.setId(1);
        user.setUsername("test");
        user.setPassword("123456");
        user.setEmail("[e-mail]");
        
        //添加信息
        biz.addNewUser(user);
    }

}

12、運行結果如下：