基于AspectJ的简单AOP例子

最新推荐文章于 2021-03-28 22:57:55 发布

风在咆哮

最新推荐文章于 2021-03-28 22:57:55 发布

阅读量150

点赞数

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

本文链接：https://blog.csdn.net/qq_37054816/article/details/99984761

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

基于XML的声明式Aspectj

目标类UserDao

package com.ssm.aspectj;

public interface UserDao {
	public void addUser();
	public void deleteUser();
}

package com.ssm.aspectj;

public class UserDaoImpl implements UserDao {

	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("添加用户");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

}

切面类

package com.ssm.aspectj.xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
	//前置通知
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知：模拟执行权限检查：......");
		System.out.print("目标类是："+joinPoint.getTarget());
		System.out.println("，被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}
	//后置通知
	public void myAfterReturing(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志：......");
		System.out.print("目标类是："+joinPoint.getTarget());
		System.out.println("，被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}
	/**
	 * 环绕通知
	 * ProceedingJoinPoint是joinpoint的子接口，表示可执行目标类的方法
	 * 1、必须是object类型的返回值
	 * 2、必须接受一个参数，类型为ProceedingJoinPoint
	 * 3、必须是throws Throwable
	 * @throws Throwable 
	 */
	public Object myAround( ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		//开始
		System.out.print("环绕开始：执行目标方法之前，模拟开启事务。。。");
		//执行当前目标方法
		Object object = proceedingJoinPoint.proceed();
		//结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务。。。");
		return object;
		
	}
	//异常通知
		public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {
			System.out.println("异常通知：出错了"+e.getMessage());
		}
	//z最终通知
		public void myAfter() {
			System.out.println("最终通知：模拟方法结束后释放资源。。。");
		}
}

配置文件

<?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"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.2.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
      http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
      ">
      <!-- 目标 -->
    <bean id="userDao" class="com.ssm.aspectj.UserDaoImpl"></bean>
    <!-- 切面 -->
    <bean id="myAspect" class="com.ssm.aspectj.xml.MyAspect" > </bean>
    <!-- aop编程 -->
    <aop:config>
    	<!-- 配置切面 -->
    	<aop:aspect id="aspect" ref="myAspect" >
    	<!-- 配置切入点 -->
    		<aop:pointcut expression="execution(* com.ssm.aspectj.*.*(..))" id="myPointCut"/>
    		<!-- 配置通知 -->
    		<!-- 前置通知 -->
    		<aop:before method="myBefore" pointcut-ref="myPointCut"/>
    		<!-- 后置通知 -->
    		<aop:after-returning method="myAfterReturing" pointcut-ref="myPointCut" returning="returnVal"/>
    		<!-- 环绕通知 -->
    		<aop:around method="myAround" pointcut-ref="myPointCut" />
    		<!-- 异常通知 -->
    		<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
    		<!-- 最终通知 -->
    		<aop:after method="myAfter" pointcut-ref="myPointCut"/>
    	</aop:aspect>
    </aop:config>
</beans>

后置通知和最终通知的区别：后置通知只有在目标方法成功运行后才会被植入；而最终通知无论目标方法是否成功运行，都会被植入。另外，如果程序没有异常，异常通知就不会被执行

测试

package com.ssm.aspectj.xml;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ssm.aspectj.UserDao;

public class TestXmlAspectj {
	@SuppressWarnings("resource")
	@Test
	public void test() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.addUser();
	}
}

在这里插入图片描述

基于Annotation(注解)的声明式Aspectj

在目标类中添加注解@Repository(“userDao”)

package com.ssm.aspectj;

import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDaoImpl implements UserDao {

	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("添加用户");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

}

package com.ssm.aspectj.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect		//相当于 <aop:aspect id="aspect" ref="myAspect" >
@Component	//相当于 <bean id="myAspect" class="com.ssm.aspectj.xml.MyAspect" > </bean>
public class MyAspect {
	//定义切入点表达式
	@Pointcut("execution(* com.ssm.aspectj.*.*(..))")
	
	//使用一个返回值为void，方法体为空的方法来命名切入点
	public void myPointCut() {}
	
	//前置通知
	@Before("myPointCut()")
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知：模拟执行权限检查：......");
		System.out.print("目标类是："+joinPoint.getTarget());
		System.out.println("，被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}
	
	@AfterReturning("myPointCut()")
	//后置通知
	public void myAfterReturing(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志：......");
		System.out.print("目标类是："+joinPoint.getTarget());
		System.out.println("，被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}
	
	/**
	 * 环绕通知
	 * ProceedingJoinPoint是joinpoint的子接口，表示可执行目标类的方法
	 * 1、必须是object类型的返回值
	 * 2、必须接受一个参数，类型为ProceedingJoinPoint
	 * 3、必须是throws Throwable
	 * @throws Throwable 
	 */
	@Around("myPointCut()")
	public Object myAround( ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		//开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务。。。");
		//执行当前目标方法
		Object object = proceedingJoinPoint.proceed();
		//结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务。。。");
		return object;
		
	}

	//异常通知
	@AfterThrowing(value="myPointCut()",throwing="e")
		public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {
			System.out.println("异常通知：出错了"+e.getMessage());
		}
	
	//z最终通知
	@After("myPointCut()")
		public void myAfter() {
			System.out.println("最终通知：模拟方法结束后释放资源。。。");
		}
}

<?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"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.2.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
      http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
      ">
     <!-- 注解扫描 -->
     <context:component-scan base-package="com.ssm.aspectj"></context:component-scan>
     
     <!-- 启动基于注解的声明式aspectj支持 -->
     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试

package com.ssm.aspectj.annotation;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ssm.aspectj.UserDao;

public class TestAnnotationAspectj {
	@SuppressWarnings("resource")
	@Test
	public void test() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.addUser();
	}
}

如果在同一个连接点有多个通知需要执行，那么在同一个切面中，目标方法之前的前置通知和环绕通知的执行顺序是未知的，目标方法之后的后置通知和环绕通知的执行顺序也是未知的。

风在咆哮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基于AspectJ的简单AOP例子

基于XML的声明式Aspectj目标类UserDaopackage com.ssm.aspectj;public interface UserDao { public void addUser(); public void deleteUser();}package com.ssm.aspectj;public class UserDaoImpl implements ...
复制链接

扫一扫

专栏目录