Java 11.Spring--AOP编程（注解）

1.创建web项目

2.引入jar包

在原有的jar包加上AOP的jar包

3.日志

 

4.准备目标对象

先创建接口

在创建实现类

package com.Spring.aop.service;

public class UserServceImpl implements UserService {

	@Override
	public void save() {
		System.out.println("保存用户");
		// TODO Auto-generated method stub
		
	}

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

	@Override
	public void update() {
		System.out.println("更新用户");
		// TODO Auto-generated method stub
		
	}

	@Override
	public void select() {
		System.out.println("查询用户");
		// TODO Auto-generated method stub
		
	}
	 

}

　　

 

5.编写通知

前置通知：在目标方法之前调用

后置通知（如果出现异常就不调用）：在目标方法之后调用

后置通知（无论是否出现异常都会调用）：在目标方法之后调用

环绕通知：在目标方法之后调用

异常通知：出现异常调用

package com.Spring.aop.advice;

import org.aspectj.lang.ProceedingJoinPoint;

public class TransactionAdvice {
//	前置通知：在目标方法之前调用
//
//	后置通知（如果出现异常就不调用）：在目标方法之后调用
//
//	后置通知（无论是否出现异常都会调用）：在目标方法之后调用
//
//	环绕通知：在目标方法之后调用
//
//	异常通知：出现异常调用
	public void before() {
		System.out.println("前置通知被执行");
	}
	
	public void afterReturning() {
		System.out.println("后置通知（如果出现异常就不调用）");
		
	}
	public void after() {
		System.out.println("后置通知（无论是否出现异常都会调用）");
		
	}
	public void afterException() {
		System.out.println("异常通知被执行");
	}
	public Object around(ProceedingJoinPoint point) throws Throwable {
		System.out.println();
		Object proceed = point.proceed();
		return proceed;
		
	}

}

　　

 

6.配置织入，将通知织入到目标对象

 

		<!-- 目标对象 -->
       	<bean name="userServce" class= "com.Spring.aop.service.UserServceImpl"></bean>
		<!-- 通知对象 -->
		<bean name="transactionAdvice" class= "com.Spring.aop.advice.TransactionAdvice" ></bean>
		<!-- 开启织入注解 -->
		<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

　　

 

加入AOP名称空间

7.在通知上添加注解

 

package com.Spring.aop.advice;

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;

@Aspect
public class TransactionAdvice {
//	前置通知：在目标方法之前调用
//
//	后置通知（如果出现异常就不调用）：在目标方法之后调用
//
//	后置通知（无论是否出现异常都会调用）：在目标方法之后调用
//
//	环绕通知：在目标方法之后调用
//
//	异常通知：出现异常调用
	@Pointcut("execution(. com.Spring.aop.service..*ServceImpl.*(..))")
	public void pointcut() {
		
	}
	
	
	@Before("TransactionAdvice.pointcut")
	public void before() {
		System.out.println("前置通知被执行");
	}
	@AfterReturning("TransactionAdvice.pointcut")
	public void afterReturning() {
		System.out.println("后置通知（如果出现异常就不调用）");
		
	}
	@After("TransactionAdvice.pointcut")
	public void after() {
		System.out.println("后置通知（无论是否出现异常都会调用）");
		
	}
	@AfterThrowing("TransactionAdvice.pointcut")
	public void afterException() {
		System.out.println("异常通知被执行");
	}
	@Around("TransactionAdvice.pointcut")
	public Object around(ProceedingJoinPoint point) throws Throwable {
		System.out.println("环绕前");
		Object proceed = point.proceed();
		System.out.println("环绕后");
		return proceed;
		
	}

}

　　

 

7.测试

package com.Spring.aop.service;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
	@Resource(name="userService")
	private UserService userService; 
	
	@Test
	public void testSave() {
		userService.save("yu jack");
	}
	
	@Test
	public void testUpdate() {
		userService.update();
	}
	
}