AOP

AOP

AOP为面向切面编程,它通过预编译和运行期间动态代理的方式实现程序功能的.

他可以对业务逻辑中的各个部分实现隔离,目的是为了降低业务逻辑的耦合度,提高程序的复用性,当然也就提高了开发的效率.

AOP和OOP(面向对象编程)的区别:

OOP是针对业务逻辑及其对象的属性和行为的封装.目的是为了获取较为清晰的逻辑单元划分.

AOP是针对业务逻辑中的切面提取,它所面对的是业务逻辑中的某个步骤或阶段,以获取逻辑过程中各部分之间降低耦合度的隔离效果.

这俩种设计思想在目标上有着本质的差异

注意:注意的是AOP是OOP的一种补充.

AOP的好处:

减少重复性代码,使得程序员更加专注于业务.

核心原理:

使用动态代理的方式在方法执行前后或者出现异常时加入相关的逻辑处理.

使用案例:

事务处理：开启事务，关闭事务，出现异常后回滚事务

权限判断：在执行方法前，判断是否具有权限

日志：在执行前进行日志处理

AOP的基本概念:

连接点:

类中可以被增强的方法,方法就被称为连接点

切入点:

实际上可以被增强的代码

通知:

连接点上要增强的功能.

切面:

把通知添加到切入点的过程

目标:

代理的目标对象(要增强的类)

代理:

向目标对象应用通知后创建的代理对象

Spring AOP实现:

在Spring中使用AOP时,一般使用AspectJ 的实现方式.

AspectJ是一个优秀的面向切面的框架,它扩展了java语言,提供了强大的切面实现.

AspectJ 中常用的通知有五种类型：

前置通知,后置通知,环绕通知,异常通知,最终通知

基于 aspectj 的 xml 配置:

相关的jar:

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

基于 aspectj 的 xml 配置实现

将装有增强功能的类交由 spring 管理.

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--把装有通知的类交给Spring管理-->
    <bean id="aop" class="com.ff.spring.demo1.aop.AOP"></bean>

    <!--配置切入点和通知-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="save" expression="execution(* com.ff.spring.demo1.dao.UserDao.save(..))"/>

        <!--配置通知-->
        <aop:aspect ref="aop">
        		<!--方法执行前-->
            <!--<aop:before method="doLog" pointcut-ref="save"></aop:before>-->
                <!--执行后执行-->
            <!--<aop:after method="doLog" pointcut-ref="save"> </aop:after>-->
                <!--方法执行前,执行后执行-->
            <!--<aop:around method="around" pointcut-ref="save"></aop:around>-->
            <!--异常通知 出现异常后 执行-->
            <aop:after-throwing method="throwable" pointcut-ref="save" throwing="throwable"></aop:after-throwing>
            <!--返回通知 执行return后 执行-->
            <aop:after-returning method="doLog" pointcut-ref="save"></aop:after-returning>
        </aop:aspect>

    </aop:config>
</beans>

相关的类:

package com.ff.spring.demo1.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class AOP {

    /*
    通知:连接点上要增强的功能
        通知时间点:前置通知(方法执行前)  后置通知,环绕通知,异常通知,最终通知(return 后执行)
     */
    public void doLog(){
        System.out.println("保存日志");
    }
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("开启事务");
        proceedingJoinPoint.proceed(); //调用自己的方法
        System.out.println("提交事务");
    }

    public void throwable(Throwable throwable){
        System.out.println("出异常了"+throwable.getMessage());
    }
}

package com.ff.spring.demo1.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.Date;

@Repository(value = "userDao")
//目标
public class UserDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    //连接点:可以被增强的方法
    //切入点:实际被增强的方法
    //
    public void save(){
        System.out.println("保存用户");
    }
}

@Autowired
JdbcTemplate jdbcTemplate;

//连接点:可以被增强的方法
//切入点:实际被增强的方法
//
public void save(){
    System.out.println("保存用户");
}

}