AOP面向切面编程

AOP面向切面编程

aop:面向切面编程，采取的是横向抽取机制，取代了传统的纵向继承体系重复性的代码，简单的来说就是拓展功能的时候可以不通过修改源码实现。

举个例子，在最原始的机制中，当我们要给一个类中的方法添加某个功能的时候，比如为了后期维护系统方便，要给方法添加日志打印的功能，这个时候只能通过修改源代码的方式实现，当系统中有很多类的时候，修改源代码就显得费时费力了。

这个时候可以采用纵向的抽取机制，比如将所有的需要更改功能的类都继承一个父类，在子类中调用父类的方法，这样就少写很多代码。然而，这样的机制仍然不是最方便的，如果父类中的方法发生改变，那么调用父类方法的所有子类都要修改。

1.AOP的原理

aop采用的是横向抽取机制，其底层使用动态代理方式实现。在采用动态代理方式时，针对有接口和没有接口的情况，分别采用不同的方式实现。

1.针对有接口的情况，使用的是jdk的动态代理。实现类在实现接口的中间，创建接口实现类的代理对象，这个代理对象和实现类是平级的，并不是一个真正的对象，只是实现和接口实现类相同的功能。

2.针对没有接口的情况，使用的是cglib的动态代理，创建该类的子类代理对象，在子类中调用父类的方法完成增强。

2.AOP操作术语

class UserService{

    void add(User user){}

    void update(User user){}

    void delete(Integer userId){}

    User getUserById(Integer userId){}
}

Joinpoint(连接点):在一个类中那些可以被增强的方法，这些方法称之为连接点，比如UserService中的四个方法，都可以称之为连接点，

Pointcut(切入点):在一个类中可以有多个连接点，但是只有实际被增强的方法才称之为切入点。如果只对UserService中的add()方法进行增强，那么这个类中只有一个切入点。

Advice(通知/增强):增强的逻辑，比如说要给add()方法增加日志打印的功能，那么这个功能就称之为通知/增强。有前置通知、后置通知、异常通知、最终通知、环绕通知。

Aspect(切面):把增强应用到具体方法上面的过程。比如说给add()方法增加日志打印的这个过程，就是切面。

3.Spring中的aop操作@Aspectj(基于xml)

//被增强的类
public class BookService {

    public void add() {
        System.out.println("BookService.add()");
    }
}
public class BookServiceAdvice {

    //前置通知
    public void before() {
        System.out.println("before advice");
    }

    //后置通知
    public void after() {
        System.out.println("after advice");
    }

    //环绕通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //在方法之前执行的方法
        System.out.println("before method advice");

        proceedingJoinPoint.proceed();

        //在方法之后执行的方法
        System.out.println("after method advice");
    }
}

1.导入jar包
- aopallinace-1.0.jar
- aspectjweaver-1.8.7.jar
- spring-aop-4.2.4.RELEASE.jar
- spring-aspects-4.2.4.RELEASE.jar
或者添加pom依赖:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>

2.在Spring配置文件中导入约束

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

3.几种常见的常用的表达式

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

• execution(* com.aop.BookService.add(..))  *表示匹配所有的方法修饰符,..表示参数

• execution(* com.aop.BookService.*(..))  第一个*表示匹配所有的方法修饰符,第二个*表示匹配该类下的所有方法

• execution(* *.*(..)) 表示对所有的方法进行增强

• execution(* add*(..)) 表示对所有的以add开头的方法进行增强

4.配置对象(基于xml)

<bean id="bookService" class="com.aop.BookService"></bean>
<bean id="bookServiceAdvice" class="com.aop.BookServiceAdvice"></bean>

5.配置aop操作

<aop:config>
    <!--配置切入点-->
    <aop:pointcut expression="execution(* com.aop.BookService.add(..))" id="bookService_add_pointcut"/>
    <!--配置切面-->
    <aop:aspect ref="bookServiceAdvice">
        <!--配置增强类型-->
        <!--前置通知-->
        <aop:before method="before" pointcut-ref="bookService_add_pointcut"/>
        <!--后置通知-->
        <aop:after-returning method="after" pointcut-ref="bookService_add_pointcut"/>
        <!--环绕通知-->
        <aop:around method="around" pointcut-ref="bookService_add_pointcut"/>
    </aop:aspect>
</aop:config>

6.测试

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
BookService bookService = (BookService) context.getBean("bookService");
bookService.add();

运行结果：

before advice
before method advice
BookService.add()
after method advice
after advice

4.Spring中的aop操作@Aspectj(基于注解)

在类上面加注解，导入jar包或者添加依赖，在配置文件中导入约束

@Service("bookService")
public class BookService {...}
@Service("bookServiceAdvice")
public class BookServiceAdvice {...}

1.在配置文件中开启aop操作

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

2.在增强类上面添加注解

@Service("bookServiceAdvice")
@Aspect
public class BookServiceAdvice {

    //前置通知
    @Before(value = "execution(* com.aop.BookService.add(..))")
    public void before() {
        System.out.println("before advice");
    }

    //后置通知
    @After(value = "execution(* com.aop.BookService.add(..))")
    public void after() {
        System.out.println("after advice");
    }

    //环绕通知
    @Around(value = "execution(* com.aop.BookService.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //在方法之前执行的方法
        System.out.println("before method advice");

        proceedingJoinPoint.proceed();

        //在方法之后执行的方法
        System.out.println("after method advice");
    }
}