Spring框架——AOP面向切面编程

• 简介
• AOP练习
• 使用动态代理解决问题
• Spring AOP
  • 用AspectJ注解声明切面
  • 前置后置通知
  • 利用方法签名编写AspectJ切入点表达式
• 指定切面的优先级
• 基于XML的配置声明切面
• Spring实例练习

---

简介

AOP（面向切面编程）：是一种新的方法论，是对传统OOP（面向对象编程）的补充。

AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。

AOP的好处：

每个事物逻辑位于一个位置，代码不分散，便于维护和升级。

业务模块更简洁，只包含核心业务的代码。

横切关注点：

---

AOP练习

Aop关于加减乘除的练习：

定义一个算法接口，含有4个方法，加减乘除。

public interface ArithmeticCalculator(){
    //加
    double add(double a,double b);
    //减
    double sub(double a,double b);
    //乘
    double mul(double a,double b);
    //除
    double div(double a,double b);
}

Aop思想：

public void before(double a ,double b){
System.out.println(a+"and"+b);
}
public void after(result){
System.out.println("结果是"+result);
}
public double sub(double a, double b){
before(a,b);
double result=a+b;
after(result);
return result;
}

但是，这样做是有一些弊端存在的，比如：

代码混乱：

越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀，每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。

代码分散：

以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码，如果日志需求发生变化，必须修改所有模块。

那么，如何解决这些问题呢？

这就需要使用Spring的动态代理模式来完成了。

---

使用动态代理解决问题

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上。

---

Spring AOP

用AspectJ注解声明切面

切面：带有@Aspect注解的Java类

通知：是标注有以下5种注解的简单的Java方法

@Before：前置通知，在方法执行之前执行

@After：后置通知，在方法执行之后执行

@AfterReturning：返回通知，在方法返回结果之后执行

@AfterThrowing：异常通知，在方法抛出异常之后 @Around：环绕通知，围绕着方法执行

前置后置通知

前置通知：在方法执行之前执行的通知

前置通知使用： @Before , @After注解，并将切入点表达式的值作为注解值。

利用方法签名编写AspectJ切入点表达式

最典型的切入点表达式是根据方法的签名来匹配各种方法：

---

指定切面的优先级

指定切面的优先级：

在同一个连接点上应用不止一个切面时，除非明确指定，否则它们的优先级是不确定的。

切面的优先级可以通过实现Ordered接口或利用@Order注解指定。

实现Ordered接口，getOrder()方法的返回值越小，优先级越高。

若使用@Order注解，序号出现在注解中。

@Aspect
@Order(0)
public class CalculaotorValidationAspect
@Aspect
@Order(1)
public class CalculatorLoggingAspect

---

基于XML的配置声明切面

基于XML声明切面：

当使用XML声明切面时，需要在<beans>根元素中导入aop Schema

在Bean配置文件中，所有的Spring AOP配置都必须定义在<aop:config>元素内部。对于每个切面而言，都要创建一个<aop:aspect>元素来为具体的切面实现引用后端Bean实例。

使用<aop:pointcut>来配置切点，通知元素需要用<aop:before>等元素，method属性指定切面类中通知方法的名称。

---

Spring实例练习

了解了这些Spring的概念知识后，必须要有一个好的例子来理解，下面就以一个简单的小例子来举例子说明。

定义一个实体类User,实现它属性的set,get方法：

public class User {
    private int id;
    private String uname;
    private String pwd;
    private int score;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
}

定义一个接口ScoreService，接口中定义一个登陆方法：

import com.jredu.aop.entity.User;
public interface ScoreService {
    /**
     * 登录
     * @param user
     * @return
     */
    User login(User user);
}

定义一个类ScoreServiceImpl，实现ScoreService 接口中的方法：

import org.springframework.stereotype.Component;
import com.jredu.aop.entity.User;
import com.jredu.aop.service.ScoreService;
@Component("score")
public class ScoreServiceImpl implements ScoreService{
    /**
     * 登录
     */
    @Override
    public User login(User user) {
        // TODO Auto-generated method stub
        System.out.println("登录成功！");
        return user;
    }
}

在applicationContext-aop2.xml中依赖注入user，并配置扫描，配置切面等。

<?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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
          <!-- 自动扫描标签 -->
     <context:component-scan base-package="com.jredu.aop">
     </context:component-scan>
     <bean
        id="user" class="com.jredu.aop.entity.User"
        p:id="1"
        p:uname="张三"
        p:pwd="123456"
        p:score="0"
     />
     <bean
        id="springAspect" class="com.jredu.aop.aspect.SpringAspect"
     />
     <!-- 配置切面 -->
     <aop:config>
        <!-- 配置切点 -->
        <aop:pointcut expression="execution(* com.jredu.aop.service.ScoreService.login(..))" id="pointcut"/>
        <!-- 配置切面 -->
        <aop:aspect ref="springAspect">
            <aop:around method="around" pointcut-ref="pointcut"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="obj"/>
        </aop:aspect>
     </aop:config>
</beans>

定义切面类SpringAspect，在切面中定义相关方法。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import com.jredu.aop.entity.User;
public class SpringAspect {
    /**
     * 执行前
     * @param point
     *//*
    public void before(JoinPoint point){
        String method = point.getSignature().getName();
        System.out.println("before method:"+method);
    }*/
    /**
     * 执行后
     * @param point
     * @throws Throwable
     */
    public User around(ProceedingJoinPoint point) throws Throwable{
        String method = point.getSignature().getName();
        System.out.println("before method:"+method);
        //调用目标方法前
        User user = (User) point.proceed();
        //调用目标方法后
        System.out.println("原来的用户积分:"+user.getScore());
        System.out.println("after method:"+method);
        user.setScore(user.getScore()+100);
        return user;
    }
    /**
     * 最终返回结果
     * @param point
     * @param obj
     */
    public void afterReturning(JoinPoint point,Object obj){
        String method = point.getSignature().getName();
        System.out.println("afterReturning method:"+method);
        User user = (User) obj;
        System.out.println("现在用户的积分："+user.getScore());
    }
}

测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jredu.aop.entity.User;
import com.jredu.aop.service.ScoreService;
public class ScoreTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext-aop2.xml");
        User user = (User) app.getBean("user");
        ScoreService service =(ScoreService) app.getBean("score");
        service.login(user);
    }
}

项目完成后的项目截图：