Spring 框架的两大核心机制(IoC,AOP)下

最新推荐文章于 2023-12-12 23:18:53 发布

愚笨难解

最新推荐文章于 2023-12-12 23:18:53 发布

阅读量154

点赞数

分类专栏： SpringMVC 文章标签： spring

本文链接：https://blog.csdn.net/suo_jia_hao/article/details/113835779

版权

SpringMVC 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring 框架的两大核心机制(IoC,AOP)

IoC(控制反转) / DI(依赖注入)
AOP(面向切面编程)

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
AOP时面向对象变成的一个补充,在运行时,动态的将代码切入到类的指定方法,指定位置上的编程思想就是面向切面编程,将不同方法的同一个位置抽象成一个切面对象,对该切面对象进行编程就是AOP
在这里插入图片描述

如何使用
创建Maven工程,pom.xml添加依赖

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
    </dependencies>

创建一个计算器接口,Cal,定义4个方法

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);
}

创建接口实现类

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;
    }
}

上述代码中日志信息和业务方逻辑的耦合性很高，使用AOP可以进行优化，把（输出语句全部提取出来），使用动态代理的方式来实现。
给业务代码找一个代理，打印日志信息的工作交给代理来做，这样的话业务代码只需要管制自身的业务即可

package com.southwind.utils;

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

/**MyInvocationHandle不是代理类，是创建代理类的类
 * MyInvocationHandle实现InvocationHandler接口后才拥有创建代理类的功能
 *
 */
public class MyInvocationHandle implements InvocationHandler {
    //object表示委托对象
    private Object object = null;
    //bind方法返回代理对象proxy
    /*newProxyInstance()方法需要三个参数1.类加载器2.委托类的实例对象3.InvocationHandler的实例对象
    1.一个类通过类加载器classLoader被加载到JVM内存中，从而被实例化，通过类的反射可以获得类加载器，
    类加载器是不变的，所以可以通过任意一个类的反射获得类加载器object.getClass().getClassLoader()
    2.动态代理类是只有在调用时才被实例化，但是也要有与委托对象类一样的接口信息，所以如果要使用动态代理
    类，还需要传入委托对象的接口信息,object.getClass().getInterfaces()
    3.InvocationHandler的实例对象就是本类，因为本类就implements了InvocationHandler，所以传入this
    */
    public Object bind(Object object){
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }

    /**处理高耦合的代码段,简化操作
     * cal1.add(1,1)
     * proxy == cal1 || method == add || args == [1,1]
     */
    @Override//         proxy == cal1 || method == add || args == [1,1]
    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);
        System.out.println(method.getName()+"方法的结果是"+result);
        return result;
    }
}

package com.southwind.test;

import com.southwind.utils.Cal;
import com.southwind.utils.MyInvocationHandle;
import com.southwind.utils.impl.CalImpl;

public class Test {
    public static void main(String[] args) {
        //使用代理方法
        Cal cal = new CalImpl();//委托对象cal
        MyInvocationHandle myInvocationHandle = new MyInvocationHandle();
        Cal proxy = (Cal)myInvocationHandle.bind(cal);//通过myInvocationHandle对象的bind方法返回一个代理对象proxy
        proxy.add(1,1);//每次调用方法都会把传参(proxy,add,[1,1])  委托对象proxy,method == add, args == [1,1]
        proxy.sub(2,1);
        proxy.mul(2,3);
        proxy.div(6,2);
    }
}

以上是通过动态代理的方法实现AOP的过程,不好理解,Spring框架对AOP进行了封装,使用Spring框架可以用面向对象的思想实现AOP。

Spring框架总中不需要创建InvocationHandle,只需要创建一个切面,将所有的非业务代码在切面对象中完成即可,Spring框架底层会自动根据切面类以及目标类生成一个代理对象.

LoggerAspect:记录切面类
LoggerAspect类定义处添加的两个注解
@Aspect:表示该类是切面类
@Component:将该类的对象注入到IoC容器中

package com.southwind.aop;

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

import java.util.Arrays;

//@Aspect注解使之成为切面对象
//@Component注解是让IoC管理它的,由spring-context包提供
//LoggerAspect记录切面
@Aspect
@Component
public class LoggerAspect {


    /**在方法执行之前打印参数信息
     * @Before注释:设定下面的before方法是在com.southwind.utils.impl.CalImpl类中的所有方法前适用
     *   通配符*,代表所有的方法,
     *   通配符..,代表参数
     *   joinPoint 连接点,把目标方法的信息抽象成一个连接点对象
     */
    @Before(value = "execution(public int com.southwind.utils.impl.CalImpl*(..))")
    public void before(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        //获取参数,把数组转换成String类型格式[a,b]
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name+"方法的参数是"+ args);
    }

    //方法执行之后,返回结果前
    @After(value = "execution(public int com.southwind.utils.impl.CalImpl*(..))")
    public void after(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature().getName()+"方法的结果是");
    }

    //方法执行并返回结果后
    @AfterReturning(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        //获取⽅法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"⽅法的结果是"+result);
    }
    //异常处理
    @AfterThrowing(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        //获取⽅法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"⽅法抛出异常："+exception);
    }
}

CalImpl业务方法也需要添加@Compoent注解

package com.southwind.utils.impl;

import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;
//CalImpl业务方法也需要添加@Compoent注解
@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;
    }
}

spring.xml中配置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:p="http://www.springframework.org/schema/p"
       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/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
    <!--设置自动扫描,ioc扫描com.southwind包中哪些类有@Compoent注解,该类扫描到IoC容器中,交由IoC管理它的对象-->
    <context:component-scan base-package="com.southwind"></context:component-scan>
    
    <!--使@Aspect注解生效,为目标类自动生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

context:component-scan 将 com.southwind 包中的所有类进⾏扫描，如果该类同时添加了@Component ，则将该类扫描到 IoC 容器中，即 IoC 管理它的对象。
aop:aspectj-autoproxy 让 Spring 框架结合切⾯类和⽬标类⾃动⽣成动态代理对象。

切⾯：横切关注点被模块化的抽象对象。
通知：切⾯对象完成的⼯作。
⽬标：被通知的对象，即被横切的对象。
代理：切⾯、通知、⽬标混合之后的对象。
连接点：通知要插⼊业务代码的具体位置。
切点：AOP 通过切点定位到连接点。

愚笨难解

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 框架的两大核心机制(IoC,AOP)下

Spring 框架的两大核心机制(IoC,AOP)IoC(控制反转) / DI(依赖注入)AOP(面向切面编程)利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率AOP时面向对象变成的一个补充,在运行时,动态的将代码切入到类的指定方法,指定位置上的编程思想就是面向切面编程,将不同方法的同一个位置抽象成一个切面对象,对该切面对象进行编程就是AOP...
复制链接

扫一扫

专栏目录