Spring基础之AOP

最新推荐文章于 2023-08-25 14:53:49 发布

盛者无名

最新推荐文章于 2023-08-25 14:53:49 发布

阅读量339

点赞数

分类专栏：编程 Java 文章标签： java spring

本文链接：https://blog.csdn.net/weixin_41489136/article/details/127837009

版权

编程同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

Java

18 篇文章 1 订阅

订阅专栏

AOP(Aspect Oriented Programming)面向切面编程
OOP(Object Oriented Programming)面向对象编程，用对象化的思想来完成程序
AOP是OOP的一个补充，是在另一个维度上抽象出对象
具体是指程序运行时动态的将非业务代码切入到业务代码中，从而实现程序的解耦合，将非业务代码抽象成一个对象，对该对象编程就是面向切面编程。

AOP的优点：

可以降低模块之间的耦合性
提高代码的复用性
提高代码的维护性
集中管理非业务代码、便于维护
业务代码不受非业务代码的影响，逻辑更加清晰

一个简单的例子：

在不进行松耦合的情况下，业务代码与非业务代码高度耦合在一起：
接口Cal

public interface Cal {
    public int add(int num1,int num2);
    public int sub(int num1,int num2);
    public int mul(int num1,int num2);
    public int div(int num1,int num2);
}

实现类CalImpl

import com.test.Cal;

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法的参数是："+num1+","+num2);
        int result=num1+num2;
        System.out.println("add方法的结果是："+result);
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是："+num1+","+num2);
        int result=num1-num2;
        System.out.println("sub方法的结果是："+result);
        return result;

    }

    @Override
    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是："+num1+","+num2);
        int result=num1*num2;
        System.out.println("mul方法的结果是："+result);
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        System.out.println("div方法的参数是："+num1+","+num2);
        int result=num1/num2;
        System.out.println("div方法的记过是："+result);
        return result;
    }
}

主类

public class Main {
    public static void main(String[] args) {
        Cal cal=new CalImpl();
        cal.add(10,3);
    }
}

以Java动态代理的方法进行松耦合：

原接口类和接口不变，实现类仅保留耦合前的代码

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        int result=num1+num2;
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        int result=num1-num2;
        return result;

    }

    @Override
    public int mul(int num1, int num2) {
        int result=num1*num2;
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        int result=num1/num2;
        return result;
    }
}

创建一个代理类MyInvocationHandler：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MyInvocationHandler implements InvocationHandler {
    //委托对象
    private Object object=null;
    //返回代理对象
    public Object bind(Object object){
        this.object=object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //实现业务代码和非业务代码的解耦合
        System.out.println(method.getName()+"方法的参数是："+ Arrays.toString(args));
        Object result=method.invoke(this.object,args);
        return result;
    }
}

主类：

public class Main {
    public static void main(String[] args) {
        //实例化委托对象
        Cal cal=new CalImpl();
        //获取代理对象
        MyInvocationHandler myInvocationHandler=new MyInvocationHandler();
        Cal proxy=(Cal)myInvocationHandler.bind(cal);
        proxy.add(10,3);
        proxy.sub(10,3);
        proxy.mul(10,3);
        proxy.div(10,3);
    }
}

代码达到松耦合的目的，运行后可以得到相同的结果

Spring中松耦合的实现：

在maven的pom.xml文件中加入依赖

    <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.9.RELEASE</version>
    </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
    </dependencies>

spring.xml的bean文件中加入aop组件及自动扫包，aop:aspectj-autoproxy，Spring IoC容器会结合切面对象自动生成代理对象，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:context="http://www.springframework.org/schema/context"
       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/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.test"/>
    <aop:aspectj-autoproxy/>
</beans>

创建切面接入的类LoggerAspect

@Aspect注解表示该类为切面类
@Before表示方法的执行时机是在业务方法之前
execution表达式表示的是切入点是CalImpl类中的所有方法
@After表示方法的执行时机是在业务方法执行之后
@AfterReturning表示方法的执行时机是在业务方法返回结果之后，returning是将业务方法返回值与切面方法的形参进行绑定
@AfterThrowing表示方法的执行时机是在业务方法抛出异常之后，throwing是将业务方法的异常与切面类方法的形参进行绑定

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class LoggerAspect {
    @Before("execution(public int com.test.Impl.CalImpl.*(..))")
    public void before(JoinPoint joinPoint)
    {
        String name=joinPoint.getSignature().getName();
        String args= Arrays.toString(joinPoint.getArgs());
        System.out.println(name+"方法的参数是："+args);
    }
    @After("execution(public int com.test.Impl.CalImpl.*(..))")
    public void after(JoinPoint joinPoint){
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完毕");
    }
    @AfterReturning(value="execution(public int com.test.Impl.CalImpl.*(..))",returning = "result")
    public void afterReturn(JoinPoint joinPoint,Object result)
    {
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"方法的结果是"+result);
    }
    @AfterThrowing(value = "execution(public int com.test.Impl.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"方法抛出异常"+exception);
    }
}

原接口类和接口不变，实现类加@Component

import org.springframework.stereotype.Component;

@Component
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        int result=num1+num2;
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        int result=num1-num2;
        return result;

    }

    @Override
    public int mul(int num1, int num2) {
        int result=num1*num2;
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        int result=num1/num2;
        return result;
    }
}

主类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        Cal cal=(Cal)applicationContext.getBean(Cal.class);
        cal.add(10,3);
        cal.sub(10,3);
        cal.mul(10,3);
        cal.div(10,3);
        cal.div(10,0);
    }
}