Spring AOP

 

Spring AOP

(1)AOP 概述

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

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

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

(2)AOP 的种类

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

 

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

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

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

 

 

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

<1> 切面 (Aspect)

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

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

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

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

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

 

 

切面意义何在？

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

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

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

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

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

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

性大大增强。

 

<2> 联接点（ JoinPoint ）

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

 

<3> 处理逻辑（ Advice ，或者叫通知）

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

常用的有三种：

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

 

<4> 切点（ PointCut ）

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

 

(4) 理解代理

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

 

< 静态代理示例 >

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 配置文件

    <bean id="logBeforeAdvice"

          class="onlyfun.caterpillar.LogBeforeAdvice"/>

 

    <bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/>

   

    <bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="proxyInterfaces">

            <value>onlyfun.caterpillar.IHello</value>

        </property>

        <property name="target">

            <ref bean="helloSpeaker"/>

        </property>

        <property name="interceptorNames">

            <list>

                <value>logBeforeAdvice</value>

            </list>

        </property>

    </bean>

 

 

测试类

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 配置文件

    <bean id="logAfterAdvice"

          class="onlyfun.caterpillar.LogAfterAdvice"/>

 

    <bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/>

   

    <bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="proxyInterfaces">

            <value>onlyfun.caterpillar.IHello</value>

        </property>

         <property name="target">

            <ref bean="helloSpeaker"/>

        </property>

        <property name="interceptorNames">

            <list>

                <value>logAfterAdvice</value>

            </list>

        </property>

    </bean>

 

测试类

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 配置文件

    <bean id="logInterceptor"

          class="onlyfun.caterpillar.LogInterceptor"/>

   

    <bean id="helloSpeaker"

          class="onlyfun.caterpillar.HelloSpeaker"/>

   

    <bean id="helloProxy"

          class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="proxyInterfaces">

            <value>onlyfun.caterpillar.IHello</value>

        </property>

        <property name="target">

            <ref bean="helloSpeaker"/>

        </property>

        <property name="interceptorNames">

            <list>

                <value>logInterceptor</value>

            </list>

        </property>

    </bean>

 

测试类

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 的定义：

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

 

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 是正确用户，否则是错误的
    }
}