AOP切面编程之Aspect框架

什么叫Aspect？

AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP
主要用途：自定义开发

Aspect通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。
aspectj 通知类型，只定义类型名称。已经方法格式。
before:前置通知(应用：各种校验)
在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
方法正常返回后执行，如果方法中抛出异常，通知无法执行
必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：十分强大，可以做任何事情)
方法执行前后分别执行，可以阻止方法的执行
必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
方法抛出异常后执行，如果方法没有抛出异常，无法执行
after:最终通知(应用：清理现场)
方法执行完毕后执行，无论方法中是否出现异常

需要导入的jar包

4个：
aop联盟规范
spring aop 实现
aspect 规范
spring aspect 实现

基于XML的Aspect框架操作

1. 创建目标接口

package com.itheima.AspectJdaili;
//使用AspectJ来实现动态代理
public interface UserDao {
	//定义第一个接口
public void Useradd();
public String Userupdate();
public void Userdelete();
}

2.创建实现类

public class UserDaolmp implements UserDao{
//定义第一个接口的实现类
	
	public void Useradd() {
		System.out.println("增加AspectJ代理");
		
	}

	public String Userupdate() {
		System.out.println("修改AspectJ代理");
		//这里设置一个异常，看看异常通知的反映
		int i=1/0;
		return "后置通知第二个形参可以返回目标方法的返回值";
		
	}

	public void Userdelete() {
		System.out.println("删除AspectJ代理");
		
	}

3.创建切面类，提供各种切面方法

public class MyAspect {
/**
	 * 参数1：import org.aspectj.lang.JoinPoint;这个参数用于描述连接点（目标方法）（在没被调用前是连接点，调用后才会成为切入点）
	 * 获得目标方法的方法名，修饰符等等
	 * getSignature():方法签名,获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息
	 * getName() 方法的名称
	 */
public void mybefore(JoinPoint joinPoint){//在自定义的前置通知方法中可以设置进行传参
		System.out.println("前增强通知："+joinPoint.getSignature().getName());
	}
	/**
	 * 自定义一个后置通知方法(可以有参数 参数1.可以获取一些目标方法的信息 2.获得目标方法的返回值 类型是Object)
	 */

	public void myafter(JoinPoint joinPoint,Object rev){
		//记得在xml配置文件中定义returning属性时，需要和后置通知第二个形参一致 这里都为rev(这里目标类中的方法返回值都为void)
		//我们修改一个
		System.out.println("后增强:"+joinPoint.getSignature().getName()+",-->"+rev);
	}
	/**
	 * 自定义一个环绕通知方法(JoinPoint的子接口ProceedingJoinPoint)
	 * 环绕通知方法：对目标方法执行环绕执行  返回值为一个Object类型的值 为了保证方法有无返回值  环绕通知都需要返回值（保险一点）
	 * 记得要抛出异常  
	 */
	public Object myaround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前增强");
		//手动执行目标方法
   Object obj=joinPoint.proceed();
      System.out.println("后增强");
		return obj;
	}

	/**
	 * 自定义一个异常通知方法(JoinPoint joinPoint,Throwable e)
	 * 异常通知：在产生异常后执行，如果后面还有方法，在发生异常后停止执行
	 * 第二个参数：用于获取目标方法的详细 （跟后置通知一样，要和xml中的throwing属性值一致）
	 * getMessage():输出异常的详细信息
	 */
public void mythrowing(JoinPoint joinPoint,Throwable e){
	System.out.println("异常通知执行成功"+e.getMessage());
}


/**
 * 自定义一个最终通知方法 ，这个通知方法类似与finally语句快（在程序最后执行完前执行，就算发生异常也会执行）
 */
public void myfinally(){
	System.out.println("最终通知，类似与finally语句快");
}
}

4.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"
    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"> <!-- bean definitions here -->
         <!-- 使用AspectJ来实现动态代理 -->
 <!--1.创建目标类对象 -->
 <bean id="userDao" class="com.itheima.AspectJdaili.UserDaolmp"></bean>        
 <!-- 2.创建通知类对象 -->
<bean id="my" class="com.itheima.AspectJdaili.MyAspect"></bean>


<!-- 真正意义是对切入点进行增强然后动态代理类去整合，然后通过目标类类去输出 -->
 <aop:config>
<aop:aspect ref="my"><!-- 这个ref引用，将自定义的通知类转换成真正的通知 -->
<aop:pointcut expression="execution(* com.itheima.AspectJdaili.UserDaolmp.*(..))" id="mypointcut"></aop:pointcut>
<!-- 前置通知，通知方法先执行-->
<aop:before method="mybefore" pointcut-ref="mypointcut"/>
<!-- 后置通知，通知方法在目标方法执行后执行-->
<aop:after-returning method="myafter" pointcut-ref="mypointcut" returning="rev"></aop:after-returning>
<!-- 环绕通知，通知方法在目标方法的前后执行-->
<aop:around method="myaround" pointcut-ref="mypointcut"></aop:around>
<!-- 异常通知,目标方法发生异常后执行 -->
<aop:after-throwing method="mythrowing" pointcut-ref="mypointcut" throwing="e"></aop:after-throwing>
<!-- 最终通知，目标方法和其他通知执行完后执行-->
  <aop:after method="myfinally" pointcut-ref="mypointcut"></aop:after>
  </aop:aspect>
</aop:config>
</beans>

使用Aspect注解

1. 创建目标接口

package com.itheima.AspectJzhujie;
//使用AspectJ来实现动态代理
public interface UserDao {
	//定义第一个接口
public void Useradd();
public String Userupdate();
public void Userdelete();
}

2.创建实现类

@Service("userDao")
public class UserDaolmp implements UserDao{
//定义第一个接口的实现类
	
	public void Useradd() {
		System.out.println("增加AspectJ代理");
		
	}

	public String Userupdate() {
		System.out.println("修改AspectJ代理");
		//这里设置一个异常，看看异常通知的反映
    
		return "后置通知第二个形参可以返回目标方法的返回值";
		
	}

	public void Userdelete() {
		System.out.println("删除AspectJ代理");
		
	}

}

3.创建切面类

@Component("my")//当然这里可以不写id，因为等会配置切面类的注解需要在这个类进行，两个注解都在这里执行
@Aspect//替代了<aop:aspect ref="my">配置切面类@Aspect//替代了<aop:aspect ref="my">配置切面类 用于或者通知
public class MyAspect {
//这时候我们想像之前一样使用公共的切入点
	//替代了<aop:pointcut expression="execution(* com.itheima.AspectJdaili.UserDaolmp.*(..))" id="mypointcut">
	//这时候我们可以定义一个公共切入点的方法,加上注解，使他变成一个公共切入点注解代替了expression= 而方法名代替了id
	@Pointcut("execution(* com.itheima.AspectJzhujie.UserDaolmp.*(..))")
	public void myPointcut(){
	}
//替代了<aop:before method="mybefore" pointcut=""execution(* com.itheima.AspectJdaili.UserDaolmp.*(..))""/>
	//切入点只对当前通知有效
	//@Before("execution(* com.itheima.AspectJzhujie.UserDaolmp.*(..))")//前置通知注解
	public void mybefore(JoinPoint joinPoint){//在自定义的前置通知方法中可以设置进行传参
		System.out.println("前增强通知："+joinPoint.getSignature().getName());
	}
	//替整体代了<aop:after-returning method="myafter" pointcut-ref="mypointcut" returning="rev">
	//而注解主要是替代了<aop:after-returning method="myafter"
//@AfterReturning(value="myPointcut()", returning="rev")//value相当于Pointcut-ref returning的属性直接加到上面就可以了
	public void myafter(JoinPoint joinPoint,Object rev){
		System.out.println("后增强:"+joinPoint.getSignature().getName()+",-->"+rev);
	}
	//环绕通知：注解替代了<aop:around method="myaround" pointcut-ref="mypointcut">
	//而注解主要替换了<aop:around method="myaround" value在通知注解中等于pointcut-ref
	//@Around(value="myPointcut()")
	public Object myaround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前增强");
		//手动执行目标方法
   Object obj=joinPoint.proceed();
      System.out.println("后增强");
		return obj;
	}
	//异常通知:注解代替了<aop:after-throwing method="mythrowing" pointcut-ref="mypointcut" throwing="e">
	//而注解主要替代了<aop:after-throwing method="mythrowing",value可以写入切入点的id 也可以直接写入切入点的具体方法
	//记得把异常属性写入注解，两者的值要一致Throwable e和throwing="e"
	//@AfterThrowing(value="execution(* com.itheima.AspectJzhujie.UserDaolmp.*(..))",throwing="e")
public void mythrowing(JoinPoint joinPoint,Throwable e){
	System.out.println("异常通知执行成功"+e.getMessage());
}
//最终通知：注解替代了<aop:after method="myfinally" pointcut-ref="mypointcut">
//而注解主要替代了<aop:after method="myfinally" value可以写入切入点的id(pointcut-ref) 也可以直接写入切入点的具体方法
@After(value="myPointcut()")
public void myfinally(){
	System.out.println("最终通知，类似与finally语句快");
}
}

4.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: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/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">
         <!-- 使用AOP注解来代替AspectJ实现动态代理 -->
         <!-- 编写扫描 -->
         <context:component-scan base-package="com.itheima.AspectJzhujie"></context:component-scan>
         <!-- 确保AOP注解生效（@Aspect，@before等等之类的）使aspectj自动动态代理 -->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 <!--1.注解替代创建目标类对象 -->   


</beans>

本文地址：https://blog.csdn.net/qq_45979629/article/details/107071446