IOC和AOP

最新推荐文章于 2024-10-07 19:19:53 发布

一条柴_Alex

最新推荐文章于 2024-10-07 19:19:53 发布

阅读量1k

点赞数

分类专栏： # Spring 文章标签： java spring 开发语言

本文链接：https://blog.csdn.net/Alex_cf/article/details/128277195

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1、IOC容器

1、IOC思想：

IOC：Inversion of Control 控制反转

DI：Dependency Injection，翻译过来是依赖注入。

DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器的资源注入。相对于IOC而言，这种表述更直接。所以结论是：IOC 就是一种反转控制的思想，而 DI 是对 IOC 的一种具体实现。

2、IOC容器在spring中的实现

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

①BeanFactory

这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

②ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

3、两种管理bean的方法：

3.1 基于XML 管理bean

1、实战：

2、bean的作用域

3、bean的声明周期

具体生命周期过程

bean对象创建（调用无参构造器）
给bean对象设置属性
bean对象初始化之前操作（由bean的后置处理器负责）
bean对象初始化（需在配置bean时指定初始化方法）
bean对象初始化之后操作（由bean的后置处理器负责）
bean对象就绪可以使用
bean对象销毁（需在配置bean时指定销毁方法）
IOC容器关闭

4、FactoryBean

FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个 FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是 getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

3.2 基于注解管理Bean

2、AOP

1、概述

我们在编写一些模块的时候，经常会遇到一些这样的疑惑

模块本身的功能是明确的
但是还有其他非核心功能(附加)需要在此模块功能上去使用

比如，模块A的功能就是打电话，但是我还希望在打电话的时候，能够计费，计流量，甚至录音，后台日志等其他功能

但是，如果我把这些功能都集中在模块A里，就会出现以下缺陷：

对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
附加功能分散在各个业务功能方法中，不利于统一维护

解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

在说AOP之前，我们先看看什么是代理模式：

2、代理模式

1、简介

①介绍

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

使用代理后：

②生活中的代理

广告商找大明星拍广告需要经过经纪人
合作伙伴找大老板谈合作要约见面时间需要经过秘书
房产中介是买卖双方的代理

③相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。

目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

2、静态代理

Target 目标

StaticProxy 代理类

public class StaticProxy implement Target{

    //将被代理的目标声明成成员变量

    private Target target;

    
     public StaticProxy(Target target){
        
        this.target= target ;  

    }

   

    @Override
    public Object coreMethod(args...){
     
    //代理类的附加功能
    附加功能语句1；


    Object result =  target.coreMethod(args...)

    //代理类的附加功能
        附加功能语句2；

    return result;
    
    }

     

}

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

3、动态代理

生产代理对象的工厂类：

public class ProxyFactory {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
public Object getProxy(){
/**
* newProxyInstance()：创建一个代理实例
* 其中有三个参数：
* 1、classLoader：加载动态生成的代理类的类加载器
* 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
* 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接
口中的抽象方法
*/
ClassLoader classLoader = target.getClass().getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();

InvocationHandler invocationHandler = new InvocationHandler() {

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
/**
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数
*/
Object result = null;

try {
    System.out.println("[动态代理][日志] "+method.getName()+"，参
    数："+ Arrays.toString(args));

    result = method.invoke(target, args);

    System.out.println("[动态代理][日志] "+method.getName()+"，结
    果："+ result);

      } catch (Exception e) {
        e.printStackTrace();
        System.out.println("[动态代理][日志] "+method.getName()+"，异
        常："+e.getMessage());
                } finally {
        System.out.println("[动态代理][日志] "+method.getName()+"，方法
        执行完毕");
            }
    return result;
        }
    };
return Proxy.newProxyInstance(classLoader, interfaces,invocationHandler);
    }
}

3、AOP概念及相关术语

1、概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

2、相关术语

①横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

②通知

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

前置通知：在被代理的目标方法前执行
返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
异常通知：在被代理的目标方法异常结束后执行（死于非命）
后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

③切面

封装通知方法的类。

④目标

被代理的目标对象。

⑤代理

向目标对象应用通知之后创建的代理对象。

⑥连接点

这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

⑦切入点

定位连接点的方式。每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。 Spring 的 AOP 技术可以通过切入点定位到特定的连接点。切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

3、作用

简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

4、基于注解的AOP

1、说明

动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。

2、准备工作

1)、导入相关的依赖

2 ) 准备被代理的目标资源

接口

public interface Target{
  
    Object coremethodA(args);

    Object coremethodB(args);
}

实现类

@Component
pubclic class TartgetImpl implements Target{


    @Override
    public Object coremethodA(args){

        //TODO
        
        return resultA;

       }

    


    @Override
    Object coremethodB(args){

           //TODO

        return resultB;

    }

}

3、创建切面类并配置

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class MyAspect {


    @Before("execution(public int com.alex.aop.TargetImpl.*
    (..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println("MyAspect -->前置通知，方法名："+methodName+"，参
        数："+args);
    }



    @After("execution(* com.alex.aop.TargetImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("MyAspect -->后置通知，方法名："+methodName);
    }

    

    @AfterReturning(value = "execution(* com.alex.aop.TargetImp.*(..))", returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("MyAspect -->返回通知，方法名："+methodName+"，结
        果："+result);
    }

    @AfterThrowing(value = "execution(* com.alex.aop.TargetImp.*(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("MyAspect -->异常通知，方法名："+methodName+"，异常："+ex);
    }
    


    @Around("execution(* com.alex.aop.TargetImp.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){

          String methodName = joinPoint.getSignature().getName();
          String args = Arrays.toString(joinPoint.getArgs());
            Object result = null;
    try {
        System.out.println("环绕通知-->目标对象方法执行之前");
        //目标对象（连接点）方法的执行
        result = joinPoint.proceed();
        System.out.println("环绕通知-->目标对象方法返回值之后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->目标对象方法出现异常时");
        } finally {
            System.out.println("环绕通知-->目标对象方法执行完毕");
        }

            return result;
        }

}