---
title: "Spring AOP"
author: "zwh910621"
date: "2009-12-02T11:11:44Z"
tags: []
slug: "spring-aop"
draft: false
lastmod: "2009-12-02T11:12:32Z"
id: 538859
url: "https://javaheart88.iteye.com/blog/538859"
---

### Spring AOP

#### (1)AOP 概述

AOP 的全称为： (Aspect Oriented Programming) ，中文意思为，面向切面 ( 方面 ) 编程。

简单的说： AOP 就是实现横切的工具。

AOP 让我们的设计逻辑更加模块化，我们称之为“关注点”。我们在同一个程序的很多部分重复使用这些关注点。比如，记录日志和控制安全性能是很多程序都会用到的典型的横切。

#### (2)AOP 的种类

事实上有两种完全不同的 AOP ，静态和动态。

 

**在静态 AOP** **中** ，横切逻辑是在编译时加入到程序中去的。如果要修改横切，就必须修改代码重新编译。

**在动态 AOP** **中** ， ( 比如 Spring 中的 AOP) ，横切逻辑是在动行时动态加入程序中的，这样，我们无需重新编译代码就可以修改横切的使用。

这两种 AOP 互相补充，在程序中两者一起使用时功能非常强大。

 

 

#### (3) AOP 中几个比较重要的概念

**&lt;1&gt;** **切面 (Aspect)**

切面，对象操作过程中的截面。这可能是 AOP 中最关键的一个术语。

我们首先来看一个应用开发中常见的切面：用户权限检查。大概只要是完整的应用，都

少不了用户权限检查这个模块，不同身份的用户可以做什么，不可以做什么，均由这个模块

加以判定。而这个模块调用的位置通常也比较固定：用户发起请求之后，执行业务逻辑之前。

针对权限检查这一模块进行分离，我们就得到了一个切面：

 

 

切面意义何在？

首先根据上例，假设我们实现了一个通用的权限检查模块，那么就可以在这层切面上进

行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切

面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需

集中于自己领域内的逻辑实现。

这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔

离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用

性大大增强。

 

**&lt;2&gt;** **联接点（ JoinPoint** **）**

程序运行过程中的某个阶段点。如某个方法调用，或者某个异常被抛出。

 

**&lt;3&gt;** **处理逻辑（ Advice** **，或者叫通知）**

在某个连接点所采用的处理逻辑

常用的有三种：

前置通知、后置通知、包围通知 ( 后面会详细讲解 )

 

**&lt;4&gt;** **切点（ PointCut** **）**

一系列连接点的集合，它指明处理方式（ Advice ）将在何时被触发。

 

#### (4) 理解代理

代理的核心任务就是拦截方法调用，并在需要的时候执行匹配某方法的通知链。通知的管理和调用基本与代理无关，所以这是由 Spring AOP 架构负责的。不过，代理还是需要拦截所有的方法调用，并在必要时将该调用传给 AOP 架构，再由后者调用通知。

 

&lt; 静态代理示例 &gt;

### 9. Spring 中常用三种通知

#### (1) 前置通知

接口： org.springframework.aop.MethodBeforeAdvice

使用前置通知可以在联结点执行前进行自定义的操作。不过， Spring 里只有一种联结点，即方法调用，所以前置通知事实上就是让你能在方法调用前进行一些操作。前置通知可以访问调用的目标方法，也可以对该方法的参数进行操作，不过它不能影响方法调用本身。

 

示例：

 

IHello 接口

public interface IHello {

    public void hello(String name);

}

 

IHello 接口实现

public class HelloSpeaker implements IHello {

    public void hello(String name) {

        System.out.println("Hello, " + name);

    }

}

 

IHello 实现代理

public class LogBeforeAdvice implements MethodBeforeAdvice {

    private Logger logger = Logger.getLogger(this.getClass().getName());

   

    public void before(Method method, Object\[] args, Object target) throws Throwable {

        logger.log(Level.INFO, "method starts..." + method);

   }

}

 

Spring 配置文件

    &lt;bean id="logBeforeAdvice"

          class="onlyfun.caterpillar.LogBeforeAdvice"/&gt;

 

    &lt;bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/&gt;

   

    &lt;bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean"&gt;

        &lt;property name="proxyInterfaces"&gt;

            &lt;value&gt;onlyfun.caterpillar.IHello&lt;/value&gt;

        &lt;/property&gt;

        &lt;property name="target"&gt;

            &lt;ref bean="helloSpeaker"/&gt;

        &lt;/property&gt;

        &lt;property name="interceptorNames"&gt;

            &lt;list&gt;

                &lt;value&gt;logBeforeAdvice&lt;/value&gt;

            &lt;/list&gt;

        &lt;/property&gt;

    &lt;/bean&gt;

 

 

测试类

public class SpringAOPDemo {

    public static void main(String\[] args) {

        ApplicationContext context =

                new FileSystemXmlApplicationContext(

                        "beans-config.xml");

        IHello helloProxy =

            (IHello) context.getBean("helloProxy");

        helloProxy.hello("Justin");

    }

}

 

#### (2) 后置通知 ( 或返回后通知 )

接口： org.springframework.aop.AfterReturningAdvice

后置通知在联结点处的方法调用已经完成，并且已经返回一个值时运行，后置通知可以访问调用的目标方法，以及该方法的参数和返回值。因为等到通知执行时该方法已经调用，后置通知完全不能影响方法调用本身。

 

示例：

 

IHello 接口

public interface IHello {

    public void hello(String name);

}

 

IHello 接口实现

public class HelloSpeaker implements IHello {

    public void hello(String name) {

        System.out.println("Hello, " + name);

    }

}

 

IHello 实现代理

public class LogAfterAdvice implements AfterReturningAdvice {

    private Logger logger = Logger.getLogger(this.getClass().getName());

   

    public void afterReturning(Object object, Method method,

                               Object\[] args,

                                Object target) throws Throwable {

        logger.log(Level.INFO, "method ends..." + method);

   }

}

 

Spring 配置文件

    &lt;bean id="logAfterAdvice"

          class="onlyfun.caterpillar.LogAfterAdvice"/&gt;

 

    &lt;bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/&gt;

   

    &lt;bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean"&gt;

        &lt;property name="proxyInterfaces"&gt;

            &lt;value&gt;onlyfun.caterpillar.IHello&lt;/value&gt;

        &lt;/property&gt;

         &lt;property name="target"&gt;

            &lt;ref bean="helloSpeaker"/&gt;

        &lt;/property&gt;

        &lt;property name="interceptorNames"&gt;

            &lt;list&gt;

                &lt;value&gt;logAfterAdvice&lt;/value&gt;

            &lt;/list&gt;

        &lt;/property&gt;

    &lt;/bean&gt;

 

测试类

public class SpringAOPDemo {

    public static void main(String\[] args) {

        ApplicationContext context = new FileSystemXmlApplicationContext(

                        "beans-config.xml");

        IHello helloProxy = (IHello) context.getBean("helloProxy");

        helloProxy.hello("Justin");

    }

}

 

 

 

#### (3) 包围通知

接口： org.aopalliance.intercept.MethodInterceptor

Spring 中的包围通知模 AOP 联盟的“方法拦截器”标准。包围通知可以在目标方法之前和之后动行，我们也可以定义在什么时候调用目标方法。如果需要，我们也可以另写自己的逻辑而完全不调用目标方法。

 

示例：

 

IHello 接口

public interface IHello {

    public void hello(String name);

}

 

 

 

IHello 接口实现

public class HelloSpeaker implements IHello {

    public void hello(String name) {

        System.out.println("Hello, " + name);

    }

}

 

IHello 实现代理

public class LogInterceptor implements MethodInterceptor {

    private Logger logger = Logger.getLogger(this.getClass().getName());

   

   public Object invoke(MethodInvocation methodInvocation) throws Throwable {

        logger.log(Level.INFO, "method starts..." + methodInvocation.getMethod());

        

        Object result = null;

        try {

          result = methodInvocation.proceed();

        }

        finally {

            logger.log(Level.INFO, "method ends..." +

               methodInvocation.getMethod() + "\\n");

        }

        return result;

   }

 

Spring 配置文件

    &lt;bean id="logInterceptor"

          class="onlyfun.caterpillar.LogInterceptor"/&gt;

   

    &lt;bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/&gt;

   

    &lt;bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean"&gt;

        &lt;property name="proxyInterfaces"&gt;

            &lt;value&gt;onlyfun.caterpillar.IHello&lt;/value&gt;

        &lt;/property&gt;

        &lt;property name="target"&gt;

            &lt;ref bean="helloSpeaker"/&gt;

        &lt;/property&gt;

        &lt;property name="interceptorNames"&gt;

            &lt;list&gt;

                &lt;value&gt;logInterceptor&lt;/value&gt;

            &lt;/list&gt;

        &lt;/property&gt;

    &lt;/bean&gt;

 

测试类

public class SpringAOPDemo {

    public static void main(String\[] args) {

        ApplicationContext context = new FileSystemXmlApplicationContext(

                        "beans-config.xml");

        IHello helloProxy = (IHello) context.getBean("helloProxy");

        helloProxy.hello("Justin");

    }

 

 

### 10. 利用 Spring 中的 AOP 做权限管理

AOP 在 Spring 中占有很重要的地位，做了一个例子是利用 AOP 来做一个登陆的身份验证，使用了 AOP 可以在不破坏你的代码的前提下帮你完成验证功能。

 

选用实现 MethodInterceptor 接口的方法来完成这个功能

 

**代码如下：**

 

接口类的定义：

程序代码 :  
package com.dragon.study;

public interface ILogin {  
    public void login(String name);  
}

 

 

接口实现类的定义：

程序代码 :  
package com.dragon.study.Impl;

import com.dragon.study.ILogin;

public class LoginImpl implements ILogin {  
    /\**  
     * Login  
     \*/  
    public void login(String name) {  
        System.out.println(" 欢迎 " + name + " 登陆！ ");  
    }  
}

 

最重要的拦截器的定义：

程序代码 :

package com.dragon.Advice;

import org.aopalliance.intercept.MethodInterceptor;  
import org.aopalliance.intercept.MethodInvocation;

public class LoginInterceptor implements MethodInterceptor {  
    /\**  
     * Interceptor  
     \*/  
    public Object invoke(MethodInvocation arg0) throws Throwable {  
        String name = (String)arg0.getArguments()\[0];  
        if (name.equals("flash")) {  
            System.out.println(" 这才是真正的用户！ ");  
            return arg0.proceed();  
        } else {  
            System.out.println(" 非法的用户 ~~~ ");  
            return null;  
        }  
    }  
}

 

ApplicationContext.xml 的定义：

&lt;beans&gt;  
&lt;bean id="loginInterceptor" class="com.dragon.advice.LoginInterceptor"&gt;&lt;/bean&gt;  
&lt;bean id="loginTarget" class="com.dragon.study.impl.LoginImpl"&gt;&lt;/bean&gt;  
&lt;bean id="login" class="org.springframework.aop.framework.ProxyFactoryBean"&gt;  
  &lt;property name="proxyInterfaces"&gt;  
    &lt;value&gt;com.dragon.study.ILogin&lt;/value&gt;  
  &lt;/property&gt;  
  &lt;property name="interceptorNames"&gt;  
    &lt;list&gt;  
     &lt;value&gt;loginInterceptor&lt;/value&gt;  
   &lt;/list&gt;  
  &lt;/property&gt;  
  &lt;property name="target"&gt;  
    &lt;ref bean="loginTarget"/&gt;  
  &lt;/property&gt;  
&lt;/bean&gt;  
&lt;/beans&gt;

 

Test 类定义：

package com;

import java.io.\*;

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

import com.dragon.study.ILogin;

public class Test {  
    public static void main(String\[] args) throws IOException {  
        ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");  
        ILogin login = (ILogin)ctx.getBean("login");  
        login.login("flash"); // 用户为 flash 是正确用户，否则是错误的  
    }  
}