Spring中AOP的注解方式的配置

川长思鸟来 2022-12-06 04:17 184阅读 0赞

#### 上篇内容简单回顾 ####

1、Spring的IOC的注解开发

（1）引入aop的包  
引入context约束  
配置文件中需要组件扫描：<context:component-scan />

（2）使用注解开发：  
@Component ：定义Bean  
@Controller ：WEB层  
@Service ：Service层  
@Repository ：DAO层

（3）属性注入：  
普通属性 ：@Value  
对象属性 ：@Resource  
@Autowired按类型注入属性，@Qulifier按名称注入属性。

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

2、XML方式和注解方式的比较

XML方式 ：适用性更广，结构更加清晰。  
注解方式 ：适用类是自己定义，开发更方便。

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

3、XML和注解的整合开发

XML定义类  
注解属性注入

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

4、Spring的AOP的基于AspectJ的XML的开发

（1）什么是AOP？  
AOP：面向切面编程，是OOP的扩展和延伸，是用来解决OOP遇到问题。

（2）Spring的AOP底层的实现：  
JDK的动态代理  
Cglib的动态代理

（3）AOP的相关术语：  
连接点：可以被拦截的点  
切入点：真正被拦截的点  
通知：增强方法  
引介：类的增强  
目标：被增强的对象  
织入：将增强应用到目标的过程  
代理：织入增强后产生的对象  
切面：切入点和通知的组合

（4）AOP的入门开发  
引入jar包  
编写目标类并配置  
编写切面类并配置  
进行aop的配置

<aop:config>
    	<aop:pointcut expression=”execution(切入点表达式)” id=”pointCut1” />
    	<aop:aspect >
    		<aop:before method=”通知方法名” pointcut-ref=”pointCut1”/>
    	</aop:aspect>
    </aop:config>

（5）通知类型  
前置通知  
后置通知  
环绕通知  
异常抛出通知  
最终通知

（6）切入点表达式写法

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

### Spring中AOP的注解方式的配置 ###

1、创建web项目，引入jar包

2、引入配置文件约束

<?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 http://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 http://www.springframework.org/schema/tx">
    
    </beans>

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

3、编写目标类，没有实现接口的类：底层使用Cglib动态代理

package com.pipi.spring.demo1;
    
    public class OrderDao { 
    
        public void save() { 
            System.out.println("save方法执行！");
        }
    
        public String delete() { 
            System.out.println("delete方法执行！");
            return "张三";
        }
    
        public void find() { 
            System.out.println("find方法执行！");
        }
    
        public void update() { 
            System.out.println("update方法执行！");
            int i = 1 / 0;  // 模拟出现异常
        }
    }

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

4、编写切面类

package com.pipi.spring.demo1;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    
    // 切面类
    @Aspect
    public class MyAspectAnno { 
    
        // 切入点的注解配置
        @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.save(..))")
        private void pointCut1(){  }
    
        @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.delete(..))")
        private void pointCut2(){  }
    
        @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.find(..))")
        private void pointCut3() {  }
    
        @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.update(..))")
        private void pointCut4() {  }
    
    
        
        // 前置通知，与切入点绑定
        @Before(value = "MyAspectAnno.pointCut1()")
        public void before(JoinPoint joinPoint) {   // 获得切入点的信息
            System.out.println("前置通知执行！" + joinPoint);
        }
    
        // 后置通知
        @AfterReturning(value = "MyAspectAnno.pointCut2()", returning="result")
        public void afterReturning(Object result) {   // 获取切入点方法的返回值
            System.out.println("后置通知执行！" + result);
        }
    
        // 环绕通知：传入参数，可执行切入点，返回值类型为Object
        @Around(value = "MyAspectAnno.pointCut3()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable { 
            System.out.println("环绕前通知执行！");
            Object obj = joinPoint.proceed();
            System.out.println("环绕后通知执行！");
            return obj;
        }
    
        // 异常通知
        @AfterThrowing(value = "MyAspectAnno.pointCut4()", throwing = "e")
        public void afterThrowing(Throwable e) {   // 获取切入点的异常信息
            System.out.println("异常抛出通知执行！" + e.getMessage());
        }
    
        // 最终通知：无论程序是否出现异常，都会执行的通知
        @After(value = "MyAspectAnno.pointCut4()")
        public void after() { 
            System.out.println("最终通知执行！");
        }
    }

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

5、编写配置文件

<aop:aspectj-autoproxy />
    
        
        <bean id="orderDao" class="com.pipi.spring.demo1.OrderDao" />
    
        
        <bean id="myAspectAnn" class="com.pipi.spring.demo1.MyAspectAnno" />

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

6、编写测试类

package com.pipi.spring.demo1;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import javax.annotation.Resource;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(value = "classpath:applicationContext.xml")
    public class SpringTest { 
    
        @Resource(name = "orderDao")
        private OrderDao orderDao;
    
        @Test
        public void test01() { 
            orderDao.save();
            System.out.println();
    
            orderDao.delete();
            System.out.println();
    
            orderDao.find();
            System.out.println();
    
            orderDao.update();
            System.out.println();
        }
    }

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

7、运行测试类

运行截图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BpcGl6aGVuXw_size_16_color_FFFFFF_t_70_pic_center]

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

#### Spring的注解的AOP的通知类型 ####

1、@Before ：前置通知

// 前置通知，与切入点绑定
    @Before(value = "execution(* com.pipi.spring.demo1.OrderDao.save(..))")
    public void before(JoinPoint joinPoint) {   // 获得切入点的信息
        System.out.println("前置通知执行！" + joinPoint);
    }

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

2、@AfterReturning ：后置通知

// 后置通知
    @AfterReturning(value = "execution(* com.pipi.spring.demo1.OrderDao.delete(..))", returning="result")
    public void afterReturning(Object result) {   // 获取切入点方法的返回值
        System.out.println("后置通知执行！" + result);
    }

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

3、@Around ：环绕通知

// 环绕通知：传入参数，可执行切入点，返回值类型为Object
    @Around(value = "execution(* com.pipi.spring.demo1.OrderDao.find(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable { 
        System.out.println("环绕前通知执行！");
        Object obj = joinPoint.proceed();
        System.out.println("环绕后通知执行！");
        return obj;
    }

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

4、@AfterThrowing ：异常抛出通知

// 异常通知
    @AfterThrowing(value = "execution(* com.pipi.spring.demo1.OrderDao.update(..))", throwing = "e")
    public void afterThrowing(Throwable e) {   // 获取切入点的异常信息
        System.out.println("异常抛出通知执行！" + e.getMessage());
    }

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

5、@After ：最终通知

// 最终通知：无论程序是否出现异常，都会执行的通知
    @After(value = "execution(* com.pipi.spring.demo1.OrderDao.update(..))")
    public void after() { 
        System.out.println("最终通知执行！");
    }

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

#### Spring中的AOP注解切入点的配置 ####

在切面类中编写方法，因为只有方法名起到PointCut的id作用，访问修饰符合返回值类型，及方法体都没啥用。

// 切入点的注解配置
    @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.save(..))")
    private void pointCut1(){  }
    
    @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.delete(..))")
    private void pointCut2(){  }
    
    @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.find(..))")
    private void pointCut3() {  }
    
    @Pointcut(value = "execution(* com.pipi.spring.demo1.OrderDao.update(..))")
    private void pointCut4() {  }

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

通知的注解与切入点的绑定：value的值都写：类.方法名()

// 前置通知，与切入点绑定
    @Before(value = "MyAspectAnno.pointCut1()")
    public void before(JoinPoint joinPoint) {   // 获得切入点的信息
        System.out.println("前置通知执行！" + joinPoint);
    }
    
    // 后置通知
    @AfterReturning(value = "MyAspectAnno.pointCut2()", returning="result")
    public void afterReturning(Object result) {   // 获取切入点方法的返回值
        System.out.println("后置通知执行！" + result);
    }
    
    // 环绕通知：传入参数，可执行切入点，返回值类型为Object
    @Around(value = "MyAspectAnno.pointCut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable { 
        System.out.println("环绕前通知执行！");
        Object obj = joinPoint.proceed();
        System.out.println("环绕后通知执行！");
        return obj;
    }
    
    // 异常通知
    @AfterThrowing(value = "MyAspectAnno.pointCut4()", throwing = "e")
    public void afterThrowing(Throwable e) {   // 获取切入点的异常信息
        System.out.println("异常抛出通知执行！" + e.getMessage());
    }
    
    // 最终通知：无论程序是否出现异常，都会执行的通知
    @After(value = "MyAspectAnno.pointCut4()")
    public void after() { 
        System.out.println("最终通知执行！");
    }

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

注意：  
如果目标对象实现了接口，Spring的AOP底层会使用JdkAopProxy的动态代理。  
如果目标对象没有实现接口，Spring的AOP底层会使用CglibAopProxy的动态代理。

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BpcGl6aGVuXw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/13727edf044d40ca871868616660ec6a.png