Spring高手之路22——AOP切面类的封装与解析

简介: 本篇文章深入解析了Spring AOP的工作机制,包括Advisor和TargetSource的构建与作用。通过详尽的源码分析和实际案例,帮助开发者全面理解AOP的核心技术,提升在实际项目中的应用能力。

1. AOP是如何收集切面类并封装的?

Spring 中,AOPAspect-Oriented Programming,面向切面编程)通过以下几个步骤收集切面类并进行封装:

1. 定义切面类:

  • 切面类通过 @Aspect 注解来标记,表示这是一个切面。
  • 在切面类中定义通知(advice),例如 @Before@After@Around 等,用于指定在目标方法执行的不同阶段要执行的逻辑。

2. 配置切面扫描:

  • Spring 容器在启动时,会根据配置或注解扫描包路径,寻找带有 @Aspect 注解的类。
  • 通过在配置类上添加 @EnableAspectJAutoProxy 注解启用 AOP 自动代理机制。

3. 解析切面类:

  • Spring 使用 AspectJAnnotationAutoProxyCreator 或类似的类来扫描和解析 @Aspect 注解的类。
  • 在解析过程中,Spring 通过反射机制查找切面类中定义的通知方法,并解析这些方法上面的注解,例如 @Before@After 等。

4. 创建切面和通知对象:

  • 解析切面类后,Spring 会为每个切面创建 AspectMetadata 对象,并将这些元数据保存在 AdvisedSupport 类中。
  • AdvisedSupport 持有目标对象(被代理的类)和通知(advice)列表。

5. 织入切面:

  • Spring 容器创建 bean 的过程中,如果发现某个 bean 需要 AOP 功能,Spring 会为其创建代理对象。
  • Spring 使用 ProxyFactory 或类似的工厂类,根据目标对象和通知列表创建代理对象。
  • 代理对象会将通知逻辑织入到目标方法的调用链中。

6. 执行代理逻辑:

  • 当客户端代码调用代理对象的方法时,代理对象会首先执行切面中的通知逻辑,然后再调用目标方法。
  • 例如,在 @Around 通知中,可以在目标方法执行前后执行额外的逻辑,或者在 @Before 通知中执行方法前的逻辑。

具体的执行流程如下图所示:

定义切面类:

@Aspect
@Component
public class LoggingAspect {
   
   

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
   
   
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
   
   
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

配置切面扫描:

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
   
   
    // other bean definitions
}

  通过以上步骤,Spring AOP 机制能够自动收集、解析和织入切面类,实现面向切面编程的功能。这种机制在保持业务逻辑和横切关注点分离的同时,也提升了代码的可读性和可维护性。

2. Advisor 是什么,它是怎么构建的?

2.1 什么是 Advisor

  在 Spring AOP 中,Advisor 是包含 AdvicePointcut 的一个概念。Advice 是要执行的具体动作(如方法前、后或环绕方法),而 Pointcut 是定义哪些连接点应该应用这些 Advice 的规则。

2.2 Advisor 的构建(源码分析+时序图说明)

本节源码基于 spring-aop-5.3.16

  在 Spring AOP 中,Advisor 的构建是通过 AspectJAdvisorFactory 来实现的。ReflectiveAspectJAdvisorFactoryAspectJAdvisorFactory 的一个具体实现。

来看看ReflectiveAspectJAdvisorFactorygetAdvisors 方法:

在这里插入图片描述

源码提出来分析:

/**
 * 从给定的 MetadataAwareAspectInstanceFactory 获取所有的 Advisor。
 * 这个方法会处理切面类的方法和字段,创建相应的 Advisor 列表。
 *
 * @param aspectInstanceFactory MetadataAwareAspectInstanceFactory 实例,用于获取切面元数据和实例
 * @return 包含所有 Advisor 的列表
 */
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
   
   
    // 获取切面类的元数据
    Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    // 获取切面类的名称
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    // 验证切面类是否合法
    validate(aspectClass);

    // 我们需要用一个装饰器包装 MetadataAwareAspectInstanceFactory,以便它只实例化一次
    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
            new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

    // 创建一个保存 Advisor 的列表
    List<Advisor> advisors = new ArrayList<>();
    // 遍历切面类的方法,获取所有符合条件的 Advisor 方法
    for (Method method : getAdvisorMethods(aspectClass)) {
   
   
        // 在 Spring Framework 5.2.7 之前,advisors.size() 被作为 declarationOrderInAspect
        // 提供给 getAdvisor(...) 以表示在已声明方法列表中的“当前位置”。
        // 然而,自 Java 7 以来,“当前位置”已不再有效,因为 JDK 不再按源代码中声明的顺序返回声明的方法。
        // 因此,我们现在将 declarationOrderInAspect 硬编码为 0,以便通过反射发现的所有通知方法,
        // 以支持 JVM 启动期间的可靠通知排序。
        // 具体来说,值 0 与 AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor) 中使用的默认值对齐。
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        if (advisor != null) {
   
   
            // 将 Advisor 添加到列表中
            advisors.add(advisor);
        }
    }

    // 如果它是每个目标实例化的切面,则发出虚拟实例化的切面
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
   
   
        // 创建并添加一个合成的实例化 Advisor 到列表的开头
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    // 查找引入字段
    for (Field field : aspectClass.getDeclaredFields()) {
   
   
        // 获取 DeclareParents 的 Advisor
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
   
   
            // 将 Advisor 添加到列表中
            advisors.add(advisor);
        }
    }

    // 返回所有的 Advisor
    return advisors;
}

/**
 * 从给定的方法和切面实例工厂获取一个 Advisor。
 * 这个方法会处理切面类的方法并创建相应的 Advisor。
 *
 * @param candidateAdviceMethod 候选的通知方法
 * @param aspectInstanceFactory MetadataAwareAspectInstanceFactory 实例,用于获取切面元数据和实例
 * @param declarationOrderInAspect 在切面中的声明顺序
 * @param aspectName 切面名称
 * @return 对应的 Advisor,如果方法没有对应的 Pointcut 则返回 null
 */
@Override
@Nullable
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                          int declarationOrderInAspect, String aspectName) {
   
   
    // 验证切面类是否合法
    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

    // 获取 Pointcut
    AspectJExpressionPointcut expressionPointcut = getPointcut(
            candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
   
   
        // 如果没有对应的 Pointcut,则返回 null
        return null;
    }

    // 创建并返回 InstantiationModelAwarePointcutAdvisorImpl
    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
            this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

/**
 * 获取给定方法的 Pointcut。
 *
 * @param candidateAdviceMethod 候选的通知方法
 * @param candidateAspectClass 候选的切面类
 * @return 对应的 AspectJExpressionPointcut,如果方法没有对应的 AspectJ 注解则返回 null
 */
@Nullable
private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
   
   
    // 查找方法上的 AspectJ 注解
    AspectJAnnotation<?> aspectJAnnotation =
            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
   
   
        // 如果方法没有对应的 AspectJ 注解,则返回 null
        return null;
    }

    // 创建 AspectJExpressionPointcut
    AspectJExpressionPointcut ajexp =
            new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
    // 设置 Pointcut 表达式
    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    if (this.beanFactory != null) {
   
   
        // 如果 beanFactory 不为空,则设置 beanFactory
        ajexp.setBeanFactory(this.beanFactory);
    }
    // 返回 AspectJExpressionPointcut
    return ajexp;
}

这些源码的关键总结如下:

一. 获取所有 Advisor (getAdvisors 方法)
1. 提取切面元数据:

  • 获取切面类和切面名称,这些信息是从 MetadataAwareAspectInstanceFactory 中提取的。

2. 装饰工厂:

  • LazySingletonAspectInstanceFactoryDecorator 包装原始工厂,这样可以确保切面实例只会被创建一次(懒加载)。

3. 处理通知方法:

  • 遍历切面类中的所有方法,检查每个方法是否是通知方法(如 @Before@After 等)。
  • 对每个通知方法调用 getAdvisor 方法,创建相应的 Advisor 对象,并将其添加到列表中。
  • getAdvisor 方法通过解析方法上的注解来创建 AspectJExpressionPointcut,然后将其与通知方法一起封装成 InstantiationModelAwarePointcutAdvisorImpl 对象。

4. 处理懒加载的切面:

  • 如果切面类是懒加载的,则添加一个 SyntheticInstantiationAdvisorAdvisor 列表的开头,以确保在真正使用切面之前完成实例化。

5. 处理引入增强:

  • 遍历切面类中的所有字段,检查是否有引入增强(@DeclareParents 注解)。
  • 对每个引入增强字段,调用 getDeclareParentsAdvisor 方法,创建相应的 Advisor 对象,并将其添加到列表中。

6. 返回所有 Advisor:

  • 最终,返回包含所有 Advisor 对象的列表,这些 Advisor 将用于在目标对象上应用切面逻辑。

二. 获取单个 Advisor (getAdvisor 方法)

1. 验证切面类:

  • 确保传入的切面类是有效的切面。

2. 获取 Pointcut:

  • 通过解析方法上的 AspectJ 注解(如 @Before@After),创建 AspectJExpressionPointcut 对象。
  • 如果方法没有相应的注解,则返回 null

3. 创建 Advisor:

  • AspectJExpressionPointcut 和通知方法封装成 InstantiationModelAwarePointcutAdvisorImpl 对象。
  • 返回创建的 Advisor 对象。

三. 获取 Pointcut (getPointcut 方法)

1. 查找方法上的 AspectJ 注解:

  • 检查给定的方法是否有 AspectJ 注解(如 @Before@After)。

2. 创建 Pointcut:

  • 如果找到了 AspectJ 注解,则创建 AspectJExpressionPointcut 对象,并设置相应的切入点表达式。
  • 如果存在 beanFactory,则设置 beanFactory

3. 返回 Pointcut:

  • 返回配置好的 AspectJExpressionPointcut 对象,如果没有找到注解,则返回 null

简要总结

  • getAdvisors 方法从切面工厂中提取元数据,装饰工厂以实现懒加载,处理切面类中的通知方法和引入增强,最终返回所有的 Advisor
  • getAdvisor 方法根据通知方法创建相应的 Advisor,并将其与 Pointcut 结合起来。
  • getPointcut 方法通过解析方法上的注解来创建并配置 Pointcut,用于在指定的连接点上应用通知。

时序图如下:

在这里插入图片描述

关键步骤说明

  • 获取所有 Advisor:由 Spring 容器发起,调用 ReflectiveAspectJAdvisorFactorygetAdvisors 方法。
  • 获取切面类和切面名称:从 MetadataAwareAspectInstanceFactory 中提取切面类和切面名称。
  • 验证切面类是否合法:确保切面类是有效的。
  • 包装工厂以实现懒加载:使用 LazySingletonAspectInstanceFactoryDecorator 包装工厂。
  • 遍历切面类的方法:逐个检查每个方法,是否包含 AspectJ 注解。
    • 方法有 AspectJ 注解:创建 AspectJExpressionPointcut,并与方法封装成 InstantiationModelAwarePointcutAdvisorImpl
    • 方法无 AspectJ 注解:跳过该方法。
  • 切面是懒加载的:添加 SyntheticInstantiationAdvisorAdvisor 列表开头。
  • 遍历切面类的字段:检查每个字段是否包含 DeclareParents 注解。
    • 字段有 DeclareParents 注解:创建相应的 Advisor
    • 字段无 DeclareParents 注解:跳过该字段。
  • 返回所有 Advisor:将包含所有 Advisor 的列表返回给 Spring 容器。

3. TargetSource 的构建和作用

  在 Spring AOP 中,TargetSource 是一个重要的概念,它用于描述 AOP 代理的目标对象。目标对象是被代理对象,即实际执行业务逻辑的对象。TargetSource 定义了如何获取这个目标对象以及它的生命周期管理。

3.1 TargetSource 的作用

  1. 获取目标对象:TargetSource 提供了获取目标对象的机制,代理对象在执行方法调用时,通过 TargetSource 获取实际的目标对象。

  2. 目标对象的生命周期管理:TargetSource 负责目标对象的生命周期管理,比如创建、缓存、销毁等。

  3. 支持多种代理模式:通过不同的 TargetSource 实现,可以支持不同的代理模式,比如单例、多例、懒加载等。

常见的 TargetSource 实现

1. SingletonTargetSource:单例目标源,目标对象是单例的,每次获取的都是同一个实例。

2. PrototypeTargetSource:原型目标源,每次获取目标对象时,都会创建一个新的实例。

3. LazyInitTargetSource:懒加载目标源,目标对象只有在第一次使用时才会被创建。

3.2 TargetSource 的构建

核心类与方法

  • AdvisedSupport:这个类持有 TargetSource 和其他 AOP 配置。
  • ProxyFactory:这个类用于创建 AOP 代理。
  • AopProxy:具体的代理实现类(如 JdkDynamicAopProxyCglibAopProxy)。

AdvisedSupportSpring AOP 框架中一个核心的配置类,它持有 TargetSource,以及其他关于 AOP 的配置。下面是一些关键代码片段:

public class AdvisedSupport extends ProxyConfig implements Advised {
   
   
    // 持有的 TargetSource 实例
    private TargetSource targetSource = EmptyTargetSource.INSTANCE;

    // 设置 TargetSource
    public void setTargetSource(TargetSource targetSource) {
   
   
        this.targetSource = (targetSource != null ? targetSource : EmptyTargetSource.INSTANCE);
    }

    // 获取 TargetSource
    public TargetSource getTargetSource() {
   
   
        return this.targetSource;
    }

    // 其他相关配置和方法
}

ProxyFactory 类用于创建 AOP 代理。它继承自 AdvisedSupport,所以可以直接访问 TargetSource

相关的类用一张图说明:

在这里插入图片描述

代码提出来分析

/**
 * 根据此工厂中的设置创建一个新的代理。
 * <p>此方法可以重复调用。如果我们添加或删除接口,效果会有所不同。
 * 可以添加和删除拦截器。
 * <p>使用默认的类加载器:通常是线程上下文类加载器(如果代理创建需要)。
 * @return 代理对象
 */
public Object getProxy() {
   
   
    // 调用 createAopProxy() 方法创建 AOP 代理,然后调用其 getProxy() 方法返回代理对象
    return createAopProxy().getProxy();
}

/**
 * 创建一个新的 AOP 代理。子类应调用此方法来获取新的 AOP 代理,而不应直接使用 this 作为参数创建 AOP 代理。
 * @return 新的 AOP 代理
 */
protected final synchronized AopProxy createAopProxy() {
   
   
    // 如果代理还没有激活,则激活代理
    if (!this.active) {
   
   
        activate();
    }
    // 调用 AopProxyFactory 的 createAopProxy 方法创建新的 AOP 代理
    return getAopProxyFactory().createAopProxy(this);
}

/**
 * 根据 AdvisedSupport 配置创建一个 AOP 代理。此方法决定使用哪种代理实现(JDK 动态代理或 CGLIB 代理)。
 **/
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
   
   
    // 检查是否在原生镜像中执行,以及是否优化、代理目标类或没有用户提供的代理接口
    if (!NativeDetector.inNativeImage() &&
            (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
   
   
        // 获取目标类
        Class<?> targetClass = config.getTargetClass();
        // 如果目标类为空,抛出 AopConfigException 异常
        if (targetClass == null) {
   
   
            throw new AopConfigException("TargetSource 无法确定目标类: " +
                    "创建代理需要一个接口或目标对象。");
        }
        // 如果目标类是接口或代理类或 lambda 表达式,使用 JdkDynamicAopProxy
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || AopProxyUtils.isLambda(targetClass)) {
   
   
            return new JdkDynamicAopProxy(config);
        }
        // 否则,使用 ObjenesisCglibAopProxy
        return new ObjenesisCglibAopProxy(config);
    } else {
   
   
        // 默认使用 JdkDynamicAopProxy
        return new JdkDynamicAopProxy(config);
    }
}

  getProxy 方法是调用 createAopProxy() 方法创建 AOP 代理对象,然后调用创建的 AOP 代理对象的 getProxy() 方法返回实际的代理对象。

  createAopProxy 方法首先检查代理是否已激活,如果未激活则调用 activate() 方法激活代理。调用 getAopProxyFactory().createAopProxy(this) 方法,通过 AopProxyFactory 创建新的 AOP 代理对象。

createAopProxy 方法过程如下:

  • 检查是否在原生镜像中执行,以及是否需要优化、代理目标类或没有用户提供的代理接口。
  • 获取目标类,如果目标类为空,抛出 AopConfigException 异常。
  • 如果目标类是接口、代理类或 lambda 表达式,使用 JdkDynamicAopProxy 创建代理。
  • 否则,使用 ObjenesisCglibAopProxy 创建代理。
  • 如果不满足上述条件,默认使用 JdkDynamicAopProxy

下面时序图是说明 TargetSourceSpring AOP 中的构建和使用过程:

在这里插入图片描述
关键步骤说明

1. 创建并配置 AdvisedSupport 实例:

  • Spring 容器创建一个 AdvisedSupport 实例,并根据配置设置其属性,包括 TargetSource

2. 设置 TargetSource:

  • AdvisedSupport 实例中设置 TargetSource,它定义了如何获取目标对象。

3. 创建 AopProxy:

  • Spring 容器调用 AopProxyFactory 创建 AopProxy 实例,传递 AdvisedSupport 作为配置。

4. 获取配置信息:

  • AopProxyFactoryAdvisedSupport 获取创建 AopProxy 所需的配置信息。

5. 根据配置创建 AopProxy 实例:

  • AopProxyFactory 根据 AdvisedSupport 配置决定使用哪种 AopProxy 实现(如 JdkDynamicAopProxyCglibAopProxy),并创建 AopProxy 实例。

6. 获取 TargetSource:

  • AopProxyAdvisedSupport 中获取 TargetSource 实例。

7. 获取目标对象:

  • AopProxy 调用 TargetSourcegetTarget 方法获取实际的目标对象实例。

8. 创建代理对象:

  • AopProxy 使用目标对象创建代理对象。

9. 返回代理对象:

  • AopProxy 将创建的代理对象返回给 Spring 容器。

10. 返回代理对象给调用者:

  • Spring 容器将代理对象返回给调用者。



欢迎一键三连~



有问题请留言,大家一起探讨学习



----------------------Talk is cheap, show me the code-----------------------

目录
相关文章
|
1月前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程(AOP)通过分离横切关注点,如日志、安全和事务,提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持,核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类,集中处理通用逻辑;`@Pointcut` 则通过表达式定义通知的应用位置,提高代码可读性与复用性。二者结合,使开发者能清晰划分业务逻辑与辅助功能,简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入,与 Spring 容器无缝集成,支持依赖注入与声明式配置,是构建清晰、高内聚应用的理想选择。
289 0
|
5月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面(Aspect)、连接点(Join Point)、通知(Advice)、切点(Pointcut)等关键概念,解析了JDK动态代理与CGLIB代理的原理及对比,并深入探讨了通知执行链路和责任链模式的应用。同时,详细分析了AspectJ注解驱动的AOP解析过程,包括切面识别、切点表达式匹配及通知适配为Advice的机制,帮助理解Spring AOP的工作原理与实现细节。
|
2月前
|
人工智能 监控 安全
Spring AOP切面编程颠覆传统!3大核心注解+5种通知类型,让业务代码纯净如初
本文介绍了AOP(面向切面编程)的基本概念、优势及其在Spring Boot中的使用。AOP作为OOP的补充,通过将横切关注点(如日志、安全、事务等)与业务逻辑分离,实现代码解耦,提升模块化程度、可维护性和灵活性。文章详细讲解了Spring AOP的核心概念,包括切面、切点、通知等,并提供了在Spring Boot中实现AOP的具体步骤和代码示例。此外,还列举了AOP在日志记录、性能监控、事务管理和安全控制等场景中的实际应用。通过本文,开发者可以快速掌握AOP编程思想及其实践技巧。
|
2月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】?核心应用实战(上篇)
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇,我们将专注于Spring AOP的实际应用,通过具体的代码示例和场景分析,帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中,我们将深入探讨Spring AOP的实现原理和底层机制。 AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架中的核心特性之一,它能够帮助我们解决横切关注点(如日志记录、性能统计、安全控制、事务管理等)的问题,提高代码的模块化程度和复用性。
|
2月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】?从动态代理到源码剖析(下篇)
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层,实现了对目标对象访问的控制与增强,其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中,这种模式广泛用于实现功能扩展(如远程调用、延迟加载)、行为拦截(如权限校验、异常处理)等场景,为系统提供了更高的灵活性和可维护性。
|
11月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
273 2
|
7月前
|
算法 测试技术 C语言
深入理解HTTP/2:nghttp2库源码解析及客户端实现示例
通过解析nghttp2库的源码和实现一个简单的HTTP/2客户端示例,本文详细介绍了HTTP/2的关键特性和nghttp2的核心实现。了解这些内容可以帮助开发者更好地理解HTTP/2协议,提高Web应用的性能和用户体验。对于实际开发中的应用,可以根据需要进一步优化和扩展代码,以满足具体需求。
660 29
|
7月前
|
前端开发 数据安全/隐私保护 CDN
二次元聚合短视频解析去水印系统源码
二次元聚合短视频解析去水印系统源码
191 4
|
7月前
|
JavaScript 算法 前端开发
JS数组操作方法全景图,全网最全构建完整知识网络!js数组操作方法全集(实现筛选转换、随机排序洗牌算法、复杂数据处理统计等情景详解,附大量源码和易错点解析)
这些方法提供了对数组的全面操作,包括搜索、遍历、转换和聚合等。通过分为原地操作方法、非原地操作方法和其他方法便于您理解和记忆,并熟悉他们各自的使用方法与使用范围。详细的案例与进阶使用,方便您理解数组操作的底层原理。链式调用的几个案例,让您玩转数组操作。 只有锻炼思维才能可持续地解决问题,只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助,麻烦您点个赞支持一下,还可以收藏起来以备不时之需,有疑问和错误欢迎在评论区指出~
|
7月前
|
移动开发 前端开发 JavaScript
从入门到精通:H5游戏源码开发技术全解析与未来趋势洞察
H5游戏凭借其跨平台、易传播和开发成本低的优势,近年来发展迅猛。接下来,让我们深入了解 H5 游戏源码开发的技术教程以及未来的发展趋势。

推荐镜像

更多
  • DNS