Spring之AOP简单讲解

╰半夏微凉° 2024-03-29 15:53 86阅读 0赞

**目录**

一：基本概念

二：案例：模拟AOP的基础代码

三：AOP相关概念

四：AOP入门案例思路分析

五：AOP工作流程

六：AOP核心概念

七：AOP切入点表达式

八：xml方式AOP快速入门

九：案例：测量业务层接口万次执行效率

JoinPoint对象

十：案例：百度网盘密码数据兼容处理

语法形式不同：

可配置的切面数量不同：

使用场景不同：

xml方式AOP原理剖析

注解方式AOP基本使用

注解方式AOP原理剖析

十一：AOP总结

--------------------

## 一：基本概念 ##

AOP， Aspect Oriented Programming， 面向切面编程,一种编程范式，指导开发者如何组织程序结构， 是对面向对象编程OOP的升华。OOP(Object Oriented Programming)是纵向对一个事物的抽象， 一个对象包括静态的属性信息， 包括动态的方法信息等。而AOP是横向的对不同事物的抽象， 属性与属性、方法与方法、对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做面向切面编程

**作用：在不惊动原始设计的基础上为其进行功能增强**

**Spring理念：无入侵式/无侵入式**

![75c97b0f01a441cd92e47ab3d90b6844.png][]

![78d7db9b07224be19debb7ec1e76fb3b.png][]

![fd70b5376ee24f51b405c3e454bad75e.png][]

## 二：案例：模拟AOP的基础代码 ##

###  ###

其实在之前学习BeanPostProcessor时， 在BeanPostProcessor的after方法中使用动态代理对Bean进行了增强， 实际存储到单例池singleObjects中的不是当前目标对象本身， 而是当前目标对象的代理对象Proxy， 这样在调用目标对象方法时， 实际调用的是代理对象Proxy的同名方法， 起到了目标方法前后都进行增强的功能，对该方式进行一下优化，将增强的方法提取出去到一个增强类中，且只对com.tangyuan.service.impl包下的任何类的任何方法进行增强

//自定义增强类
      public class My Advice{
            public void beforeAdvice() {
               System.out.println("beforeAdvice...") ；
            }
    
            public void afterAdvice() {
               System.out.println("afterAdvice...") ；
            }
    
    }

1.创建service类

public interface UserService {
         void show1();
        
         void show2();
    
    }

2.实现service的实现类

public class UserServiceImpl implements UserService { 
      @Override
        public void show1() {  
              System.out.println(show1.....);
        }
    
          @Override
        public void show2() {  
              System.out.println(show2.....);
        }
    
    
    }

ps:以上目标对象,目标类已经准备完成

3.创建增强类,内部提供增强方法

public class MyAdvice{
          //前置增强方法
          public void beforeAdvice(){
                System.out.println(前置的增强.....);
          }
        
         public void afterAdvice(){
                System.out.println(后置的增强.....);
          }    
        
    }

目的：在执行show1()方法的同时,也要将before和after的方法执行

4.将UserServiceImpl类和MyAdvic类配置到xml文件Spring容器中

5.BeanProxy对象创建

public class MockAopBeanPostProcessor implements BeanPostProcessor,ApplicationContextAware{
        //成员变量
        private ApplicationContext applicationContext;    
        
          @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
           //目的：对UserServiceImpl中的show1和show2方法进行增强,增强方法存在于MyAdvice类中
            //问题：1.筛选Service,impl包下的所有的类的所有方法都可以进行增强----解决方案if-else
            //2.MyAdvice怎么获取到?解决方案:从Spring容器中获得MyAdvice
            if(bean.getClass().getPackage().getName().equals("com.tangyuan.service.impl")){
                //生成当前bean的Proxy对象
              Object beanProxy=Proxy.newProxyInstance(
                    bean.getClass().getClassLoader(),
                    bean.getClass().getInterfaces(),
                    (Object proxy,Method  method,Object[] args) -> {
                         MyAdvice myAdvice=applicationContext.getBean(MyAdvice.class);
                        //执行增强对象的before方法
                         myAdvice.beforeAdvice();
                        //执行目标对象的目标方法
                        Object result = method.invoke(bean, args);
                        //执行增强对象的after法
                         myAdvice.afterAdvice();
                        return result;
                    }
            );
                
                return beanProxy;  
            }        
            return bean;
        }
        
         @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
             this.applicationContext=applicationContext;
        }
        
        
    
    }

6.将 MockAopBeanPostProcessor类配置到xml文件Spring容器中

7.测试

ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
       IUserService userService = applicationContext.getBean(UserService.class);
            userService.show1();

## 三：AOP相关概念 ##

![1de95df7b142483da59b71cc73472207.png][]

![eeeb6ca679594926ae1b438b6b774126.png][]

![90f7bfc30762468ba470178af67051f5.png][]

切入点范围小，连接点范围大，切入点一定在连接点中

## 四：AOP入门案例思路分析 ##

目的：在接口执行前输出当前系统时间

开发模式：xml or 注解

思路分析：

1.导入坐标(pom.xml)

<dependencies>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.4</version>
        </dependency>
      </dependencies>

spring-context坐标依赖spring-aop坐标：

![6afd8a0d73784aeb816d34102600c8b5.png][]

2.制作连接点方法(原始操作，Dao接口与实现类)

public interface BookDao {
        public void save();
        public void update();
    }

import com.tangyuan.dao.BookDao;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class BookDaoImpl implements BookDao {
    
        public void save() {
            System.out.println(System.currentTimeMillis());
            System.out.println("book dao save ...");
        }
    
        public void update(){
            System.out.println("book dao update ...");
        }

3.制作共性功能(通知类与通知)

创建一个类，用来存储共性功能

import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    //通知类必须配置成Spring管理的bean
    @Component
    //设置当前类为切面类类
    @Aspect
    public class MyAdvice {
        //4.定义切入点
        //设置切入点，要求配置在方法上方
        @Pointcut("execution(void com.tangyuan.dao.BookDao.update())")
        private void pt(){}
    
         //5.绑定切入点与通知关系(切面)
        //设置在切入点pt()的前面运行当前操作（前置通知）
         @Before("pt()")
        public void method(){
            System.out.println(System.currentTimeMillis());
        }
    }

4.定义切入点

切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

5.绑定切入点与通知关系(切面)，并指定通知添加到原始接点的具体执行位置

6.定义通知类受Spring容器管理，并定义当前类为切面类

7.在配置类中进行相关属性的配置，开启Spring对AOP注解驱动支持

## 五：AOP工作流程 ##

1.Spring容器启动

2.读取所有切面配置中的切入点

@Component
    @Aspect
    public class MyAdvice{
    @Pointcut("execution(void com.tangyuan.dao.BookDao.save())")
    private void ptx() {}
    
    @Pointcut("execution(void com.tangyuan.dao.BookDao.update())")
    private void pt() {}
    
    @Before("pt() ")
    public void method() {
    System.out.println(System.currentTimeMiLLis() ) ；
    }
    }

3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

匹配失败，创建对象

匹配成功，创建原始对象(目标对象)的代理对象

4.获取bean执行方法

获取bean，调用方法并执行，完成操作

获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

## 六：AOP核心概念 ##

目标对象(Target) ：原始功能去掉共性功能对应的类产生的对象， 这种对象是无法直接完成最终工作的

代理(Proxy) ：目标对象无法直接完成工作， 需要对其进行功能回填， 通过原始对象的代理对象实现

## 七：AOP切入点表达式 ##

切入点：要进行增强的方法

切入点表达式：要进行增强的方法的描述方式

![a853b05a650948f19a17ccd9069b5db2.png][]![796d7e858eb9460abf3b5bf9498131d4.png][]

![ee313b01e0754ecaac72f58103791ed9.png][]

![133605f5ad214282850bed69a4729fc7.png][]

## 八：xml方式AOP快速入门 ##

前面我们自己编写的AOP基础代码还是存在一些问题的， 主要如下：

*  被增强的包名在代码写死了
 *  通知对象的方法在代码中写死了

if("com.tangyuan.service.impl".equals(packageName) ) {
    //对Bean进行动态代理， 返回的是Proxy代理对象
    Object proxy Bean=Proxy.new Proxy Instance(
    bean.getClass() .getClassLoader() ，
    bean.getClass() .get Interfaces() ，
    (Object proxy，Method method， Object[]  args)->{
    myAdvice.beforeAdvice() ； //执行Advice的before方法
    Object result=method.invoke(bean， args) ； //执行目标
    myAdvice.afterAdvice() ； //执行Advice的after方法
    return result；
    })；
    //返回代理对象
    return proxyBean；
    }
      return bean；
    }

通过配置文件的方式去解决上述问题

*  配置哪些包、哪些类、哪些方法需要被增强
 *  配置目标方法要被哪些通知方法所增强，在目标方法执行之前还是之后执行增强
    
    配置方式的设计、配置文件(注解) 的解析工作， Spring已经帮我们封装好了

xml方式配置AOP的步骤：

1、导入AOP相关坐标；

2、准备目标类、准备增强类， 并配置给Spring管理；

3、配置切点表达式(哪些方法被增强)；

4、配置织入(切点被哪些通知方法增强，是前置增强还是后置增强)。

1.导入AOP相关坐标；

<dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.6</version>
        </dependency>

2.目标和通知

<bean id="userService" class="com.tangyuan.service.impl.UserServiceImpl"></bean>
    
    <bean id="myAdvice" class="com.tangyuan.advice.MyAdvice"></bean>

3.配置aop的命名空间

xmlns:aop="http://www.springframework.org/schema/aop"
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop.xsd

4.配置切点表达式

<aop:config>
    
    <aop：pointcut id="myPointcut" expression="execution(void com.tangyuan.service.impl.UserServiceImpl.show1() ) "/>
        
    <aop：aspect ref="myAdvice">
          <aop：before method="beforeAdvice" pointcut-ref="myPointcut"/>
    </aop：aspect>
        
    </aop:config>

xml配置AOP的方式还是比较简单的， 下面看一下AOP详细配置的细节：

*  切点表达式的配置方式
 *  切点表达式的配置语法
 *  通知的类型
 *  AOP的配置的两种方式

ps:

1.切点表达式可以配置在外部,可以使用pointcut-ref来引用切点表达式的id

2.pointcut="execution(void com.tangyuan.service.impl.UserServiceImpl.show1() )"

3.切点表达式可以配置多个

切点表达式是配置要对哪些连接点(哪些类的哪些方法)进行通知的增强，语法如下：

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

其中，

*  访问修饰符可以省略不写；
 *  返回值类型、某一级包名、类名、方法名可以使用\*表示任意；
 *  包名与类名之间使用单点.表示该包下的类，使用双点..表示该包及其子包下的类；
 *  参数列表可以使用两个点..表示任意参数。

切点表达式举几个例子方便理解

//表示访问修饰符为public、无返回值、在com.tangyuan.aop包下的TargetImpl类的无参方法show
    execution(public void com.tangyuan.aop.TargetImpl.show() )
    //表述com.tangyuan.aop包下的Target Impl类的任意方法
    execution(*com.tangyuan.aop.Target Impl.*(..) )
    //表示com.tangyuan.aop包下的任意类的任意方法
    execution(*com.tangyuan.aop.*.*(..) )
    //表示com.tangyuan.aop包及其子包下的任意类的任意方法
    execution(*com.tangyuan.aop..*.*(..) )
    //表示任意包中的任意类的任意方法
    execution(**..*.*(..) )

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置

![5189355d0f11447f9e0f33c286461bc9.png][]

public void beforeAdvice() {
       System.out.println("前置的增强....") ；
    }
    
    public void after Returning Advice() {
       System.out.println("后置的增强....") ；
    }
    
    
    <！--环绕通知方法-->
    public Object around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
          System.out.println("环绕前的增强....") ；
          Object res=proceedingJoinPoint.proceed() ； //执行目标方法
          System.out.println("环绕后的增强....") ；
          return res；
    }
    
    
    public void afterThrowingAdvice() {
          System.out.println("异常抛出通知...报异常才执行") ；
      }
    
    public void afterAdvice() {
         System.out.println("最终的增强....") ；
    }
    
    
    
    
    
    <aop：before method="beforeAdvice" pointout-ref="myPointcut2"/>
    
    <aop：after-returning method="afterReturningAdvice" pointcut-ref-"myPointcut2”
    
    <aop：around method="around" pointcut-ref="myPointcut2"/>
    
    <aop：after-throwing method="afterThrowingAdvice" pointcut-ref="myPointcut2"/>
    
    <aop：after method="afterAdvice" pointcut-ref="myPointcut2"/>

![e1ee517774464ab9b856f3a1e86c845a.png][]

![179a0dbb6b4b404ab762066f7ee698a1.png][]

![b005246e3c5243b683d5e3739825c109.png][]

![7efd62b850134ddeb44557d0ad76fd4a.png][]

![0e552c95b9c643828e46a274a0943621.png][]

![7ed26a379e9d45ee802d0e1b9d6baa07.png][]

## 九：案例：测量业务层接口万次执行效率 ##

![b71afb580d9948aaa04ac3fd97b058df.png][]

1.dao接口

import com.tangyuan.domain.Account;
    import org.apache.ibatis.annotations.Delete;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    
    import java.util.List;
    
    public interface AccountDao {
    
        @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
        void save(Account account);
    
        @Delete("delete from tbl_account where id = #{id} ")
        void delete(Integer id);
    
        @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
        void update(Account account);
    
        @Select("select * from tbl_account")
        List<Account> findAll();
    
        @Select("select * from tbl_account where id = #{id} ")
        Account findById(Integer id);
    }

2.service接口及实现类

import com.tangyuan.domain.Account;
    
    import java.util.List;
    
    public interface AccountService {
    
        void save(Account account);
    
        void delete(Integer id);
    
        void update(Account account);
    
        List<Account> findAll();
    
        Account findById(Integer id);
        }

import com.tangyuan.dao.AccountDao;
    import com.tangyuan.domain.Account;
    import com.tangyuan.service.AccountService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    @Service
    public class AccountServiceImpl implements AccountService {
    
        @Autowired
        private AccountDao accountDao;
    
        public void save(Account account) {
            accountDao.save(account);
        }
    
        public void update(Account account){
            accountDao.update(account);
        }
    
        public void delete(Integer id) {
            accountDao.delete(id);
        }
    
        public Account findById(Integer id) {
            return accountDao.findById(id);
        }
    
        public List<Account> findAll() {
            return accountDao.findAll();
        }
    }

3.实体类

import java.io.Serializable;
    
    public class Account implements Serializable {
    
        private Integer id;
        private String name;
        private Double money;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", money=" + money +
                    '}';
        }
    }

4.配置类

import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.sql.DataSource;
    
    
    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource dataSource(){
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }

import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.mapper.MapperScannerConfigurer;
    import org.springframework.context.annotation.Bean;
    
    import javax.sql.DataSource;
    
    public class MybatisConfig {
    
        @Bean
        public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
            SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
            ssfb.setTypeAliasesPackage("com.itheima.domain");
            ssfb.setDataSource(dataSource);
            return ssfb;
        }
    
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer(){
            MapperScannerConfigurer msc = new MapperScannerConfigurer();
            msc.setBasePackage("com.itheima.dao");
            return msc;
        }
    }

import org.springframework.context.annotation.*;
    @Configuration@ComponentScan("com.itheima")
    @PropertySource("classpath:jdbc.properties")
    @Import({JdbcConfig.class,MybatisConfig.class})
    @EnableAspectJAutoProxy
    public class SpringConfig {}

5.切面类

import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    public class ProjectAdvice {
        //匹配业务层的所有方法
        @Pointcut("execution(* com.itheima.service.*Service.*(..))")
        private void servicePt(){}
    
        //设置环绕通知，在原始操作的运行前后记录执行时间
        @Around("ProjectAdvice.servicePt()")
        public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
            //获取执行的签名对象
            Signature signature = pjp.getSignature();
            //通过签名获取执行类型(接口名)
            String className = signature.getDeclaringTypeName();//com.tangyuan.service.AccountService
            //通过签名获取执行操作名称(方法名)
            String methodName = signature.getName();//findById
    
            long start = System.currentTimeMillis();
            for (int i = 0; i < 10000; i++) {
               pjp.proceed();
            }
            long end = System.currentTimeMillis();
            System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
        }

当前测试的接口效率仅仅是一个理论值，并不是一次完整的执行过程

通知方法在被调用时， Spring可以为其传递一些必要的参数

<table> 
 <thead> 
  <tr> 
   <th>参数类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JoinPoint</td> 
   <td>连接点对象，任何通知都可使用，可以获得当前目标对象、目标方法参数等信息</td> 
  </tr> 
  <tr> 
   <td>ProceedingJoinPoint</td> 
   <td>JoinPoint子类对象， 主要是在环绕通知中执行proceed() ， 进而执行目标方法</td> 
  </tr> 
  <tr> 
   <td>Throwable</td> 
   <td>异常对象，使用在异常通知中，需要在配置文件中指出异常对象名称</td> 
  </tr> 
 </tbody> 
</table>

![34a14b4a66b547e8a92c2b52ad9041fa.png][]

### JoinPoint对象 ###

###  ###

描述了连接点方法的运行状态，可以获取到原始方法的调用参数

public void 通知方法名称(JoinPoint joinPoint) {
    //获得目标方法的参数
    System.out.println(joinPoint.getArgs() ) ；
    //获得目标对象
    System.out.println(joinPoint.getTarget() ) ；
    //获得精确的切点表达式信息
    System.out.println(joinPoint.getStaticPart() ) ；
    }

ProceedingJoinPoint对象是JoinPoint的子类

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{   System.out.println(joinPoint.getArgs() ) ； //获得目标方法的参数   System.out.println(joinPoint.getTarget() ) ； //获得目标对象   System.out.println(joinPoint.getStaticPart() ) ； //获得精确的切点表达    Objectresult=joinPoint.proceed() ； //执行目标方法       return result； //返回目标方法返回值}

Throwable对象

public void afterThrowing(JoinPoint joinPoint， Throwable th) {
         //获得异常信息
        System.out.println("异常对象是："+th+"异常信息是："+th.get Message() )
    }

<aop：after-throwing method="afterThrowing" pointcut-ref="myPointcut"  throwing="th"/>

![8fa300feeeaa4f2ea88b67e0fd07f1a2.png][]

## 十：案例：百度网盘密码数据兼容处理 ##

![d17b532cba134f908d9f7c5dc8dc68a7.png][]

1.dao接口及实现类

public interface ResourcesDao {
    
        boolean readResources(String url, String password);
    }

@Repository
    public class ResourcesDaoImpl implements ResourcesDao {
        public boolean readResources(String url, String password) {
            System.out.println(password.length());
            //模拟校验
            return password.equals("root");
        }
    }

2.service接口及实现类

public interface ResourcesService {
        public boolean openURL(String url ,String password);
    
    }

import com.tangyuan.dao.ResourcesDao;
    import com.tangyaun.service.ResourcesService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    @Service
    public class ResourcesServiceImpl implements ResourcesService {
        @Autowired
        private ResourcesDao resourcesDao;
    
        public boolean openURL(String url, String password) {
            return resourcesDao.readResources(url,password);
        }
    }

3.配置类

import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    @Configuration
    @ComponentScan("com.tangyuan")
    @EnableAspectJAutoProxy
    public class SpringConfig {
    }

4.切面类

import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    public class DataAdvice {
        @Pointcut("execution(boolean com.tangyuan.service.*Service.*(*,*))")
        private void servicePt(){}
    
        @Around("DataAdvice.servicePt()")
        public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
            //获取参数
            Object[] args = pjp.getArgs();
            //遍历参数
            for (int i = 0; i < args.length; i++) {
                //判断参数是不是字符串
                if(args[i].getClass().equals(String.class)){
                    args[i] = args[i].toString().trim();
                }
            }
            Object ret = pjp.proceed(args);
            return ret;
        }
    }

5.测试

import com.tangyuan.config.SpringConfig;
    import com.tangyuan.service.ResourcesService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
            boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
            System.out.println(flag);
        }
    }

AOP配置的两种语法形式

AOP的xml有两种配置方式， 如下：

*  使用<advisor>配置切面
 *  使用<aspect>配置切面
    
    Spring定义了一个Advice接口， 实现了该接口的类都可以作为通知类出现

public interface Advice{ }

advisor需要的通知类需要实现Advice的子功能接口， 例如：MethodBeforeAdvice、AfterReturningAdvice等， 是通过实现的接口去确定具备哪些通知增强的， 见代码演示

public class MyAdvice2 implements MethodBeforeAdvice， AfterReturningAdvice{
    @Override
    public void before(Method method， Object[] objects， Object o) throws Throwable {
          System.out.println("前置通知.."}
    }
    
    
    @Override
    public void afterReturning(Object o， Method method， Object[] objects， Object o) throws Throwable
        System.out.println("后置通知...........") ；
           }
     }

public class MyAdvice3 implements MethodInterceptor{
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable{
        System.out.println("环绕前...........") ；
    //执行目标方法
    Object res=method Invocation.getMethod() .invoke(methodInvocation.getThis()，methodInvocation.getArguments() ) ；
          System.out.println("环绕后...........") ；
    return res；
    }

AOP配置的两种语法形式不同点

### 语法形式不同： ###

*  advisor是通过实现接口来确认通知的类型,如MyAdvice2
 *  aspect是通过配置确认通知的类型， 更加灵活,如
 *      <aop:aspect ref="myadvice">
        
        <aop:after method="afterAdvice" pointcut-ref="myPointcut2"/>
        
        /aop:aspect

### 可配置的切面数量不同： ###

*  一个advisor只能配置一个固定通知和一个切点表达式
 *  一个aspect可以配置多个通知和多个切点表达式任意组合

### 使用场景不同： ###

*  允许随意搭配情况下可以使用aspect进行配置
 *  如果通知类型单一、切面单一的情况下可以使用advisor进行配置
 *  在通知类型已经固定， 不用人为指定通知类型时， 可以使用advisor进行配置， 例如后面要学习的Spring事务控制的配置

*  ### xml方式AOP原理剖析 ###

![0ff0a27cc74744e586f735240d0d37a7.png][]

![38c25d5305584d379874046576dce2f0.png][]

![50f77ffd47e74deb817512f20a07c53b.png][]

![ede255dfbc4041b0b2d4ed0616257c74.png][]

![99cab00d16344387b30341253c523d26.png][]

![ff64abc2ef1b43139e2291be6254f2f2.png][]

JDK的动态代理代码， 之前已经写过了， 下面看一下Cglib基于超类的动态代理

Target target=new Target() ； //目标对象
    Advices advices三new Advices() ； //通知对象
    Enhancer enhancer=new Enhancer() ； //增强器对象
    enhancer.setSuperclass(Target.class) ； //增强器设置父类
    //增强器设置回调
    enhancer.set Callback( (MethodInterceptor) (o， method，objects，method Proxy)一>{
    
    advices.before() ；
    Object result=method.invoke(target， objects) ；
    advices.afterReturning() ；
    return result；
    
    })；
    //创建代理对象
    Target targetProxy=(Target) enhancer.create() ；
    //测试
    String result=targetProxy.show("haohao") ；

*  ### 注解方式AOP基本使用 ###

Spring的AOP也提供了注解方式配置， 使用相应的注解替代之前的xml配置， xml配置AOP时， 我们主要配置了三 部分：目标类被Spring容器管理、通知类被Spring管理、通知与切点的织入(切面) ， 如下

<bean id="target"class="com.tangyuan.aop.Target Impl"></bean>
    
    <bean id="advices"class="com.tangyuan.aop.Advices"></bean>
    
    <aop：config proxy-target-class="true">
    <aop：aspect ref="advices">
        <aop：around method="around"pointcut="execution(*com.tangyuan.aop.*.*(..))"/>
    </aop：aspect>
    </aop：config>

1.接口service类

@Service("userService")
    public class UserServiceImpl implements UserService{ }

2.增强类

//增强类，内部提供增强方法
    @Component
    @Aspect
    public class MyAdvice{
    //<aop：beforemethod="beforeAdvice"pointcut="execution(*com.tangyuan.service.impl.*.*(..))"/>
    @Before("execution(*com.tangyuan.service.impl.*.*(..) ) ")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("当前目标对象是："+joinPoint.getTarget() ) ；
        System.out.println("表达式："+joinPoint.getStaticPart() ) ；
        System.out.println("前置的增强....") ；
    }
    }

3.在xml文件中进行配置

<context：component-scan base-package="com.tangyuan"/>
    
    
    <aop：aspectj-autoproxy/>

![0e33daa9ea6340a9b010bbda0d561ea8.png][]

各种注解方式通知类型
    //前置通知
    @Before("execution(*com.tangyuan.aop.*.*(..) ) ")
    public void before(JoinPoint joinPoint) {}
    //后置通知
    @AfterReturning("execution(*com.tangyuan.aop.*.*(..) ) ")
    public void AfterReturning(JoinPoint joinPoint) {}
    //环绕通知
    @Around("execution(*com.tangyuan.aop.*.*(..) ) ")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable{}
    //异常通知
    @AfterThrowing("execution(*com.tangyuan.aop.*.*(..) ) ")
    public void AfterThrowing(Join Point join Point) {}
    //最终通知
    @After("execution(*com.tangyuan.aop.*.*(..) ) ")
    public void After(JoinPoint joinPoint) {}
    
    //切点表达式的抽取
    @Pointcut("execution(*com.tangyuan.service.impl.*.*(..))")
    public void myPointcut() {}
    
    使用：
    @Around(“类名.myPointcut()”）

@Confiquration
    @ComponentScan("com.tangyuan")//<context：component-scan base-package="com.tangyuan"/>
    @EnableAspectJAutoProxy //<aop：aspectj-autoproxy/>
    public class Spring Config{ }

*  ### 注解方式AOP原理剖析 ###

![1ce7414cd1c14fef9d04bde5529cbcd6.png][]

![607650fffda14d608de415d3e490b4fd.png][]

![3e7478d056fd42e1a1223a446cf87526.png][]

![322af536a1d647f3a4e3e542cb58b9e1.png][]

![d002c6e0a10147e5969f6fc5570c8e61.png][]

## 十一：AOP总结 ##

![1432f284cca44528803d4e4a5d3f341b.png][]

![9e6a7bca7052425b8786aea1308995ea.png][]

![39cccc55ad6b42daa1f1a90d046a3606.png][]

![2dc54760363248f2ac120de777971ada.png][]

[75c97b0f01a441cd92e47ab3d90b6844.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3e9955f45e9140b585badee164ac743a.png
[78d7db9b07224be19debb7ec1e76fb3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/08ba8a5b1a7441b798de5b9fe85b4627.png
[fd70b5376ee24f51b405c3e454bad75e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/092253fc34dd42f5ae8f6f72d08f8598.png
[1de95df7b142483da59b71cc73472207.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/bc4671fd0b854a59a0f2782f1235121e.png
[eeeb6ca679594926ae1b438b6b774126.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/7e12d4c0960646c5b204218ef6e7d65c.png
[90f7bfc30762468ba470178af67051f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f690e2adc5aa4b368fe8db46f551cd98.png
[6afd8a0d73784aeb816d34102600c8b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/4eee76786f1d46a9accf534d0d757505.png
[a853b05a650948f19a17ccd9069b5db2.png]: https://img-blog.csdnimg.cn/a853b05a650948f19a17ccd9069b5db2.png
[796d7e858eb9460abf3b5bf9498131d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2f83654daa9041268326d9212169d424.png
[ee313b01e0754ecaac72f58103791ed9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/858829ac5713477481dd490fff36af23.png
[133605f5ad214282850bed69a4729fc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/e5598d62360a47858864013d81f1eaf9.png
[5189355d0f11447f9e0f33c286461bc9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/d85093a051644988a518598d4599203b.png
[e1ee517774464ab9b856f3a1e86c845a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/71024e6b54964b8a87fee14fd0e53b7f.png
[179a0dbb6b4b404ab762066f7ee698a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c54f022510c24bf9af4a2cd8186e7438.png
[b005246e3c5243b683d5e3739825c109.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/8d8b9d0a06a84f80a5b2e9c3b98500f4.png
[7efd62b850134ddeb44557d0ad76fd4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/19bc50decacf4910aa8f0920003dc949.png
[0e552c95b9c643828e46a274a0943621.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/8551068d119048c4a02c13d0debd0f59.png
[7ed26a379e9d45ee802d0e1b9d6baa07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/d8e7bcad7ce847ea8be9f908f741ea7b.png
[b71afb580d9948aaa04ac3fd97b058df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/41bcd8a206c14cb3bdb4c6fd9a47a87a.png
[34a14b4a66b547e8a92c2b52ad9041fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0f8245cc225b4aaa8959473d207627b0.png
[8fa300feeeaa4f2ea88b67e0fd07f1a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/8b250f0eced2419c806285c5fd15b820.png
[d17b532cba134f908d9f7c5dc8dc68a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/4d9da2a465444718aaa595366e3f4e57.png
[0ff0a27cc74744e586f735240d0d37a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/e515f83d1fc34f7eac915063f5753ae3.png
[38c25d5305584d379874046576dce2f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/381b1e3930c14f318f78f747262afcdb.png
[50f77ffd47e74deb817512f20a07c53b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/da4195f49d3f441691caf0ad4041b055.png
[ede255dfbc4041b0b2d4ed0616257c74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/40add77c195447e6a4c7f9d5aac8dfab.png
[99cab00d16344387b30341253c523d26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/15d883207ae94c48aec3fa7e331a29df.png
[ff64abc2ef1b43139e2291be6254f2f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/268a8d2d2389479595c8e60c2b9ccdbb.png
[0e33daa9ea6340a9b010bbda0d561ea8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/62ef64a74d3c46c78ed23e37e828cb74.png
[1ce7414cd1c14fef9d04bde5529cbcd6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/dc60209710244159a99c7cbbba5222d9.png
[607650fffda14d608de415d3e490b4fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3c319cd6a8ce47fb8e6bf342e0fcf8e8.png
[3e7478d056fd42e1a1223a446cf87526.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/5c7a75f66a6246b6b801c581df5b8c65.png
[322af536a1d647f3a4e3e542cb58b9e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/e3f9c9607a61428185ecb9f3ead02839.png
[d002c6e0a10147e5969f6fc5570c8e61.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0ff740d72e57458bb8aac3bccaf82268.png
[1432f284cca44528803d4e4a5d3f341b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/698a8755457848a18163acc61ab050fe.png
[9e6a7bca7052425b8786aea1308995ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3fb37d0117054e8caecc741aeb23cf1d.png
[39cccc55ad6b42daa1f1a90d046a3606.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/8ef200bd5d7547929144d2d6333fcf4b.png
[2dc54760363248f2ac120de777971ada.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/996cab3fd41f45b590ee80cea803bc3f.png