学习Spring(4)AOP

分手后的思念是犯贱 2022-10-19 05:31 37阅读 0赞

# Spring AOP #

## AOP ##

### 代理模式 ###

#### 静态代理 ####

目录结构：

*  staticAgent
    
     *  Rent.java(接口，核心功能)
     *  Landlady.java
     *  Lntermediary.java
     *  AgentTest.java(测试代码)

Rent.java：

package staticAgent;
    // 租房，核心功能
    public interface Rent { 
        void rent();
    }

Landlady.java：

package staticAgent;
    // 房东
    public class Landlady implements Rent{ 
        @Override
        public void rent() { 
         System.out.println("租房");
        }
    }

Lntermediary.java：

package staticAgent;
    // 中介
    public class Lntermediary implements Rent{ 
        // 代理房东租房子
        Landlady landlady;
        public Lntermediary(Landlady newlandlady) { 
            this.landlady = newlandlady;
        }
        @Override
        public void rent() { 
            seeHouse();
            this.landlady.rent();
            signContract();
        }
        // 除了租房子这个核心功能，还有其它附属的功能
        public void seeHouse(){ 
            System.out.println("看房子");
        }
        public void signContract(){ 
            System.out.println("签合同");
        }
    }

AgentTest.java：

package staticAgent;
    import org.testng.annotations.Test;
    public class AgentTest {
        @Test
        public static void test() {
            Landlady landlady = new Landlady();
            Lntermediary nd = new Lntermediary(landlady);
            // 中介代理房东租房
            nd.rent();
        }
    }

代理模式包含如下角色：

*  subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口，相当于核心功能；
 *  RealSubject：真实主题角色，是实现抽象主题接口的类;
 *  Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象；

代理模式就是在引用对象时引入一些间接性，就是不直接的调用对象的方法，而是通过代理来调用，这样，我们添加一些公用的方法就能直接加在代理中

静态代理的缺点就是，一个真是主题角色就需要一个代理角色，这就很繁琐了

不改动原有业务逻辑新加功能的方式就是新加一层，原来直接调用方法的程序不会影响，自己调用新的一层也不会有问题

interface A{ 
        add();
        update();
        query();
    }
    
    // A的实现类
    class Aclass implements A{ 
        add(){ };
        update(){ };
        query(){ };
    }
    
    // 别人原来的调用方式
    Aclass a = new Aclass();
    a.add();
    
    // 现在需要给A接口中每个方法添加自己的日志
    // 不要直接去改A接口的代码，如果A接口有几十个方法需要修改，你不能保证能测试到所有调用这里的代码，特别是老的代码
    
    // 解决方法是增加一层：
    // 和实现类一样实现接口
    class Aproxy implements A{ 
        Aclass aclass;
        // set方法引入实现类
        setAclass(Aclass newa){ 
            this.aclass = newa;
        }
        // 实现接口的方法
        add(){ 
            // 加入新的方法
           log();
           // 调用实现类的接口实现方法
           aclass.add();
        };
        update(){ 
            log();
            aclass.update();
        };
        query(){ 
            log();
            aclass.query();
        };
        log(){ };
    }
    
    // 新的调用方式
    Aproxy ap = new Aproxy();
    Aclass a = new Aclass();
    ap.set(a);
    ap.add();
    
    // 这样旧代码的调用方式兼容，新代码的调用也兼容，之前的直接修改如果出问题是会让程序直接报错，而现在的方式，如果有老的代码没修改至少不会报错，只是没有新功能

#### 动态代理 ####

通过反射来动态创建对应的类，再执行这个类的对应方法

还是因之前的目录：

*  staticAgent
    
     *  Rent.java(接口，核心功能)
     *  Landlady.java
     *  Lntermediary.java
     *  AgentTest.java(测试代码)
     *  dynamicAgent.java(动态代理类)

dynamicAgent.java：

public class dynamicAgent<T> implements InvocationHandler { 
        // 接口实现类实例，如果不使用泛型，这里可以直接用Object
        T rent;
        void setObject(T obj){ 
            this.rent = obj;
        }
        // 生成代码类
        public Object getProxy(){ 
            // 第一个参数是代理类的类加载器，第二个参数是代理类要实现的接口，第三个参数是处理接口方法的程序
            // 这里代理类是自己，所以直接this，getClass().getClassLoader()是获取加载器
            // getClass().getInterfaces() 是获取实现类的接口
            // 因为invoke()就是执行方法，所以第三个参数也是本身this
            return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
        }
        // 处理代理实例，并返回执行结果
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            // 动态代理本质就是通过反射实现，这里就是执行这个对象的方法
            seeHouse();
            Object result = method.invoke(rent, args);
            signContract();
            return result;
        }
        // 除了租房子这个核心功能，还有其它附属的功能
        public void seeHouse(){ 
            System.out.println("看房子");
        }
        public void signContract(){ 
            System.out.println("签合同");
        }
    }

修改测试代码AgentTest.java：

public class AgentTest { 
        @Test
        public static void test() { 
            // 真实代理角色，房东
            Landlady landlady = new Landlady();
            //创建一个与代理对象相关联的InvocationHandler实现类
            dynamicAgent<Rent> nd = new dynamicAgent<Rent>();
            nd.setObject(landlady);
            // 获取代理对象
            Rent zj = (Rent) nd.getProxy();
            // 代理对象执行方法
            zj.rent();
        }
    }

执行结果是和静态代理是一样的

动态代理两个类：

*  Proxy(类) 生成代理类
 *  InvocationHandler(接口) 执行方法并返回结果

动态代理好处，一个动态代理类代理一个接口，相当于代理一个业务，一个代理类可以代理实现接口的所有类

### AOP ###

#### 第一种方式：实现Spring前后置通知等的接口： ####

maven中需要添加jar包：  
pom.xml中添加：

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>

目录结构:

*  java
    
     *  com.test
        
         *  log
            
             *  Log.java(前置通知)
             *  AfterLog.java(后置通知)
         *  service
            
             *  UserService.java(接口)
             *  UserServiceImpl.java
 *  test
    
     *  java
        
         *  MyTest.java(测试类)
 *  resources
    
     *  applicationContext02.xml(配置文件)

流程：

1.  写服务接口
2.  服务实现类
3.  前后通知类编写，实现 MethodBeforeAdvice 和 AfterReturningAdvice 接口
4.  编写applicationContext.xml配置bean和切入点

UserService.java(服务接口)：

package com.test.service;
    public interface UserService { 
        void add();
        void delete();
        void update();
        void select();
    }

UserServiceImpl.java(实现服务接口)：

package com.test.service;
    public class UserServiceImpl implements UserService{ 
        @Override
        public void add() { 
            System.out.println("这是新增！");
        }
        @Override
        public void delete() { 
            System.out.println("这是删除！");
        }
        @Override
        public void update() { 
            System.out.println("这是更新！");
        }
        @Override
        public void select() { 
            System.out.println("这是查询！");
        }
    }

Log.java(实现MethodBeforeAdvice接口的前置通知类)：

package com.test.log;
    import org.springframework.aop.MethodBeforeAdvice;
    import java.lang.reflect.Method;
    // MethodBeforeAdvice 前置通知接口，在方法前添加功能
    // MethodBeforeAdvice 整个过程大致就是使用的jdk提供的动态代理的接口InvocationHandler和Proxy
    public class Log implements MethodBeforeAdvice { 
        // before()，第一个参数是需要执行的方法，第二参数是方法参数，第三个是目标对象
        // before()会在方法执行之前执行
        @Override
        public void before(Method method, Object[] objects, Object o) throws Throwable { 
            System.out.println("前置通知："+o.getClass().getName()+"执行了"+method.getName()+"方法");
        }
    }

AfterLog.java(实现AfterReturningAdvice接口的后置通知类)：

package com.test.log;
    import org.springframework.aop.AfterReturningAdvice;
    import java.lang.reflect.Method;
    // AfterReturningAdvice 后置通知接口，在方法之后添加功能
    // 这里也是一个动态代理的实现
    public class AfterLog implements AfterReturningAdvice { 
        // afterReturning()，第一个参数是执行方法返回的结果，第二个参数是执行的方法，第三个参数是方法参数，第三个是目标对象
        @Override
        public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable { 
            System.out.println("后置通知：执行了"+method.getName()+"方法，方法返回结果为："+o);
        }
    }

applicationContext02.xml(配置文件，配置bean和切入点)：

<?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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="userService" class="com.test.service.UserServiceImpl"/>
        <bean id="log" class="com.test.log.Log" />
        <bean id="afterLog" class="com.test.log.AfterLog" />
        
        
        <aop:config>
            
            
            <aop:pointcut id="mypointcut" expression="execution(* com.test.service.UserServiceImpl.*(..)))"/>
            
            
            <aop:advisor advice-ref="log" pointcut-ref="mypointcut"/>
            <aop:advisor advice-ref="afterLog" pointcut-ref="mypointcut"/>
        </aop:config>
    </beans>

MyTest.java(测试类)：

import com.test.service.UserService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.testng.annotations.Test;
    public class MyTest { 
        @Test
        public void test(){ 
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext02.xml");
            // 动态代理的是接口
            UserService usi = applicationContext.getBean("userService", UserService.class);
            usi.add();
        }
    }

结果：

前置通知：com.test.service.UserServiceImpl执行了add方法
    这是新增！
    后置通知：执行了add方法，方法返回结果为：null

#### 自定义实现AOP，切面实现： ####

目录结构:

*  java
    
     *  com.test
        
         *  diyClass
            
             *  DiyPointcut.java(自定义类)
         *  service
            
             *  UserService.java(接口)
             *  UserServiceImpl.java
 *  test
    
     *  java
        
         *  MyTest.java(测试类)
 *  resources
    
     *  applicationContext02.xml(配置文件)

流程：

1.  写服务接口
2.  服务实现类
3.  写一个自定义的类，前后通知等设置为方法
4.  编写applicationContext.xml配置bean和切面，切入点

DiyPointcut.java自定义类，添加前后置通知方法：

package com.test.diyClass;
    public class DiyPointcut { 
        public void before(){ 
            System.out.println("这是前置通知");
        }
        public void after(){ 
            System.out.println("这是后置通知");
        }
    }

applicationContext02.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/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="userService" class="com.test.service.UserServiceImpl"/>
        
        
        <bean id="diyclass" class="com.test.diyClass.DiyPointcut" />
        
        <aop:config>
            
            <aop:aspect ref="diyclass">
                
                <aop:pointcut id="mypointcut" expression="execution(* com.test.service.UserServiceImpl.*(..)))"/>
                
                <aop:before method="before" pointcut-ref="mypointcut"/>
                
                <aop:after method="after" pointcut-ref="mypointcut" />
            </aop:aspect>
        </aop:config>
    </beans>

运行测试代码，结果：

这是前置通知
    这是新增！
    这是后置通知

#### 使用注解实现AOP： ####

目录结构:

*  java
    
     *  com.test
        
         *  diyClass
            
             *  AnnotationPointcut.java(切面类)
         *  service
            
             *  UserService.java(接口)
             *  UserServiceImpl.java
 *  test
    
     *  java
        
         *  MyTest.java(测试类)
 *  resources
    
     *  applicationContext02.xml(配置文件)

流程：

1.  写服务接口
2.  服务实现类
3.  写一个用@Aspect修饰的切面类，用 @Before，@After修饰前后通知的方法
4.  编写applicationContext.xml配置bean和< aop:aspectj-autoproxy />开启注解支持

AnnotationPointcut.java，切面类编写：

package com.test.diyClass;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    // 第三种方式：注解方式实现AOP
    // @Aspect 将类定义为切面
    @Aspect
    public class AnnotationPointcut { 
        // @Before(使用范围)，修饰前置通知方法
        @Before("execution(* com.test.service.UserServiceImpl.*(..)))")
        public void before(){ 
            System.out.println("这是注解实现的前置通知");
        }
        // @After(使用范围)，修饰后置通知方法
        @After("execution(* com.test.service.UserServiceImpl.*(..)))")
        public void after(){ 
            System.out.println("这是注解实现的后置通知");
        }
    }

applicationContext02.xml：

执行测试类的结果：

这是注解实现的前置通知
    这是新增！
    这是注解实现的后置通知