Spring---学习第三天（Spring核心之AOP）

╰半夏微凉° 2023-02-20 07:29 19阅读 0赞

### Spring第三天 ###

*  AOP简介
 *   *   *  什么是AOP？
         *  AOP的作用以及优势
         *   *  作用
             *  优势
             *  引入学习案例----给业务层添加事务的支持
         *  AOP的相关术语
         *   *  Joinpoint(连接点)
             *  Pointcut(切入点)
             *  Advice(通知/增强)
             *  Introduction(引介)
             *  Target(目标对象)
             *  Weaving(织入)
             *  Proxy（代理）
             *  Aspect(切面)
         *  学习 spring 中的 AOP 要明确的事
         *   *  开发阶段（我们做的）
             *  运行阶段（ Spring 框架完成的）
         *  基于 XML 的 AOP 配置(改善上面事务控制转账案例）
         *  基于注解 的 AOP 配置(改善上面事务控制转账案例）

# AOP简介 #

### 什么是AOP？ ###

**AOP（全称：Aspect Oriented Programming)即面向切面编程，它是面向对象编程OOP的延续，与IOC并称Spring的两大核心。在Spring中的主要用于对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，大大的提高了开发的效率。**

### AOP的作用以及优势 ###

#### 作用 ####

> 在程序运行期间，在不修改源码的情况下对已有的方法进行增强，也就是使用动态代理的方式。

#### 优势 ####

*  减少重复代码
 *  提高开发效率
 *  维护方便

#### 引入学习案例----给业务层添加事务的支持 ####

**业务层代码**

package com.gzgs.service.impl;
    
    import com.gzgs.dao.AccountDao;
    import com.gzgs.domain.Account;
    import com.gzgs.service.AccountService;
    
    import java.util.List;
    
    public class AccountServiceImpl implements AccountService { 
        private AccountDao accountDao;
    
        public void setAccountDao(AccountDao accountDao) { 
            this.accountDao = accountDao;
        }
    
        public List<Account> findAll() { 
            return accountDao.findAll();
        }
    
        public Account findAccountById(int id) { 
            return accountDao.findAccountById(id);
        }
    
        public void insertAccount(Account account) { 
            accountDao.insertAccount(account);
        }
    
        public void deleteAccount(int id) { 
            accountDao.deleteAccount(id);
        }
    
        public void updateAccount(int id, Account account) { 
            accountDao.updateAccount(id,account);
        }
    
        public void transfer(String sourceName, String targetName, double money) { 
            //查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //查询转入账户
            Account target=accountDao.findAccountByName(targetName);
            //转出账户扣钱
            source.setMoney(source.getMoney()-money);
            //转入账户加钱
            target.setMoney(target.getMoney()+money);
            //更新转出账户
            accountDao.updateAccount(source.getId(),source);
    
            //更新转入账户
            accountDao.updateAccount(target.getId(),target);
        }
    }

**代理对象工厂代码**

package com.gzgs.factory;
    
    import com.gzgs.service.AccountService;
    import com.gzgs.utils.TransactionManager;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 用于创建Service的代理对象工厂 */
    public class BeanFactory { 
       private AccountService accountService;
       private TransactionManager txManager;
    
        public void setAccountService(AccountService accountService) { 
            this.accountService = accountService;
        }
    
        public void setTxManager(TransactionManager txManager) { 
            this.txManager = txManager;
        }
    
        public AccountService getAccountService(){ 
            return (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            Object rtValue=null;
                            try { 
                                //开启事务
                                txManager.beginTransaction();
                                //执行操作
                                rtValue = method.invoke(accountService, args);
                                //提交事务
                                txManager.commit();
                                //返回结果
                                return rtValue;
                            }catch (Exception e){ 
                                txManager.rollback();
                                throw new RuntimeException(e);
                            }finally { 
                                //释放连接
                                txManager.release();
                            }
                        }
                    });
        }
    }

### AOP的相关术语 ###

#### Joinpoint(连接点) ####

> 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的  
> 连接点，对应上边的例子就是AccountServiceImpl中所有的方法都是。

#### Pointcut(切入点) ####

> 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义，也就是我们需要对其增强的方法。从概念上可以得知，所有的切入点都是连接点，而连接点不一定都是切入点。

#### Advice(通知/增强) ####

> 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。  
> 通知的类型： 前置通知,后置通知,异常通知,最终通知,环绕通知，根据相对与切入点的位置而定。

#### Introduction(引介) ####

> 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方  
> 法或 Field。

#### Target(目标对象) ####

> 代理的目标对象，也就是上面例子中的AccountServiceImpl.

#### Weaving(织入) ####

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

#### Proxy（代理） ####

> 一个类被 AOP 织入增强后，就产生一个结果代理类,也就是上面例子中getAccountService的返回结果。

#### Aspect(切面) ####

> 是切入点和通知（引介）的结合

### 学习 spring 中的 AOP 要明确的事 ###

#### 开发阶段（我们做的） ####

> 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。

> 把公用代码抽取出来，制作成通知。（开发阶段最后再做）： AOP 编程人员来做。

> 在配置文件中，声明切入点与通知间的关系，即切面。： AOP 编程人员来做。

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

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

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

### 基于 XML 的 AOP 配置(改善上面事务控制转账案例） ###

**bean.xml**

<?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"
           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">
    
        
        <bean id="accountService" class="com.gzgs.service.impl.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"></property>
        </bean>
        
        <bean id="accountDao" class="com.gzgs.dao.impl.AccountDaoImpl">
            <property name="runner" ref="runner"></property>
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
        
        <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
            <constructor-arg name="ds" ref="dataSource"></constructor-arg>
        </bean>
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test02"></property>
            <property name="user" value="root"></property>
            <property name="password" value="123456"></property>
        </bean>
        
        <bean id="connectionUtils" class="com.gzgs.utils.ConnectionUtils">
            
           <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="txManager" class="com.gzgs.utils.TransactionManager">
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
    
    
        
        <aop:config>
            
            <aop:pointcut id="pt1" expression="execution(* com.gzgs.service.impl.*.*(..))"></aop:pointcut>
            
            <aop:aspect id="advice" ref="txManager">
                
                <aop:before method="beginTransaction" pointcut-ref="pt1"></aop:before>
                
                <aop:after-returning method="commit" pointcut-ref="pt1"></aop:after-returning>
                
                <aop:after-throwing method="rollback" pointcut-ref="pt1"></aop:after-throwing>
                
                <aop:after method="release" pointcut-ref="pt1"></aop:after>
    
    
            </aop:aspect>
        </aop:config>
    
    
    
    </beans>

### 基于注解 的 AOP 配置(改善上面事务控制转账案例） ###

> 在使用基于注解的AOP配置的时候，经常会出现一个后置通知执行异常的bug，这是由于四个通知的调用顺序不和逻辑所导致的，调用顺序依次是:前置通知,最终通知,后置通知。这样就会导致由于资源被释放掉于是导致后置通知执行失败，通常它的报错信息是当connection自动提交没有设置为false，这是因为它和前置通知已经不是同一个连接了。所以在使用基于注解的AOP配置的时候，最好是使用环绕通知来控制程序的执行顺序。

**核心AOP代码**

package com.gzgs.utils;
    
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /** * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接 */
    @Component("transactionManager")
    @Aspect
    public class TransactionManager { 
        @Autowired
        private ConnectionUtils connectionUtils;
    
        @Pointcut("execution(* com.gzgs.service.impl.*.*(..))")
        private void pt1(){ }
    
    
        /** * 开启事务 */
    
        public  void beginTransaction(){ 
            try { 
                System.out.println("我是前置");
                connectionUtils.getThreadConnection().setAutoCommit(false);
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    
        /** * 提交事务 */
    
        public  void commit(){ 
            try { 
    
                connectionUtils.getThreadConnection().commit();
    
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    
        /** * 回滚事务 */
    
        public  void rollback(){ 
            try { 
                System.out.println("我是异常置");
                connectionUtils.getThreadConnection().rollback();
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    
    
        /** * 释放连接 */
    
    
    
        public  void release(){ 
            try { 
                System.out.println("释放");
                connectionUtils.getThreadConnection().close();//还回连接池中
                connectionUtils.removeConnection();
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
        @Around("pt1()")
        public Object aroundAdvice(ProceedingJoinPoint pjp){ 
            Object rtValue = null;
            try { 
                //1.获取参数
                Object[] args = pjp.getArgs();
                //2.开启事务
                this.beginTransaction();
                //3.执行方法
                rtValue = pjp.proceed(args);
                //4.提交事务
                this.commit();
                System.out.println("我是后置");
                //返回结果
                return  rtValue;
    
            }catch (Throwable e){ 
                //5.回滚事务
                this.rollback();
                throw new RuntimeException(e);
            }finally { 
                //6.释放资源
                this.release();
            }
        }
    }

**学习代码：https://download.csdn.net/download/weixin\_45680962/12550122**  
**本博客纯属个人学习笔记，学习资源来自黑马训练营，如有错误，感激指正**