Spring AOP编程的半自动和全自动编写代理

左手的ㄟ右手 2022-02-05 00:21 147阅读 0赞

### 文章目录 ###

*   *  Spring AOP编程的半自动和全自动编写代理
     *   *  Spring编写代理：半自动
         *   *  AOP联盟通知类型
             *  环绕通知
         *  Spring编写代理：全自动

## Spring AOP编程的半自动和全自动编写代理 ##

### Spring编写代理：半自动 ###

*  让spring 创建代理对象，从spring容器中手动的获取**代理对象**。注意：这里从Spring中获取到的是代理对象，而不是目标类对象

#### AOP联盟通知类型 ####

*  AOP联盟为通知Advice定义了org.aopalliance.aop.Advice
 *  Spring按照通知Advice在目标类方法的连接点位置，可以分为5类
    
     *  前置通知 org.springframework.aop.MethodBeforeAdvice
        
         *  在目标方法执行前实施增强
     *  后置通知 org.springframework.aop.AfterReturningAdvice
        
         *  在目标方法执行后实施增强
     *  环绕通知 org.aopalliance.intercept.MethodInterceptor(功能最强，可以实现其他类型的通知)
        
         *  在目标方法执行前后实施增强
     *  异常抛出通知 org.springframework.aop.ThrowsAdvice
        
         *  在方法抛出异常后实施增强
     *  引介通知 org.springframework.aop.IntroductionInterceptor
        
         *  在目标类中添加一些新的方法和属性

环绕通知，必须手动执行目标方法
    try{
       //前置通知
       //执行目标方法
       //后置通知
    } catch(){
       //抛出异常通知
    }

#### 环绕通知 ####

我们重点来实现环绕通知，因为它的功能最强大

*  编写目标类  
    首先我们需要编写目标类

public interface UserService {
    
        public void addUser();
    	public void updateUser();
    	public void deleteUser();
    }

public class UserServiceImpl implements UserService {
        @Override
        public void addUser() {
            System.out.println("addUser()");
        }
    
        @Override
        public void updateUser() {
            System.out.println("updateUser()");
        }
    
        @Override
        public void deleteUser() {
            System.out.println("deleteUser()");
        }
    }

然后我们需要添加配置

然后进行测试看看

@Test
        public void demo01(){
            String xmlPath = "spring_aop_proxy.xml";
            AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("userServiceId");
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }

![在这里插入图片描述][20190504003004927.png]

*  编写切面类  
    用于存放通知（也就是存放增强的代码）

/**
     * 切面类中确定通知，需要实现不同接口，接口就是规范，从而就确定方法名称。
     * * 采用“环绕通知” MethodInterceptor
     */
    public class MyAspect implements MethodInterceptor {
    
    	@Override
        public Object invoke(MethodInvocation mi) throws Throwable {
    		
    		System.out.println("before");
    		
    		//手动执行目标方法
    		Object obj = mi.proceed();
    		
    		System.out.println("after");
    		return obj;
    	}
    }

配置文件中添加切面类配置

*  创建代理类  
    之前我们用JDK动态代理还有CGLIB都是使用创建一个工厂类来返回代理。  
    现在我们把创建一个工厂类来返回代理过程交给spring  
    所以我们只需要添加一下Spring的配置，但是我们在Spring配置中配置这一个工厂类ProxyFactoryBean。所以这也就是为什么叫做半自动。

<beans xmlns="http://www.springframework.org/schema/beans"
           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
           					   ">
    
        
        <bean id="userServiceId" class="com.cc.study.aop_proxy.UserServiceImpl"></bean>
        
        <bean id="myAspectId" class="com.cc.study.aop_proxy.MyAspect"></bean>
        
        <bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="interfaces" value="com.cc.study.aop_proxy.UserService"></property>
            <property name="target" ref="userServiceId"></property>
            <property name="interceptorNames" value="myAspectId"></property>
        </bean>
    
    </beans>

测试类

@Test
        public void demo02(){
            String xmlPath = "spring_aop_proxy.xml";
            AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }

这里我们需要拿到代理类，然后调用它的方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]

### Spring编写代理：全自动 ###

*  从spring容器获得目标类，与半自动不同的是，这里从Spring获取到的是目标类。如果配置AOP，spring将自动生成代理。

我们首先要做的就是添加pom的依赖，添加spring aop的依赖还有aspectjweaver的依赖(用于确定目标类，aspectj 切入点表达式)

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.3</version>
            </dependency>

然后我们要做的就是配置需要导入Spring AOP的命名空间  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]

然后我们还是需编写目标类还有切面类，都跟半自动的一样，这里就不写了，配置上也是需要加上的。不同的点在于最后创建代理对象的时候，是交给Spring帮我们自动生成代理，所以我们主要就是需要在配置中加入Spring AOP的配置。

<?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"
           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 id="userServiceId" class="com.cc.study.aop_proxy.UserServiceImpl"></bean>
        
        <bean id="myAspectId" class="com.cc.study.aop_proxy.MyAspect"></bean>
        
        <aop:config proxy-target-class="true">
            <aop:pointcut expression="execution(* com.cc.study.aop_proxy.*.*(..))" id="myPointCut"/>
            <aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
        </aop:config>
    </beans>

然后就是测试

@Test
        public void demo03(){
            String xmlPath = "spring_aop_proxy2.xml";
            AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("userServiceId");
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }

可以看到我们这里直接获取的是目标类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]

[20190504003004927.png]: /images/20220205/b1825feb2db547faaf87a6675ec69f70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]: /images/20220205/63dccf724137409d98fb71326ef02ee4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]: /images/20220205/a5bead377b1442c080b33deec561c736.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]: /images/20220205/d086ebd670ce42ae85b1fa72756af6cc.png