AOP

最新推荐文章于 2023-06-26 22:17:02 发布

扶苏工子

最新推荐文章于 2023-06-26 22:17:02 发布

阅读量183

点赞数

分类专栏： Spring 文章标签： aop

本文链接：https://blog.csdn.net/weixin_44378338/article/details/114790313

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

任务二：AOP

一转账案例

需求

使用spring框架整合DBUtils技术，实现用户转账功能

1.1 基础功能

步骤分析

创建java项目，导入坐标
编写Account实体类
编写AccountDao接口和实现类
编写AccountService接口和实现类
编写spring核心配置文件
编写测试代码

转账案例

1 ）创建java项目，导入坐标

<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.15</version>
</dependency>
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.6</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

2 ）编写Account实体类

public class Account {

    private Integer id;
    private String name;
    private Double money;

3 ）编写AccountDao接口和实现类

public interface AccountDao {

    // 转出操作
    public void out(String outUser, Double money);
    // 转入操作
    public void in(String inUser, Double money);

}

@Repository("accountDao") //生成该类实例存到ioc容器
public class AccountDaoImpl implements AccountDao {

    @Autowired //注入queryRunner对象到ioc容器
    private QueryRunner queryRunner;

    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        try {
            queryRunner.update(sql,money,outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void in(String inUser, Double money) {

        String sql = "update account set money = money + ? where name = ?";
        try {
            queryRunner.update(sql,money,inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

4 ）编写AccountService接口和实现类

public interface AccountService {

    //转账方法
    public void transfer(String outUser,String inUser,Double money);

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    //需要用到dao层的对象，所以就需要注入dao对象
    @Autowired
    private AccountDao accountDao;

    /*转账方法*/
    public void transfer(String outUser, String inUser, Double money) {
        accountDao.in(inUser,money);
        accountDao.out(outUser,money);
    }
}

5 ）编写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"
       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">

    <!--加载注解扫描-->
    <!--开启组件扫描-->
    <context:component-scan base-package="com.lagou"/>
    <!--加载jdbc配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置dataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--把QueryRunner交给IOC容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
</beans>

6 ）编写测试代码

package com.lagou.test;

import com.lagou.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/*需要加载配置文件*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer(){

        accountService.transfer("tom","jerry",100.0);
    }
}

7 ）问题分析

上面的代码事务在dao层，转出转入操作都是一个独立的事务，但实际开发，应该把业务逻辑控制在一个事务中，所以应该将事务挪到service层。

3.2 传统事务

步骤分析

编写线程绑定工具类
编写事务管理器
修改service层代码
修改dao层代码

1 ）编写线程绑定工具类

/**
 * 线程绑定工具类,从dataSource中获取一个connection,并把connection与线程进行绑定
 * */

@Component //创建ConnectionUtils的实例存入Ioc容器
public class ConnectionUtils {

    @Autowired
    private DataSource dataSource;

    /*ThreadLocal： 线程内部的存储类，可以在指定的线程内部存储数据 以key-value形式存储
    * key---> ThreadLocal(就是当前线程)
    * value---> 任意类型的值*/
    private ThreadLocal<Connection> threadLocal;

    /*获取当前线程的连接，如果获取到的为空，那么就要从数据源中获取，放到ThreadLocal中，即当前线程*/
    public Connection getThreadConnection(){

        // 1.先从线程上ThreadLocal获取
        Connection connection = threadLocal.get();

        // 2. 判断con连接是否为空，为空就从数据源获取
        if (connection == null){
            //从数据源获取
            try {
                connection = dataSource.getConnection();

                // 把con连接放入ThreadLocal中
                threadLocal.set(connection);

            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return connection;
    }

    /*解除当前线程的连接绑定*/
    public void removeThreadConnection(){
        threadLocal.remove();
    }
}

2 ）编写事务管理器

/**
* 事务管理器工具类： 开启事务，提交事务，回滚事务，释放资源
* */
@Component  //存入Ioc容器方便使用其实例调用相应方法
public class TransactionManager  {

    //调用ConnectionUtils的方法，所以需要用到ConnectionUtils的实例
    @Autowired
    private ConnectionUtils connectionUtils;

    /*开启事务*/
    public void beginTransaction(){
        Connection threadConnection = connectionUtils.getThreadConnection();
        try {
            threadConnection.setAutoCommit(false);//改成手动提交事务
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /*提交事务*/
    public void commitTransaction(){
        Connection threadConnection = connectionUtils.getThreadConnection();
        try {
            threadConnection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    /*回滚事务*/
    public void rollbackTransaction(){
        Connection threadConnection = connectionUtils.getThreadConnection();
        try {
            threadConnection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    /*释放资源*/
    public void closeTransaction(){
        Connection threadConnection = connectionUtils.getThreadConnection();
        try {
            //改成自动提交
            threadConnection.setAutoCommit(true);
            
            //关闭连接
            threadConnection.close();
            
            //解除线程绑定
            connectionUtils.removeThreadConnection();
            
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3 ）修改service层代码

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    //需要用到dao层的对象，所以就需要注入dao对象
    @Autowired
    private AccountDao accountDao;

    // 需要用到TransactionManager对象
    @Autowired
    private TransactionManager transactionManager;

    /*转账方法*/
    public void transfer(String outUser, String inUser, Double money) {

        try {
            // 1.开启事务
            transactionManager.beginTransaction();

            // 2.操作事务
            accountDao.in(inUser,money);
            accountDao.out(outUser,money);

            // 3.提交事务
            transactionManager.commitTransaction();

        } catch (Exception e) {
            e.printStackTrace();
            // 4.回滚事务
            transactionManager.rollbackTransaction();
        } finally {
            // 5.释放资源
            transactionManager.closeTransaction();
        }

    }
}

4 ）修改dao层代码

@Repository("accountDao") //生成该类实例存到ioc容器
public class AccountDaoImpl implements AccountDao {

    @Autowired //注入queryRunner对象到ioc容器
    private QueryRunner queryRunner;

    @Autowired
    private ConnectionUtils connectionUtils;

    public void out(String outUser, Double money) {
        String sql = "update account set money = money - ? where name = ?";
        try {
            queryRunner.update(connectionUtils.getThreadConnection(),sql,money,outUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void in(String inUser, Double money) {

        String sql = "update account set money = money + ? where name = ?";
        try {
            queryRunner.update(connectionUtils.getThreadConnection(),sql,money,inUser);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

5 ）问题分析

上面代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了

一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了，违背了面向对象的开发思想。

二、Proxy优化转账案例

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强

CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强

在这里插入图片描述

2.1 JDK动态代理方式

Jdk工厂类

采用jdk动态代理技术生成目标类的代理对象
* newProxyInstance()方法的参数：
       **ClassLoader loader**  类加载器，借助被代理对象获取类加载器
*      **Class<?> interface**  被代理类所需要实现的全部接口
*      **InvocationHandler h**  当代理对象调用接口的任意方法时，都会执行InvocationHandler的invoke()方法

***实现事务与业务代码的解耦，把事务代码放到代理对象的invoke()方法中，接口方法中只保留业务代码***

@Component
public class JdkProxyFactory {

    @Autowired
    private AccountService accountService;//被代理对象

    @Autowired
    private TransactionManager transactionManager;//管理事务对象

    /*采用jdk动态代理技术生成目标类的代理对象
    * newProxyInstance()方法的参数：ClassLoader loader  类加载器，借助被代理对象获取类加载器
    *      Class<?> interface  被代理类所需要实现的全部接口
    *      InvocationHandler h  当代理对象调用接口的任意方法时，都会执行InvocationHandler的invoke()方法        */
    public AccountService createAccountServiceJdkProxy(){

        AccountService accountServiceProxy =(AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            //第三个参数，需要InvocationHandler的实现类，这里使用了匿名内部类，并重写了invoke方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*参数：proxy : 当前的代理对象引用
                 *      method：被调用的目标方法的引用
                 *      args： 被调用目标方法的参数*/

                //会执行被代理类也就是accountService里面的方法

                /*实现类事务与业务的分离，解耦*/
                Object result = null;
                try {
                    //**在执行接口的方法之前**，开启事务
                  transactionManager.beginTransaction();

                    //**执行事务操作**
                     result = method.invoke(accountService, args);

                    //**在执行接口的方法之后，**提交事务
                    transactionManager.commitTransaction();

                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollbackTransaction();
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();
                }

                return result;
            }
        });

        return accountServiceProxy;
    }

}

接口代码

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    //需要用到dao层的对象，所以就需要注入dao对象
    @Autowired
    private AccountDao accountDao;

   /* // 需要用到TransactionManager对象
    @Autowired
    private TransactionManager transactionManager;*/

    /*转账方法*/
    public void transfer(String outUser, String inUser, Double money) {

          /*  // 1.开启事务
            transactionManager.beginTransaction();*/

            // 2.操作事务
            accountDao.in(inUser,money);
            //int i = 10/0;
            accountDao.out(outUser,money);

            /*// 3.提交事务
            transactionManager.commitTransaction();

            // 4.回滚事务
            transactionManager.rollbackTransaction();

            // 5.释放资源
            transactionManager.closeTransaction();*/

    }
}

测试代码

@Test
    public void testTransferProxy(){

        //当前返回的时AccountService的代理对象Proxy
        AccountService accountServiceJdkProxy = jdkProxyFactory.createAccountServiceJdkProxy();
        //当代理对象调用被代理对象实现的接口的任意方法时，都会执行invoke()方法
        accountServiceJdkProxy.transfer("tom","jerry",200.0);
    }

2.2 CGLIB动态代理方式

Cglib工厂类

/**
 *  该类使用cglib动态代理的方式，对目标类AccountServiceImpl进行方法的transfer的动态增强
 */
@Component
public class CglibProxyFactory {

    @Autowired
    private AccountService accountService;
    @Autowired
    private TransactionManager transactionManager;
    public AccountService createAccountServiceCglibProxy(){

        //create()方法的参数
        //参数1：目标类的字节码对象
        //参数2：动作类，当代理对象调用目标对象的原方法时，都会调用代理对象的intercept()方法
        AccountService accountServiceProxy =(AccountService) Enhancer.create(accountService.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //o 代表生成的代理对象，method 代表目标方法的引用， objects 方法入参 methodProxy 方法代理

                try {
                    //开启事务
                    transactionManager.beginTransaction();

                    //执行事务操作
                    method.invoke(accountService,objects);
                    //提交事务
                    transactionManager.commitTransaction();
                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚
                    transactionManager.rollbackTransaction();
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();
                }

                return null;
            }
        });

        return accountServiceProxy;
    }
}

测试代码

@Test
    public void testTransferProxyCglib(){

        //当前返回的时AccountService的代理对象Proxy
        AccountService accountServiceCglibProxy = cglibProxyFactory.createAccountServiceCglibProxy();
        //当代理对象调用被代理对象实现的接口的任意方法时，都会执行intercept方法
        accountServiceCglibProxy.transfer("tom","jerry",100.0);
    }

三初识AOP

3.1 什么是AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为 面向切面编程

AOP 是 OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

这样做的好处是 ：

1. 在程序运行期间，在不修改源码的情况下对方法进行功能增强

2. 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码

3. 减少重复代码，提高开发效率，便于后期维护

3.2 AOP底层实现

实际上，AOP 的底层是通过 Spring 提供的的 动态代理技术 实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

3.3 AOP相关术语

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

* **Target（目标对象）：代理的目标对象**-----AccountService(AccountServiceImpl)
public interface AccountService {

    //转账方法
    public void transfer(String outUser,String inUser,Double money);

    public void save();

    public void update();

    public void delete();
}

* **Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类**---**accountServiceProxy** 

public AccountService createAccountServiceJdkProxy(){

        AccountService **accountServiceProxy** =(AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            //第三个参数，需要InvocationHandler的实现类，这里使用了匿名内部类，并重写了invoke方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*参数：proxy : 当前的代理对象引用
                 *      method：被调用的目标方法的引用
                 *      args： 被调用目标方法的参数*/

                //会执行被代理类也就是accountService里面的方法

                /*实现类事务与业务的分离，解耦*/
                Object result = null;
                try {

                    if (method.getName().equals("transfer")){
                        System.out.println("前置增强");
                    //开启事务
                  transactionManager.beginTransaction();

                    //执行事务操作
                     result = method.invoke(accountService, args);

                        System.out.println("后置增强");
                    //提交事务
                    transactionManager.commitTransaction();
                }else {
                        method.invoke(accountService,args);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollbackTransaction();
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();
                }
                return result;
            }
        });

        return accountServiceProxy;
    }

* **Joinpoint（连接点）：所谓连接点是指那些可以被拦截增强的方法。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点，也就是以下四个方法**

//转账方法
    public void transfer(String outUser,String inUser,Double money);

    public void save();

    public void update();

    public void delete();

* **Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义，就是真正被增强的方法，也就是transfer**

public void transfer(String outUser,String inUser,Double money);

if (method.getName().equals("transfer"))

* **Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
也就是实现增强的业务逻辑
分类：前置通知、后置通知、异常通知、最终通知、环绕通知

try {
                 if (method.getName().equals("transfer")){
                        
                        System.out.println("前置增强");
                    //开启事务
                  transactionManager.beginTransaction();//前置通知

                    //执行事务操作
                     result = method.invoke(accountService, args);

                        System.out.println("后置增强");
                    //提交事务
                    transactionManager.commitTransaction();//后置通知
                }else {
                        method.invoke(accountService,args);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollbackTransaction();//异常通知
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();//最终通知
                }**

**环绕通知：spring提供的一种可以通过代码的方式来手动控制的类型，也就是上面的各类通知形成的整段代码**

* **Aspect（切面）：是切入点和通知（引介）的结合的过程

if (method.getName().equals("transfer")){

                        System.out.println("前置增强");
                    //开启事务
                  transactionManager.beginTransaction();

                    //执行事务操作
                     result = method.invoke(accountService, args);

                        System.out.println("后置增强");
                    //提交事务
                    transactionManager.commitTransaction();
                }else {
                        method.invoke(accountService,args);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollbackTransaction();
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();
                }**

* **Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织
入，而AspectJ采用编译期织入和类装载期织入

AccountService accountServiceProxy =(AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            //第三个参数，需要InvocationHandler的实现类，这里使用了匿名内部类，并重写了invoke方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*参数：proxy : 当前的代理对象引用
                 *      method：被调用的目标方法的引用
                 *      args： 被调用目标方法的参数*/

                //会执行被代理类也就是accountService里面的方法

                /*实现类事务与业务的分离，解耦*/
                Object result = null;
                try {

                    if (method.getName().equals("transfer")){

                        System.out.println("前置增强");
                    //开启事务
                  transactionManager.beginTransaction();

                    //执行事务操作
                     result = method.invoke(accountService, args);

                        System.out.println("后置增强");
                    //提交事务
                    transactionManager.commitTransaction();
                }else {
                        method.invoke(accountService,args);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    //回滚事务
                    transactionManager.rollbackTransaction();
                } finally {
                    //释放资源
                    transactionManager.closeTransaction();
                }

                return result;
            }
        });

        return accountServiceProxy;
    }**

3.4 AOP开发明确事项

3.4.1 开发阶段（我们做的）

1. 编写核心业务代码（目标类的目标方法）切入点

2. 把公用代码抽取出来，制作成通知（增强功能方法）通知

3. 在配置文件中，声明切入点与通知间的关系，即切面

3.4.2 运行阶段（Spring框架完成的）

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3.4.3 底层代理实现

在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

当bean实现接口时，会用JDK代理模式
当bean没有实现接口，用cglib实现（ 可以强制使用cglib（在spring配置中加入<aop:aspectj-
autoproxy proxyt-target-class=”true”/>）

3.5 知识小结

**aop：面向切面编程
* aop底层实现：基于JDK的动态代理 和 基于Cglib的动态代理
* aop的重点概念：
Pointcut（切入点）：真正被增强的方法
Advice（通知/ 增强）：封装增强业务逻辑的方法
Aspect（切面）：切点+通知
Weaving（织入）：将切点与通知结合，产生代理对象的过程**

四基于XML的AOP开发

4.1 快速入门

步骤分析

创建java项目，导入AOP相关坐标
创建目标接口和目标实现类（定义切入点）
创建通知类及方法（定义通知）
将目标类和通知类对象创建权交给spring
在核心配置文件中配置织入关系，及切面
编写测试代码

4.1.1 创建java项目，导入AOP相关坐标

<dependencies>
<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!-- aspectj的织入（切点表达式需要用到该jar包） -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<!--spring整合junit-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

4.1.2 创建目标接口和目标实现类

public interface AccountService {

    //目标方法，即切入点需要拦截增强的方法
    public void transfer();
}

public class AccountServiceImpl implements AccountService {

    public void transfer() {
        System.out.println("转账方法执行了");
    }
}

4.1.3 创建通知类

/**
*  通知类
* */
public class MyAdvice {

    public void before(){
        System.out.println("前置通知执行了");
    }
}

4.1.4 将目标类和通知类对象创建权交给spring

<!--把目标类交给ioc容器-->
    <bean id="accountService" class="com.lagou.service.impl.AccountServiceImpl"></bean>

    <!--通知类交给Ioc容器-->
    <bean id="myAdvice" class="com.lagou.advice.MyAdvice"></bean>

4.1.5 在核心配置文件中配置织入关系，及切面

导入aop命名空间

<!--Aop配置-->
    <aop:config>
        <!--配置切面，切入点+通知-->
        <aop:aspect ref="myAdvice">
            <aop:before method="before" pointcut="execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())"></aop:before>
        </aop:aspect>
    </aop:config>

**配置了目标类的transfer执行时先使用myAdivce的before方法进行增强**

4.1.6 编写测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;
    @Test
    public void testTransfer() throws Exception {
        accountService.transfer();
    }

}

4.2 XML配置AOP详解

4.2.1 切点表达式

表达式语法：

**execution([修饰符] 返回值类型 包名.类名.方法名(参数))**

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号 * 代替，代表任意
包名与类名之间一个点. 代表当前包下的类，两个点 … 表示当前包及其子包下的类
参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())
execution(void com.lagou.service.impl.AccountServiceImpl.*(..))
execution(* com.lagou.service.impl.*.*(..))
execution(* com.lagou.service..*.*(..))

切点表达式抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。

<aop:config>
        <!--抽取切入点-->
        <aop:pointcut id="myPointCut" expression="execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())"/>

        <!--配置切面，切入点+通知-->
        <aop:aspect ref="myAdvice">
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="myPointCut"/>
</aop:aspect>
    </aop:config>

4.2.2 通知类型

通知的配置语法：

**<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>**

MyAdvice通知类

public void before(){
        System.out.println("前置通知执行了");
    }

    public void afterReturning(){
        System.out.println("后置通知执行了");
    }

    public void afterThrowing(){
        System.out.println("异常通知执行了");
    }

    public void after(){
        System.out.println("最终通知执行了");
    }

目标类

public void transfer() {
        //int a = 10/0;
        System.out.println("转账方法执行了");
    }

前置通知：用于配置前置通知。指定增强的方法在切入点方法之前执行


<!--前置通知-->
            <aop:before method="before" pointcut-ref="myPointCut"/>

后置通知：用于配置后置通知。指定增强的方法在切入点方法之后执行

<!--后置通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="myPointCut"/>

异常通知：用于配置异常通知。指定增强的方法出现异常后执行

<!--异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="myPointCut"/>

最终通知：用于配置最终通知。无论切入点方法执行时是否有异常，都会执行环绕通知

<!--最终通知-->
            <aop:after method="after" pointcut-ref="myPointCut"/>

环绕通知：用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

MyAdvice目标类

/*proceedingJoinPoint：  切点对象*/
    public Object around(ProceedingJoinPoint proceedingJoinPoint){
        Object proceed = null;
        try {
            System.out.println("前置通知执行了");
            proceed = proceedingJoinPoint.proceed();//执行切点方法即transfer()方法
            System.out.println("后置通知执行了");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知执行了");
        } finally {
        System.out.println("最终通知执行了");
        }

        return proceed;
    }

<!--环绕通知-->
            <aop:around method="around" pointcut-ref="myPointCut"/>

注意：通常情况下，环绕通知都是独立使用的

4.3 知识小结

*** aop织入的配置
<aop:config>
<aop:aspect ref=“通知类”>
<aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
</aop:aspect>
</aop:config>

* 通知的类型
前置通知、后置通知、异常通知、最终通知、环绕通知

* 切点表达式
execution([修饰符] 返回值类型 包名.类名.方法名(参数))**

五基于注解的AOP开发

5.1 快速入门

步骤分析

创建java项目，导入AOP相关坐标
创建目标接口和目标实现类（定义切入点）
创建通知类（定义通知）
将目标类和通知类对象创建权交给spring
在通知类中使用注解配置织入关系，升级为切面类
在配置文件中开启组件扫描和 AOP 的自动代理
编写测试代码

5.1.1 创建java项目，导入AOP相关坐标

<dependencies>
<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<!--spring整合junit-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

5.1.2 创建目标接口和目标实现类

public interface AccountService {

    public void transfer();
}

@Service
public class AccountServiceImpl implements AccountService {

    public void transfer(){
        System.out.println("转账操作执行了");
    }
}

5.1.3 创建通知类

@Component //存入ioc容器
@Aspect  //升级为切面类  切入点+通知
public class MyAdvice {

    @Before("execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())")
    public void before(){
        System.out.println("前置通知...");
    }
}

5.1.4 将目标类和通知类对象创建权交给spring

@Service
public class AccountServiceImpl implements AccountService {}
@Component
public class MyAdvice {}

5.1.5 在通知类中使用注解配置织入关系，升级为切面类

@Component //存入ioc容器
@Aspect  //升级为切面类  切入点+通知
public class MyAdvice {

    @Before("execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())")
    public void before(){
        System.out.println("前置通知...");
    }
}

5.1.6 在配置文件中开启组件扫描和 AOP 的自动代理

<!--开启Ioc注解扫描-->
    <context:component-scan base-package="com.lagou"/>

    <!--Aop的自动代理 ,spring会采用动态代理完成织入增强，  proxy-target-class="true" 指强制使用cglib动态代理-->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

5.1.7 编写测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml"})
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer(){

        accountService.transfer();
    }
}

5.2 注解配置AOP详解

5.2.1 切点表达式

切点表达式的抽取

@Component //存入ioc容器
@Aspect  //升级为切面类  切入点+通知
public class MyAdvice {

    /*抽取切点表达式,先定义一个方法再添加注解，填入切点表达式*/
    @Pointcut("execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())")
    public void myPointCut(){

    }

    @Before("MyAdvice.myPointCut()")
    public void before(){
        System.out.println("前置通知...");
    }

    @AfterReturning("myPointCut()")
    public void afterReturning(){
        System.out.println("后置通知...");
    }
}

5.2.2 通知类型

通知的配置语法：@通知注解(“切点表达式")

在这里插入图片描述

/*抽取切点表达式*/
    @Pointcut("execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())")
    public void myPointCut() {

    }

    /*前置通知*/
    @Before("MyAdvice.myPointCut()")
    public void before() {
        System.out.println("前置通知...");
    }

    /*后置通知*/
    @AfterReturning("myPointCut()")
    public void afterReturning() {
        System.out.println("后置通知...");
    }

    /*异常通知*/
    @AfterThrowing("myPointCut()")
    public void afterThrowing() {
        System.out.println("异常通知...");
    }

   /*最终通知*/
    @After("myPointCut()")
    public void after() {
        System.out.println("最终通知...");
    }

执行顺序：

在这里插入图片描述

环绕通知

/*环绕通知*/
    @Around("myPointCut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) {

        Object proceed = null;

        try {
            System.out.println("前置通知");

            proceed = proceedingJoinPoint.proceed();

            System.out.println("后置通知");

        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知");
        } finally {

            System.out.println("最终通知");
        }

        return proceed;
    }

执行顺序

在这里插入图片描述

注意：

当前四个通知组合在一起时，执行顺序如下：

在这里插入图片描述

**@Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）
与xml配置的方式不同，使用注解后置通知会再最终通知后面执行，这是采用注解的bug，但使用环绕通知会与xml的顺序保持一致**

5.2.3 纯注解配置

使用注解@EnableAspectJAutoProxy 替代配置文件的 <aop:aspectj-autoproxy>
@Configuration
@ComponentScan("com.lagou")
@EnableAspectJAutoProxy  //替代<aop:aspectj-autoproxy>
public class SpringConfig {

}

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration({"classpath:applicationContext.xml"})//使用纯注解就不用加载核心配置文件，而是加载核心配置类
@ContextConfiguration(classes = SpringConfig.class)//加载核心配置类
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer(){

        accountService.transfer();
    }
}

5.3 知识小结

*** 使用@Aspect注解，标注切面类
* 使用@Before等注解，标注通知方法
* 使用@Pointcut注解，抽取切点表达式
* 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy**

六 AOP优化转账案例

依然使用前面的转账案例，将两个代理工厂对象直接删除！改为spring的aop思想来实现

6.1 xml配置实现

1 ）配置文件

<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--开启组件扫描-->
<context:component-scan base-package="com.lagou"/>
<!--加载jdbc配置文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--把数据库连接池交给IOC容器-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>

<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>

<aop:config>
<!--切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(*
com.lagou.service..*.*(..))"/>
<!-- 切面配置 -->
<aop:aspect ref="transactionManager">
<aop:before method="beginTransaction" pointcut-ref="myPointcut"/>
<aop:after-returning method="commit" pointcut-ref="myPointcut"/>
<aop:after-throwing method="rollback" pointcut-ref="myPointcut"/>
<aop:after method="release" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>
</beans>

2 ）事务管理器（通知）

**// 事务管理器工具类，包括：开启事务、提交事务、回滚事务、释放资源**

@Component
public class TransactionManager {
@Autowired
ConnectionUtils connectionUtils;

public void begin(){
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}

public void commit(){
try {
connectionUtils.getThreadConnection().commit();
} catch (SQLException e) {
e.printStackTrace();
}
}

public void rollback(){
try {
connectionUtils.getThreadConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}

public void release(){
try {
connectionUtils.getThreadConnection().setAutoCommit(true);
connectionUtils.getThreadConnection().close();
connectionUtils.removeThreadConnection();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

6.2 注解配置实现

1 ）配置文件

<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<!--开启组件扫描-->
<context:component-scan base-package="com.lagou"/>
<!--开启AOP注解支持-->
<aop:aspectj-autoproxy/>
<!--加载jdbc配置文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--把数据库连接池交给IOC容器-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--把QueryRunner交给IOC容器-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
</beans>

2 ）事务管理器（通知）

@Component  //存入Ioc容器方便使用其实例调用相应方法
@Aspect //切面类
public class TransactionManager {

    //调用ConnectionUtils的方法，所以需要用到ConnectionUtils的实例
    @Autowired
    private ConnectionUtils connectionUtils;

    //环绕通知
    @Around("execution(* com.lagou.service.impl.AccountServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint point) throws SQLException {

        Object proceed = null;
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);

            proceed = point.proceed();

            connectionUtils.getThreadConnection().commit();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            connectionUtils.getThreadConnection().rollback();
        } finally {

            //改成自动提交
            connectionUtils.getThreadConnection().setAutoCommit(true);

            //关闭连接
            connectionUtils.getThreadConnection().close();

            //解除线程绑定
            connectionUtils.removeThreadConnection();
        }

        return proceed;
    }

扶苏工子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AOP

任务二：AOP一转账案例需求使用spring框架整合DBUtils技术，实现用户转账功能1.1 基础功能步骤分析创建java项目，导入坐标编写Account实体类编写AccountDao接口和实现类编写AccountService接口和实现类编写spring核心配置文件编写测试代码转账案例1 ）创建java项目，导入坐标<dependencies><dependency><groupId>mysql</groupId>.
复制链接

扫一扫