当前位置： 首页 > article >正文

Spring 的奇幻起源：从 IoC 容器到 Bean 的魔法世界 ✨

article 2024/11/19 2:33:07

目录

什么是 Spring？为什么它如此流行？

IoC 容器：从“依赖倒置”到“控制反转”

Bean：IoC 容器中的基本组件

Spring 中的配置方式：XML、注解和 JavaConfig

Bean 的作用域和生命周期管理

Bean 的属性装配和自动装配

高级特性：BeanPostProcessor 和 FactoryBean

Spring Boot 中的 Bean 管理和自动配置

大家好这里是苏泽，一个从小喜欢钻研原理的疯小子
这篇文章是我的专栏《Spring 狂野之旅：底层原理高级进阶》 🚀 的第一篇文章
也是学习写一个讲解底层原理的博客的第一课
我认为深入了解一个事物的全貌是一件神秘而刺激的过程 希望你们能和我一样Enjoy the process

这个专栏里我希望能把Spring的底层原理讲得彻彻底底 让普通人也能一看就懂的程度 会慢慢更新 如果有想法可以在评论区提哦
相互交流学习的小伙伴可以关注一下我 技术博客每日一更

  1. 什么是 Spring？为什么它如此流行？

    • Spring框架的定位是一个全方位的企业级应用开发框架，它致力于简化企业级应用的开发，并且提供了全栈式的解决方案。从最初的依赖注入（DI）和面向切面编程（AOP），到如今的云原生、微服务架构，Spring框架不断进化，始终站在技术潮流的前沿。

      二、Spring傲视群雄的底气

      Spring框架之所以能够成为Java世界中的一颗常青树，其原因不仅仅是因为它的历史悠久，更重要的是它拥有以下几大优点：

      1. 全方位的企业级支持

      Spring提供了从前端到后端，从数据库操作到安全认证，再到云服务的全栈式开发支持。不管你是在做小型应用还是大型分布式系统，Spring都能提供合适的解决方案。

      2. 灵活性和扩展性

      通过依赖注入和面向切面编程，Spring允许开发者以极其灵活的方式组织自己的代码。同时，Spring的设计允许你轻松扩展现有的功能，甚至可以整合其他框架和库。

      3. 强大的社区支持

      作为Java世界中最受欢迎的框架之一，Spring拥有庞大而活跃的社区。无论你遇到任何问题，都能在社区中找到解答，或是从众多的开源项目中获得灵感。

      4. 持续的创新和进步

      Spring团队从未停止过对技术的探索和创新。从Spring Framework到Spring Boot，再到Spring Cloud，每一次更新都让开发者的生活变得更加美好。

      三、应用场景：Spring框架的舞台

      Spring框架的应用场景广泛，无论是传统的Web应用、企业级应用，还是现代的微服务架构、云原生应用，Spring都能提供强有力的支持。具体来说，Spring框架可以应用于：

    • 企业级应用开发：利用Spring的事务管理、安全框架等功能，可以快速构建可靠的企业级应用。
    • 微服务架构：通过Spring Boot和Spring Cloud，开发者可以轻松地构建和部署微服务架构的应用。
    • 云原生应用：Spring Cloud为开发云原生应用提供了一系列的解决方案，包括服务发现、配置管理等。
  2. 一、时光机启动：Spring框架的历史和定位想象一下，我们坐上时光机回到了2003年，那时候Rod Johnson发布了他的著作《Expert One-on-One J2EE Design and Development》。书中提出了一种轻量级的Java开发方式，这就是Spring框架的雏形。与当时流行的重量级EJB（Enterprise JavaBeans）相比，Spring提出了一种更加简单、灵活的开发模式。

下面正式开始基本认识Sprin

IoC 容器：从“依赖倒置”到“控制反转”

IoC：让你的代码像呼吸一样自然

在软件开发的世界里，有一种魔法可以让我们的代码更加灵活、解耦，它就是IoC（控制反转）。今天，让我们一起揭开IoC的神秘面纱，看看它是如何让我们的代码像呼吸一样自然。

一、IoC的概念：反转你的思维

想象一下，如果你是一名厨师，每当你需要煮一壶水时，都必须亲自去河边打水，然后生火，最后才能煮水。这样不仅效率低下，而且极其繁琐。如果有人能帮你准备好水，甚至帮你煮好水，那该多好啊！

这就是IoC的精髓所在。在没有IoC的传统开发模式中，对象自己控制着自己的行为。而一旦引入IoC，对象的创建和生命周期的控制就被反转了，交给了外部一个容器来管理。这就好比你不再需要亲自去河边打水，而是有一个“厨房助手”来帮你准备好一切。

// 传统方式，对象自己控制一切
public class TraditionalService {
    private Dependency dependency = new Dependency();
    
    public void doSomething() {
        dependency.doWork();
    }
}

// 使用IoC后，对象的创建被反转，由外部控制
public class IoCService {
    private Dependency dependency;
    
    // 依赖通过构造器注入，由外部（如IoC容器）控制
    public IoCService(Dependency dependency) {
        this.dependency = dependency;
    }
    
    public void doSomething() {
        dependency.doWork();
    }
}

二、IoC的实现方式：施展魔法的工具

在Java世界中，IoC最常见的实现方式有两种：依赖注入（DI）和面向切面编程（AOP）。

依赖注入（DI）

依赖注入是IoC的一种实现方式，它通过“注入”依赖对象来减少对象间的耦合。依赖可以通过构造器、setter方法或者字段直接注入。

@Component
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository; // 依赖注入
    }
}

面向切面编程（AOP）

AOP则是另一种IoC的体现，它允许我们对程序进行横向切割，将一些跨越应用程序多个部分的关注点（如日志、事务管理）模块化到独立的切面中。

@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeServiceMethod(JoinPoint joinPoint) {
        System.out.println("Before executing: " + joinPoint.getSignature().getName());
    }
}

三、IoC容器：魔法的源泉

IoC容器是IoC实现的核心，它负责实例化、配置和组装对象。Spring框架提供了强大的IoC容器，主要分为两种类型：BeanFactory和ApplicationContext。

BeanFactory

BeanFactory是Spring框架中的基础设施，支持依赖注入（DI），它管理Bean的定义并使用依赖注入（DI）原则组装它们。

XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml")); 

MyBean bean = (MyBean) factory.getBean("myBean");

ApplicationContext

ApplicationContext是BeanFactory的子接口，提供了更多高级特性，如消息国际化、事件发布等。它是使用Spring IoC容器的首选方式。

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
MyBean bean = context.getBean(MyBean.class);

Bean：IoC 容器中的基本组件

Java Spring Bean：万物之源

在Spring框架的世界里，Bean是构成应用程序骨架的基础元素。它们如同细胞一样，承载着数据和行为，构建出复杂而强大的生命体——我们的应用程序。今天，我们将深入探讨Bean的定义、生命周期，以及它们的作用和分类。

一、Bean的定义和生命周期

Bean的定义

在Spring框架中，Bean是由Spring IoC容器管理的对象。这些对象不需要通过new关键字实例化，而是由Spring容器负责实例化、配置和组装。

@Component
public class ExampleBean {
    // Bean的内容
}

Bean的生命周期

了解Bean的生命周期对于编写高效、可维护的Spring应用至关重要。Bean的生命周期包括以下几个阶段：

  1. 实例化：Spring容器通过构造器或工厂方法创建Bean实例。
  2. 属性赋值：Spring容器注入Bean的属性。
  3. 初始化：Bean可能会执行自定义的初始化逻辑。
  4. 使用：现在，Bean已经准备好被应用使用了。
  5. 销毁：当容器关闭时，Bean可能执行自定义的销毁逻辑。
@Service
public class MyService {
    // 业务逻辑
}

@Repository
public class MyRepository {
    // 数据访问逻辑
}

@Controller
public class MyController {
    // 处理Web请求
}

二、Bean的作用和分类

Bean的作用

Spring Bean承担着各种角色，从简单的配置对象，到处理Web请求的控制器，再到处理业务逻辑的服务类。Bean的主要作用包括：

  • 封装依赖关系：Spring容器负责管理Bean之间的依赖关系，使得代码更加解耦和易于测试。
  • 统一管理资源：Spring容器可以统一管理数据库连接、线程池等资源，提高资源利用率和应用性能。
  • 增强功能：通过AOP等技术，Spring可以在不修改源代码的情况下增加事务管理、安全检查等功能。

Bean的分类

根据Bean的作用和行为，我们可以将其分为几类：

  • 单例Bean：默认情况下，Spring中的Bean都是单例的，即每个Bean定义对应一个对象实例。
  • 原型Bean：每次请求都会创建一个新的Bean实例。
  • 特殊Bean：
    • FactoryBean：用于产生其他Bean实例的特殊Bean。
    • Controller/Service/Repository：分别标识表现层、业务层、持久层的组件。
@Service
public class MyService {
    // 业务逻辑
}

@Repository
public class MyRepository {
    // 数据访问逻辑
}

@Controller
public class MyController {
    // 处理Web请求
}

Spring Bean是Spring框架的核心，它不仅仅是简单的数据容器，更是承载了Spring应用复杂逻辑和功能的基石。通过深入理解Bean的定义、生命周期以及分类，我们可以更加有效地利用Spring框架构建出健壮、灵活且易于维护的应用程序。

Spring 中的配置方式：XML、注解和 JavaConfig

Spring配置之道：注解、JavaConfig与传统XML

在Spring的世界里，配置是构建和维护应用程序的关键。随着Spring框架的发展，配置方式也从最初的XML配置演变到了注解和JavaConfig。每种配置方式都有其独特的特点和适用场景。今天，我们将深入探讨这些配置方式，帮助你选择最适合你项目的配置方法。

一、传统XML配置

在Spring的早期版本中，XML配置是主流的配置方式。通过XML文件，开发者可以定义Bean以及Bean之间的依赖关系。

特点

  • 明确性：XML配置将Bean的定义和依赖关系描述得非常清晰。
  • 集中管理：所有的配置信息都集中在一个或几个XML文件中，便于管理。
  • 灵活性：通过加载不同的XML配置文件，可以轻松切换应用程序的行为。

适用场景

  • 复杂项目，需要清晰地管理大量Bean之间的依赖关系。
  • 项目团队习惯于使用XML进行配置。
<beans>
    <bean id="myBean" class="com.example.MyBean">
        <property name="dependency" ref="myDependency"/>
    </bean>

    <bean id="myDependency" class="com.example.MyDependency"/>
</beans>

二、注解配置

随着Spring 2.5的发布，注解配置开始成为主流。它通过在类、字段或方法上添加注解来实现Bean的声明和依赖注入。

特点

  • 简洁性：减少了配置的冗余，代码更加简洁。
  • 易于理解：配置直接与代码结合，提高了代码的可读性。
  • 开发效率：减少了编写和维护XML配置文件的工作量。

适用场景

  • 快速开发小到中型项目。
  • 项目中大量使用自动扫描和自动装配的功能。
@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean(myDependency());
    }

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }
}

三、JavaConfig配置

JavaConfig是一种基于Java的配置方式，它允许开发者通过编写配置类来实现Bean的定义和依赖注入。

特点

  • 类型安全：编译时就能发现潜在的错误。
  • 重构友好：IDE的支持使得重构变得更加容易。
  • 灵活性：可以通过编程方式动态决定配置。

适用场景

  • 对类型安全有严格要求的项目。
  • 需要动态决定配置的复杂项目。
@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean(myDependency());
    }

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }
}

深入理解注解和JavaConfig的使用方法

注解和JavaConfig不仅仅是配置Spring应用的方式，它们代表了一种现代化的、与代码紧密集成的配置思想。通过合理利用这些特性，我们可以构建出更加灵活、易于维护的应用。

注解使用精要

  • 利用@ComponentScan注解自动扫描并注册Bean。
  • 使用@Autowired注解实现自动依赖注入。
  • 通过@Qualifier注解解决自动装配时的歧义性。
  • 使用@Profile注解定义不同环境下的配置。

JavaConfig使用技巧

  • 定义配置类，并使用@Configuration注解标记。
  • 使用@Bean注解方法，返回Bean的实例。
  • 利用方法调用实现Bean之间的依赖注入。
  • 结合@Profile和@Conditional注解实现条件化的Bean创建。

Bean 的作用域和生命周期管理

解析 Bean 的作用域和生命周期概念

在Spring框架中，理解Bean的作用域和生命周期是至关重要的，它们决定了Bean的创建、管理及销毁方式。本篇博客将深入探讨这两个概念，并通过示例代码帮助读者更好地理解Spring提供的各种Bean生命周期回调方法。

一、Bean的作用域(Scope)

在Spring中，Bean的作用域决定了容器如何新建Bean实例的规则。Spring提供了几种作用域：

  • singleton：（默认作用域）容器中只存在一个共享的Bean实例，每次请求都返回同一个Bean实例。
  • prototype：每次请求都会创建一个新的Bean实例。
  • request：每次HTTP请求都会产生一个新的Bean，仅在Web应用中有效。
  • session：在一个HTTP Session中，一个Bean定义对应一个实例。仅在Web应用中有效。
  • application：在一个ServletContext生命周期内，一个Bean定义对应一个实例。仅在Web应用中有效。

示例代码：定义不同作用域的Bean

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class BeanScopeConfig {

    @Bean
    @Scope("singleton")
    public MyBean singletonBean() {
        return new MyBean();
    }

    @Bean
    @Scope("prototype")
    public MyBean prototypeBean() {
        return new MyBean();
    }
}

二、Bean的生命周期

Bean的生命周期指的是从Bean的初始化到销毁的整个过程。在这个过程中，Spring容器提供了多个扩展点，允许在Bean的创建和销毁过程中加入自定义逻辑。

Bean生命周期的主要阶段：

  1. 实例化Bean：Spring容器首先调用构造函数或工厂方法来实例化Bean。
  2. 填充属性：Spring容器注入Bean所需要的依赖。
  3. 调用BeanNameAware的setBeanName()：如果Bean实现了BeanNameAware接口，Spring容器将Bean的ID传给setBeanName方法。
  4. 调用BeanFactoryAware的setBeanFactory()：如果Bean实现了BeanFactoryAware接口，Spring容器将调用setBeanFactory方法，传入BeanFactory。
  5. 调用ApplicationContextAware的setApplicationContext()：如果Bean实现了ApplicationContextAware接口，Spring容器将调用setApplicationContext方法，传入ApplicationContext。
  6. 前置处理器Before Initialization：BeanPostProcessor的postProcessBeforeInitialization方法将被调用。
  7. 初始化：如果Bean实现了InitializingBean接口，Spring容器将调用afterPropertiesSet方法。另外，可以通过@Bean注解的initMethod指定初始化方法。
  8. 后置处理器After Initialization：BeanPostProcessor的postProcessAfterInitialization方法将被调用。
  9. Bean准备就绪：此时，Bean已经准备好被应用使用了。
  10. 销毁：当容器关闭时，如果Bean实现了DisposableBean接口，Spring容器将调用destroy方法。也可以通过@Bean注解的destroyMethod指定销毁方法。

示例代码：自定义Bean生命周期回调方法

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class MyLifecycleBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
        System.out.println("MyLifecycleBean is initialized.");
    }

    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
        System.out.println("MyLifecycleBean is destroyed.");
    }
}

通过实现InitializingBean和DisposableBean接口，我们可以在Bean的生命周期的特定时间点执行自定义逻辑。

Bean 的属性装配和自动装配

深入理解Spring Bean：属性、依赖与自动装配

在Spring框架中，Bean是构建应用程序的基石。它们不仅承载着数据和行为，还通过依赖关系与其他Bean相互作用。正确地管理Bean的属性和依赖关系，是实现高效、可维护Spring应用的关键。本篇博客将带你深入理解Bean的属性和依赖关系，并掌握Spring提供的属性配置和自动装配方式。

一、理解Bean的属性和依赖关系

Bean的属性

Bean的属性指的是Bean中的字段，这些字段可以通过XML配置、注解或JavaConfig来配置。

示例：通过XML配置Bean属性
<bean id="exampleBean" class="com.example.ExampleBean">
    <property name="beanProperty" value="Some Value"/>
</bean>
示例：通过注解配置Bean属性
@Component
public class ExampleBean {
    @Value("${some.value}")
    private String beanProperty;
}

Bean的依赖关系

Bean的依赖关系指的是一个Bean依赖于另一个Bean来完成其操作。例如，一个服务类（Service）可能依赖于一个数据访问对象（DAO）。

示例：通过XML配置Bean依赖
<bean id="myDao" class="com.example.MyDao"/>

<bean id="myService" class="com.example.MyService">
    <property name="myDao" ref="myDao"/>
</bean>
示例：通过注解配置Bean依赖
@Service
public class MyService {
    private final MyDao myDao;

    @Autowired
    public MyService(MyDao myDao) {
        this.myDao = myDao;
    }
}

二、掌握Spring提供的属性配置和自动装配方式

属性配置

Spring提供了多种方式来配置Bean的属性，其中最常用的是@Value注解。

使用@Value注解

@Value注解可以用来注入普通属性、系统属性、环境变量等。

@Component
public class ExampleBean {
    @Value("${app.name:defaultAppName}")
    private String appName;
}

自动装配

Spring的自动装配功能可以自动满足Bean之间的依赖，减少配置的工作量。最常用的自动装配注解是@Autowired。

使用@Autowired进行自动装配

Spring会在容器中查找匹配类型的Bean，并注入到被@Autowired标注的字段、构造器或方法中。

@Service
public class MyService {
    private final MyDao myDao;

    @Autowired
    public MyService(MyDao myDao) {
        this.myDao = myDao; // 自动装配
    }
}

高级自动装配

对于更复杂的自动装配场景，Spring提供了@Qualifier和@Primary注解来进一步控制自动装配的行为。

使用@Qualifier指定具体的Bean

当有多个同类型的Bean可供选择时，@Qualifier注解可以用来指定具体要装配的Bean。

@Autowired
@Qualifier("specificDao")
private MyDao myDao;
使用@Primary指定首选的Bean

通过在Bean定义上使用@Primary注解，可以指定当存在多个同类型Bean时，默认选择哪一个。

@Component
@Primary
public class PrimaryDao implements MyDao {
    // 实现细节
}

高级特性：BeanPostProcessor 和 FactoryBean

理解 BeanPostProcessor 和 FactoryBean 的作用和区别

在Spring框架中，BeanPostProcessor和FactoryBean是两个非常重要的接口，它们在Bean的生命周期管理和创建过程中扮演着关键角色。虽然它们的功能看似相近，但实际上各自的作用和应用场景大相径庭。

BeanPostProcessor：定制Bean的创建过程

BeanPostProcessor允许开发者插手Bean的初始化过程，在Bean的初始化前后执行一些自定义逻辑。

主要方法：

  • postProcessBeforeInitialization(Object bean, String beanName): 在任何Bean初始化回调方法（如InitializingBean的afterPropertiesSet或自定义的init方法）之前调用。
  • postProcessAfterInitialization(Object bean, String beanName): 在所有Bean初始化回调之后调用。

应用场景：

  • 修改或包装Bean的实例，例如用代理包装一个Bean以提供额外的功能。
  • 检查Bean属性的正确性或根据特定条件更改Bean的属性。

示例代码：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化之前执行的逻辑
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化之后执行的逻辑
        return bean;
    }
}

FactoryBean：专门用于生产对象的工厂Bean

与BeanPostProcessor不同，FactoryBean是用于生成其他Bean实例的特殊Bean。当配置的Bean实现了FactoryBean接口时，它将返回getObject()方法所返回的对象，而不是FactoryBean本身。

主要方法：

  • T getObject(): 返回由FactoryBean创建的Bean实例。
  • Class<?> getObjectType(): 返回FactoryBean创建的Bean类型。
  • boolean isSingleton(): 表明由FactoryBean创建的Bean是否为单例。

应用场景：

  • 创建复杂对象，当一个Bean的创建过程中涉及复杂逻辑时，可以使用FactoryBean封装这些逻辑。
  • 返回的Bean实例可以是接口的代理，也可以是需要复杂初始化的对象。

示例代码：

import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean<MyBean> {
    @Override
    public MyBean getObject() throws Exception {
        // 返回需要创建的Bean实例
        return new MyBean();
    }

    @Override
    public Class<?> getObjectType() {
        return MyBean.class;
    }

    @Override
    public boolean isSingleton() {
        // 控制该Bean是否为单例
        return true;
    }
}

BeanPostProcessor vs FactoryBean

虽然BeanPostProcessor和FactoryBean都可以影响Spring容器中Bean的创建，但它们的主要区别在于：

  • BeanPostProcessor是用于修改或包装已经存在的Bean实例的。
  • FactoryBean是用于创建新的Bean实例的。

Spring Boot 中的 Bean 管理和自动配置

探索Spring Boot：设计理念与自动配置深解

Spring Boot，作为现代Java开发中的一颗明星，以其“约定大于配置”的理念，极大地简化了Spring应用的开发、部署和运维。它不仅继承了Spring框架强大的依赖注入和面向切面编程的特性，还在此基础上提供了自动配置等功能，使得开发者可以更加专注于业务逻辑。本篇博客将带你深入理解Spring Boot的设计理念和主要特点，以及它在Bean管理和自动配置方面的实现原理。

Spring Boot的设计理念和主要特点

设计理念

Spring Boot遵循“约定大于配置”的原则，旨在减少项目搭建的复杂性和开发时的配置要求。它通过合理的默认配置，帮助开发者快速启动和开发Spring应用程序。

主要特点

  • 自动配置：自动配置Spring和第三方库，尽可能地减少配置文件的使用。
  • 独立运行：生成的应用程序可以直接运行，不需要外部的Servlet容器。
  • 运维友好：提供了丰富的监控和管理功能，支持健康检查、应用信息查看等。
  • 无代码生成和XML配置：不需要生成代码或进行XML配置，通过注解和自动装配完成配置。

深入掌握Spring Boot在Bean管理和自动配置方面的实现原理

Bean管理

Spring Boot利用Spring框架的依赖注入（DI）特性来管理Bean。开发者可以通过注解如@Component、@Service、@Repository等来声明Bean，并通过@Autowired或构造器注入依赖。

示例：定义和注入Bean
@Service
public class MyService {
    // 业务逻辑
}

@RestController
public class MyController {
    private final MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService; // 自动装配
    }
}

自动配置原理

Spring Boot自动配置的魔法背后是@EnableAutoConfiguration注解，这个注解通过@Import引入了AutoConfigurationImportSelector类，该类负责读取META-INF/spring.factories文件中的配置，根据条件选择性地应用配置。

示例：自动配置的简化示例

假设我们有一个自动配置类MyAutoConfiguration，当classpath中存在某个特定类时，这个配置类就会被应用：

@Configuration
@ConditionalOnClass(SomeClass.class)
public class MyAutoConfiguration {
    @Bean
    public SomeBean someBean() {
        return new SomeBean();
    }
}

在resources/META-INF/spring.factories文件中，我们声明这个自动配置类：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration

当Spring Boot应用启动时，如果classpath中存在SomeClass，那么SomeBean就会被自动配置。


http://www.kler.cn/a/231785.html

相关文章：

  • Java基础-I/O流
  • Lua资料
  • JS的学习与使用
  • 卷径计算(基于卷径变化微分方程计算实时卷径)
  • 以太坊基础知识结构详解
  • 【珠海科技学院主办，暨南大学协办 | IEEE出版 | EI检索稳定 】2024年健康大数据与智能医疗国际会议（ICHIH 2024）
  • 《MySQL 简易速速上手小册》第1章：MySQL 基础和安装（2024 最新版）
  • Leetcode第123场双周赛
  • 【MySQL】学习和总结DCL的权限控制
  • 智慧自助餐饮系统（SpringBoot+MP+Vue+微信小程序+JNI+ncnn+YOLOX-Nano）
  • SASS 官方文档速通
  • TCP和UDP相关问题(重点)(5)——5.TCP三次握手和四次挥手(非常重要)
  • 移动云ONAIR媒体云全解读!媒体内容数字化融合一站式解决方案
  • 小白代码审计入门
  • 每日一题——LeetCode1422.分割字符串的最大得分
  • 在Python中如何定义一个闭包并使用它
  • 跳过mysql5.7密码并重置密码 shell脚本
  • IP风险画像在企业网络统计与安全防范中应用
  • 使用Vue+ ECharts进行动态图表展示
  • jsp教务管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
  • Spring Boot的打包方式：JAR vs. WAR 打包方式
  • office文件转pdf在线预览
  • Redis面试题41
  • Ubuntu 命令与脚本
  • Redis核心技术与实战【学习笔记】 - 29.Redis的未来猜想，基于 NVM内存
  • GO语言笔记4-标识符、关键字与运算符