Spring-AOP配置-注解方式

旧城等待， 2023-02-10 01:21 44阅读 0赞

#### 常用注解 ####

**@Aspect**  
作用：  
把当前类声明为切面类。

**@Before**  
作用：  
把当前方法看成是前置通知。  
属性：  
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

**@AfterReturning**  
作用：  
把当前方法看成是最终通知。报异常，就不执行  
属性：  
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

**@AfterThrowing**  
作用：  
把当前方法看成是异常通知。只有报异常才执行  
属性：  
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

**@After**  
作用：  
把当前方法看成是后置通知。不管报不报异常都执行  
属性：  
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

**@Around**  
作用：  
把当前方法看成是环绕通知。  
属性：  
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

**@Pointcut**  
作用：  
指定切入点表达式  
属性：  
value：指定表达式的内容

### 配置环境 ###

##### UserService 接口 #####

package com.ywq.spring.service;
    
    import com.ywq.spring.pojo.User;
    
    public interface UserService {
        
    	void insert(User user);
    	void update(User user);
    }

##### 业务层UserServiceImpl 实现类 #####

package com.ywq.spring.service.impl;
    
    import com.ywq.spring.pojo.User;
    import com.ywq.spring.service.UserService;
    
    @Service
    public class UserServiceImpl implements UserService{
        
    	
    	public void insert(User user) {
        
    		System.out.println("---调用DAO层保存方法---");
    	}
    	public void update(User user) {
        
    		System.out.println("---调用DAO层修改方法---");
    	}
    }

##### 切面类 #####

package com.ywq.spring;
    
    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;
    
    @Component
    @Aspect //在此类中可以使用注解进行aop的相关配置 <aop:aspect>
    public class TransactionManagerHandler {
        
    	
    	//<aop:pointcut expression="execution( * com.ywq.spring.service..*.*(..))" id="当前方法名就是id"/>
    	@Pointcut("execution( * com.ywq.spring.service..*.*(..))")
    	public void pointcut() {
        }
    	
    	@Before("pointcut()") //<aop:before method="begin" pointcut-ref="pt"/>
    	public void begin() {
        
    		System.out.println("开启事务");
    	}
    	
    	@AfterReturning("pointcut()")//<aop:after-returning method="commit" pointcut-ref="pt"/> 
    	public void commit() {
        
    		System.out.println("提交事务");
    	}
    	
    	//<aop:after-throwing  throwing="e"  method="rollback" pointcut-ref="pt"/>
    	@AfterThrowing(pointcut="pointcut()",throwing="ex")
    	public void rollback(Throwable ex) {
        
    		System.out.println("注解的回滚事务 : " + ex.getMessage());
    	}
    	
    	@After("pointcut()")//<aop:after method="close"  pointcut-ref="pt"/>
    	public void close() {
        
    		System.out.println("关闭session");
    	}
    	
    	//环绕增强
    	@Around("pointcut()") //<aop:around method="allInOne" pointcut-ref="pt"/>
    	public Object allInOne(ProceedingJoinPoint pjp) {
        
    		Object result = null;
    		try {
        
    			System.out.println("开启事务------");
    			//执行被代理对象当前需要执行业务方法
    			result = pjp.proceed();
    			System.out.println("提交事务------");
    		} catch (Throwable ex) {
        
    			System.out.println("------回滚事务 : " + ex.getMessage());
    		}finally {
        
    			System.out.println("关闭session------");
    		}
    		return result;
    	}
    }

##### AOPxml配置 #####

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        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
        ">
       
       <context:component-scan base-package="com.ywq.spring"/>	
       
       <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

##### 纯注解配置 #####

package com.ywq.spring.config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    @Configuration
    @ComponentScan("com.ywq.spring")
    @EnableAspectJAutoProxy //开启aop注解配置
    public class SpringConfig {
        
    
    }

##### 测试代码 #####

package com.ywq.spring.test;
    
    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;
    
    import com.ywq.spring.pojo.User;
    import com.ywq.spring.service.impl.UserServiceImpl;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    //读取Spring配置文件 xml
    //@ContextConfiguration("classpath:applicationContext.xml")
    //读取Spring配置文件 java类做配置文件
    @ContextConfiguration(classes = {
        SpringConfig.class})
    public class UserServiceTest {
        
    
    	@Resource
    	private UserServiceImpl service;
    
    	@Test
    	public void testSave() {
        
    		User user = new User(null, "张三", "zhangsan@qq.com");
    		service.insert(user);
    	}
    
    	@Test
    	public void testUpdate() {
        
    		User user = new User(1, "李四", "lisi@qq.com");
    		service.update(user);
    	}
    }