Java SpringAOP面向切面编程的实现方法

喜欢ヅ旅行 2022-12-04 05:28 174阅读 0赞

### 文章目录 ###

*  AOP面向切面编程
 *  方法一：使用spring接口【springAPI接口实现】
 *   *  业务接口和实现类
     *  增强类
     *  spring中注册
     *  测试类
 *  方法二：自定义来实现AOP【主要是切面自定义】
 *   *  自定义切入类
     *  测试：
 *  方法三：注解方式

# AOP面向切面编程 #

AOP为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

*  切面（ASPECT）：横切关注点 被模块化的特殊对象。它是一个类。
 *  通知（Advice）：切面必须要完成的工作。它是类中的一个方法。
 *  目标（Target）：被通知对象。
 *  代理（Proxy）：向目标对象应用通知之后创建的对象。
 *  切入点（PointCut）：切面通知 执行的 “地点”的定义。
 *  连接点（JointPoint）：与切入点匹配的执行点。

使用的依赖：

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

# 方法一：使用spring接口【springAPI接口实现】 #

## 业务接口和实现类 ##

public interface UserService { 
    
       public void add();
    
       public void delete();
    
       public void update();
    
       public void search();
    
    }

public class UserServiceImp implements UserService { 
    
        public void add() { 
            System.out.println("add");
        }
    
        public void delete() { 
            System.out.println("delete");
        }
    
        public void query() { 
            System.out.println("query");
        }
    
        public void update() { 
            System.out.println("update");
        }
    }

## 增强类 ##

我们编写两个 , 一个前置增强 一个后置增强

import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    
    public class Log implements MethodBeforeAdvice { 
        //method：要执行的目标对象的方法
        //args：参数
        //target：目标对象
        public void before(Method method, Object[] args, Object target) throws Throwable { 
            System.out.println(target.getClass().getName()+method.getName());
        }
    }

public class AfterLog implements AfterReturningAdvice { 
        //returnVaule: 返回值
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { 
            System.out.println(method.getName()+returnValue);
        }
    }

## spring中注册 ##

<?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/beanss https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <bean id="userservice" class="com.service.UserServiceImp"></bean>
        <bean id="log" class="com.log.Log"/>
        <bean id="afterlog" class="com.log.AfterLog"/>
    
        
        <aop:config>
            
            <aop:pointcut id="point" expression="execution(* com.service.UserServiceImp.*(..))"/>
            
            <aop:advisor advice-ref="log" pointcut-ref="point"/>
            <aop:advisor advice-ref="afterlog" pointcut-ref="point"/>
        </aop:config>
    
    </beans>

## 测试类 ##

public class Mytest { 
        public static void main(String[] args) { 
            ApplicationContext context = new ClassPathXmlApplicationContext("ApplcationContext.xml");
            //动态代理代理的是接口
            UserService userService = (UserService) context.getBean("userservice");
            userService.add();
        }
    }

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来。实现公共业务的重复利用 。  
领域业务更纯粹 , 其本质还是动态代理 。

# 方法二：自定义来实现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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <bean id="userservice" class="com.service.UserServiceImp"></bean>
        <bean id="log" class="com.log.Log"/>
        <bean id="afterlog" class="com.log.AfterLog"/>
    
        <bean id="diy" class="com.diy.DiyPointcut">
        </bean>
        <aop:config>
            
            <aop:aspect ref="diy">
                
                <aop:pointcut id="point" expression="execution(* com.service.UserServiceImp.*(..))"/>
                <aop:before method="before" pointcut-ref="point"/>
                <aop:after method="after" pointcut-ref="point"/>
            </aop:aspect>
        </aop:config>
    
    </beans>

## 自定义切入类 ##

public class DiyPointcut { 
    
        public void before(){ 
            System.out.println("before方法执行前");
        }
    
        public void after(){ 
            System.out.println("after方法执行后");
        }
    }

## 测试： ##

public class MyTest { 
       @Test
       public void test(){ 
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           UserService userService = (UserService) context.getBean("userService");
           userService.add();
      }
    }

# 方法三：注解方式 #

import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    @Aspect  //标注这个类是一个切面
    public class Annotation { 
    
        @Before("execution(* com.service.UserServiceImp.*(..))")
        public void before(){ 
            System.out.println("before方法执行前");
        }
    
        @After("execution(* com.service.UserServiceImp.*(..))")
        public void after(){ 
            System.out.println("after方法执行后");
        }
    
        //在环绕增强中，我们可以给地暖管一个参数，代表我们要获取切入的点
        @Around("execution(* com.service.UserServiceImp.*(..))")
        public void around(ProceedingJoinPoint joinPoint) throws Throwable { 
            System.out.println("around");
    
            Object proceed = joinPoint.proceed();
    
            System.out.println("after around");
        }
    }

aop:aspectj-autoproxy：说明
    
    通过aop命名空间的<aop:aspectj-autoproxy />
    声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。
    当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，
    但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
    
    <aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，
    表示使用jdk动态代理织入增强，
    当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，
    表示使用CGLib动态代理技术织入增强。
    不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。