简单上手SpringBean的整个装配过程

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量408 收藏 6
点赞数 4
分类专栏： Spring全攻略 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunzroad/article/details/138915785
版权

你好，这里是codetrend专栏“Spring6全攻略”。

典型的企业级应用程序并非仅由单个对象（在Spring术语中称为bean）组成。即使是最简单的应用程序，也会包含一些协同工作的对象，共同呈现出终端用户眼中连贯一致的应用程序形态。

以下mermaid流程图简单展示了Spring工作过程。
产生
业务类POJO
Spring容器ApplicationContext
配置元数据Configuration Metadata
可执行的系统/应用程序

业务类与配置元数据相结合，使得在Spring容器ApplicationContext被创建并初始化后，得到的是一个完全配置好且可执行的系统或应用程序。

下文将从定义一系列独立的bean定义出发，进而构建出一个对象间相互协作以达成目标的完全成型的应用程序。

配置元数据 Configuration Metadata

Spring IoC 容器通过消费一种形式的配置元数据。这些配置元数据代表了您作为应用程序开发者告诉 Spring 容器如何实例化、配置和组装应用程序中的对象。

配置元数据方式如下：

  • 基于 XML 格式配置
  • 基于 Groovy 格式配置
  • 基于Java类和注解进行配置

虽然配置的形式不一样，但是配置内容和api基本一样的。

以下是基于 XML 格式、Groovy 格式和 Java 类与注解的方式来配置 Spring IoC 容器的示例：

  • 基于 XML 格式配置：
<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.example.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean id="userDao" class="com.example.UserDao"/>

</beans>
  • 基于 Groovy 格式配置：
// applicationContext.groovy
beans {
    userService(com.example.UserService) {
        userDao = ref('userDao')
    }

    userDao(com.example.UserDao)
}
  • 基于 Java 类和注解进行配置：
// AppConfig.java
@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        UserService userService = new UserService();
        userService.setUserDao(userDao());
        return userService;
    }

    @Bean
    public UserDao userDao() {
        return new UserDao();
    }
}

以上示例分别展示了使用 XML、Groovy 和 Java 类与注解的方式来配置 Spring IoC 容器。无论使用哪种配置方式，都可以定义和组装应用程序中的对象，并且相应的 API 在实现上基本一致。

这三种配置方式各有优劣，开发者可以根据项目需求和个人喜好选择合适的方式。

Ioc容器使用初体验

Ioc容器在Spring6框架中也就是各种BeanFactory的实现类来创建和管理对象。

ClassPathXmlApplicationContext就是通过读取xml配置初始化bean的一种方法。

启动类的代码如下：

/**
 * 宠物测试app
 * @author nine
 * @since 1.0
 */
public class PetApp {
    public static void main(String[] args) {
        // 创建一个类路径下的XML应用上下文，并指定配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("s104/services.xml", "s104/daos.xml");
        // 从上下文中获取名为"petStore"的bean，其类型为PetStoreServiceImpl，其中petStoreAlias是别名
        PetStoreService petStoreService = context.getBean("petStoreAlias", PetStoreServiceImpl.class);
        // 调用获取的bean的buyPet方法
        petStoreService.buyPet(new Pet("Tom", "Cat",1));
    }
}

bean的配置如下：

<!-- daos.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="accountDao"
          class="io.yulin.learn.spring.s104.AccountDao">
    </bean>

    <bean id="itemDao" class="io.yulin.learn.spring.s104.ItemDao">
    </bean>
</beans>

<!-- services.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- services -->
    <bean id="petStore" class="io.yulin.learn.spring.s104.PetStoreServiceImpl" >
        <property name="accountDao" ref="accountDao"/>
        <property name="itemDao" ref="itemDao"/>
    </bean>
    <!--命名别名-->
    <alias name="petStore" alias="petStoreAlias" />
</beans>

对应bean如下。其中这些bean也就是简单的业务bean。

@Slf4j
@Data
public class PetStoreServiceImpl implements PetStoreService {
    private  AccountDao accountDao;
    private  ItemDao itemDao;
    @Override
    public boolean buyPet(Pet pet) {
        log.info("buy pet: {}", pet);
        accountDao.store(pet);
        itemDao.minus(pet);
        return true;
    }
}

@Slf4j
public class ItemDao {
    public void minus(Pet pet) {
        log.info("minus pet num: {}", pet.getNum());
    }
}

@Slf4j
public class AccountDao {
    public void store(Pet pet) {
        log.info("增加收入: {}", pet);
    }
}

这个过程与开发者编写工具类一样，没有任何注解、导入依赖这些配置。习惯使用springboot的开发者可能对此表示有点不习惯。

但是xml元数据配置+BeanFactory一起，就组合成了一个单独的app。运行起来就和springboot无异。

讲上述代码修改为基于Java类和注解进行配置的代码如下。

public class PetAppJavaConfig {
    public static void main(String[] args) {
        // 创建一个基于 Java Config 的应用上下文
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 从上下文中获取名为"petStoreService"的bean，其类型为PetStoreService
        PetStoreService petStoreService = context.getBean(PetStoreService.class);
        // 调用获取的bean的buyPet方法
        petStoreService.buyPet(new Pet("Tom", "Cat", 1));
    }
}
@Configuration
class AppConfig {
    @Bean
    public PetStoreService petStoreService(AccountDao accountDao, ItemDao itemDao) {
        PetStoreServiceImpl petStoreService = new PetStoreServiceImpl();
        petStoreService.setAccountDao(accountDao);
        petStoreService.setItemDao(itemDao);
        return petStoreService;
    }
    @Bean
    public AccountDao accountDao() {
        return new AccountDao();
    }
    @Bean
    public ItemDao itemDao() {
        return new ItemDao();
    }
}

可以看出代码简洁明了不少，代码输出结果都是一致的。

11:38:11.646 [main] INFO io.yulin.learn.spring.s104.PetStoreServiceImpl -- buy pet: Pet(name=Tom, type=Cat, num=1)
11:38:11.653 [main] INFO io.yulin.learn.spring.s104.AccountDao -- 增加收入: Pet(name=Tom, type=Cat, num=1)
11:38:11.653 [main] INFO io.yulin.learn.spring.s104.ItemDao -- minus pet num: 1

完整项目源码信息查看可以在gitee或者github上搜索r0ad查看。（外链审核太严格~木办法）

配置Bean初体验

Spring IoC容器管理一个或多个bean。这些bean是根据您提供给容器的配置元数据创建的（例如，以XML <bean/> 定义的形式）。

在容器内部，bean 定义被表示为 BeanDefinition 对象，其中包含（除其他信息外）以下元数据：

  • 一个包限定的类名：通常是所定义的 bean 的实际实现类。
  • Bean 行为配置元素，用于说明 bean 在容器中应如何运行（作用域、生命周期回调等）。
  • 引用其他 bean，这些 bean 是该 bean 执行工作所需的。这些引用也称为协作者或依赖项。
  • 其他配置设置用于设置新创建对象中的值，例如，管理连接池的 bean 中的池大小限制或要使用的连接数。

/**
 * 说明备案definition的例子
 *
 * @author nine
 * @since 1.0
 */
public class BeanDefinitionProcessDemo {
    public static void main(String[] args) {
        // ️GenericApplicationContext 是一个【干净】的容器
        GenericApplicationContext context = new GenericApplicationContext();
        // 用原始方法注册三个 bean
        context.registerBean("bean1", Bean1.class);
        // 初始化容器
        // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例
        context.refresh();
        Bean1 bean = context.getBean(Bean1.class);
        bean.print();
        // 销毁容器
        context.close();
    }
}

@Slf4j
class Bean1 {
    public void print() {
        log.info("I am bean1");
    }
}

通过这个代码可以发现，Bean1在调用registerBean接口后从一个普通的pojo类变成了一个bean。

org.springframework.context.support.GenericApplicationContext#registerBean为了方便使用有很多重载方法。

通过源码可以发现，普通类通过ClassDerivedBeanDefinition的构造函数转换为BeanDefinition。也就是该class通过setBeanClass成为BeanDefinition的属性beanClass。

后续通过一些列操作，自定义、名字处理、注册容器等等添加了其他的属性信息或者进行二次处理。

具体源码如下。

public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier, BeanDefinitionCustomizer... customizers) {
    // 创建一个 ClassDerivedBeanDefinition 对象，用于封装 Bean 的定义信息
    ClassDerivedBeanDefinition beanDefinition = new ClassDerivedBeanDefinition(beanClass);

    // 如果存在 supplier，则设置到 BeanDefinition 中
    if (supplier != null) {
        beanDefinition.setInstanceSupplier(supplier);
    }

    // 对 BeanDefinition 进行定制处理
    for (BeanDefinitionCustomizer customizer : customizers) {
        customizer.customize(beanDefinition);
    }

    // 如果指定了 beanName，则使用指定的名称，否则使用 beanClass 的名称
    String nameToUse = (beanName != null ? beanName : beanClass.getName());

    // 将封装好的 BeanDefinition 注册到容器中
    registerBeanDefinition(nameToUse, beanDefinition);
}

bean的生命周期回调

Spring6 中 Bean 的生命周期可以通过 InitializingBean 和 DisposableBean 接口、@PostConstruct 和 @PreDestroy 注解以及配置文件中的 init-method 和 destroy-method 方法来管理。

把上面手动注入的bean的demo修改，增加实现 Bean 的初始化和销毁回调：

public class BeanDefinitionProcessDemo {
    public static void main(String[] args) {
        // GenericApplicationContext 是一个干净的容器
        GenericApplicationContext context = new GenericApplicationContext();
        // 用原始方法注册 bean1，并指定初始化和销毁方法
        context.registerBean("bean1", Bean1.class, Bean1::new, beanDefinition -> {
            beanDefinition.setInitMethodName("init");
            beanDefinition.setDestroyMethodName("destroy");
        });
        // 初始化容器
        context.refresh();
        Bean1 bean = context.getBean(Bean1.class);
        bean.print();
        // 销毁容器
        context.close();
    }
}

@Slf4j
class Bean1 {
    public void print() {
        log.info("I am bean1");
    }
    public void init() {
        log.info("Bean1 is being initialized");
    }
    public void destroy() {
        log.info("Bean1 is being destroyed");
    }
}

通过输出可以发现，bean1的初始化和销毁回调被调用了。

15:14:23.631 [main] INFO io.yulin.learn.spring.s104.Bean1 -- Bean1 is being initialized
15:14:23.669 [main] INFO io.yulin.learn.spring.s104.Bean1 -- I am bean1
15:14:23.670 [main] INFO io.yulin.learn.spring.s104.Bean1 -- Bean1 is being destroyed

把整个过程改为更熟悉的基于注解驱动开发的方式，代码如下。

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 通过注解方式配置Bean
 * @author nine
 * @since 1.0
 */
public class BeanDefinitionProcessAnnotationDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(BeanAnnotation1.class);
        context.refresh();

        BeanAnnotation1 bean = context.getBean(BeanAnnotation1.class);
        bean.print();
        context.close();
    }
}

@Slf4j
class BeanAnnotation1 {
    public void print() {
        log.info("I am BeanAnnotation1");
    }

    @PostConstruct
    public void init() {
        log.info("BeanAnnotation1 is being initialized");
    }

    @PreDestroy
    public void destroy() {
        log.info("BeanAnnotation1 is being destroyed");
    }
}

输出结果基本一致的。

通过这个转换过程可以更能清晰的发现，Spring如何从基于xml配置、Java配置、注解配置的转换。也能更加深刻体会到Spring的强大兼容性。

实例化Bean

需要使用bean就必须实例化这个类，最简单的方式就是new 一个对象。

但是在Spring6框架中提供了更多的配置来实现实例化bean。

如果使用基于XML的配置元数据，可以在<bean/>元素的class属性中指定要实例化的对象的类型（或类）。

这个class属性（在BeanDefinition实例上内部是一个Class属性）通常是必需的。

使用Class属性的两种方式之一：

  • 通常情况下，为了指定要构造的bean类，在容器本身通过调用其构造函数反射性地直接创建bean的情况下，类似于使用new运算符的Java代码。
  • 在较不常见的情况下，为了指定包含静态工厂方法的实际类，容器调用该类上的静态工厂方法来创建bean。从调用静态工厂方法返回的对象类型可以是相同的类，也可以是完全不同的类。

构造器实例化bean

当通过构造函数方式创建一个bean时，所有普通类都可以被Spring使用并与之兼容。

也就是说，正在开发的类不需要实现任何特定的接口或以特定方式编码。只需指定bean类即可。

然而，根据为该特定bean使用的IoC类型，可能需要一个默认（空）构造函数。

Spring IoC容器可以管理几乎任何希望它管理的类。它不局限于管理真正的JavaBeans。

大多数Spring用户更喜欢具有仅默认（无参数）构造函数。

Spring容器还可以管理非bean的类。例如，如果需要使用不符合JavaBean规范的传统连接池，Spring也可以进行管理。

下面通过一个例子说明基于构造器实例化bean的例子。

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * SpringBean创建demo
 *
 * @author nine
 * @since 1.0
 */
public class SpringBeanCreateDemo {

    public static void main(String[] args) {
        // 创建一个基于 Java Config 的应用上下文
        ApplicationContext context = new AnnotationConfigApplicationContext(AppCreateConfig.class);
        // 从上下文中获取名bean，其类型为PetStoreService
        MyClass bean = context.getBean(MyClass.class);
        // 调用获取的bean的方法
        bean.hello("jack");
    }
}

@Configuration
@Slf4j
class AppCreateConfig {
    @Bean
    public MyClass exampleBean() {
        return new MyClass("exampleConstructorArg");
    }
}

@Slf4j
class MyClass {
    public MyClass(String constructorArg) {
        log.info(constructorArg);
    }

    public void hello(String name) {
        log.info("hello " + name);
    }
}

输出结果如下。可以看到MyClass类被正确初始化和被IoC容器管理。

09:44:57.211 [main] INFO io.yulin.learn.spring.s104.MyClass -- exampleConstructorArg
09:44:57.262 [main] INFO io.yulin.learn.spring.s104.MyClass -- hello jack

静态工厂方法实例化bean

在定义使用静态工厂方法创建的bean时，使用class属性指定包含静态工厂方法的类，并使用名为factory-method的属性指定工厂方法本身的名称。

应该能够调用这个方法（带有可选参数，如后面所述），并返回一个活动对象，随后将其视为通过构造函数创建的对象。

这样一个bean定义的用途之一是在遗留代码中调用静态工厂。

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * SpringBean创建demo
 *
 * @author nine
 * @since 1.0
 */
public class SpringBeanFactoryMethodCreateDemo {

    public static void main(String[] args) {
        // 创建一个基于 Java Config 的应用上下文
        ApplicationContext context = new AnnotationConfigApplicationContext(AppFactoryConfig.class);
        // 从上下文中获取名bean，其类型为PetStoreService
        AppFactoryConfig.MyBean bean = context.getBean(AppFactoryConfig.MyBean.class);
        // 调用获取的bean的方法
        bean.hello();
    }
}

@Slf4j
@Configuration
class AppFactoryConfig {

    @Bean
    public MyBean myBean() {
        // 调用带有可选参数的静态工厂方法创建 bean
        return MyBeanFactory.createBean("Tom");
    }

    static class MyBean {
        private String name;

        public MyBean(String name) {
            this.name = name;
        }

        public void hello() {
            log.info("Hello, " + name);
        }
    }

    static class MyBeanFactory {
        public static MyBean createBean(String parameter) {
            return new MyBean(parameter);
        }
    }
}

通过实例工厂方法实例化bean

类似于通过静态工厂方法进行实例化，使用实例工厂方法进行实例化会调用容器中现有 bean 的非静态方法来创建一个新的 bean。

要使用这种机制，将class属性留空，在factory-bean属性中指定当前（或父级或祖先）容器中包含要被调用以创建对象的实例方法的 bean 的名称。

使用factory-method属性设置工厂方法本身的名称。

这个例子是基于java config来实现的。

可以发现MyBean通过现有名为MyBeanFactory的bean来创建的。

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

@Configuration
public class AppBeanCreateConfig {
    @Bean
    public MyBeanFactory myBeanFactory() {
        return new MyBeanFactory();
    }

    @Bean
    public MyBean myBean(MyBeanFactory myBeanFactory) {
        // 调用实例工厂方法创建 bean
        return myBeanFactory.createBean("optionalParameter");
    }

    static class MyBean {
        private String name;

        public MyBean(String name) {
            this.name = name;
        }

        public void hello() {
            System.out.println("Hello, " + name);
        }
    }

    static class MyBeanFactory {
        public MyBean createBean(String parameter) {
            return new MyBean(parameter);
        }
    }
}

确定Bean的运行时类型

确定Spring框架中一个特定bean的运行时类型确实需要考虑到多种复杂情况。

在bean元数据定义中指定的类只是一个初始类引用，可能与声明的工厂方法结合，或者是一个可能导致bean具有不同运行时类型的FactoryBean类，或者在实例级工厂方法的情况下根本没有设置（这是通过指定的工厂-bean 名称来解析的）。

此外，AOP代理可能会用基于接口的代理包装一个bean实例，只暴露目标bean的实际类型（仅暴露其实现的接口）。

查找特定bean的实际运行时类型的推荐方法是使用BeanFactory.getType调用指定的bean名称。

这考虑了上述所有情况，并返回BeanFactory.getBean调用将为相同的bean名称返回的对象类型。

以上面的通过实例工厂方法实例化bean为例说明使用BeanFactory.getType。

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

@Slf4j
public class BeanRunTimeTypeTest {

    @Test
    public void test() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppBeanCreateConfig.class);
        // 获取 BeanFactory 实例
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 使用 BeanFactory.getType 方法获取特定 bean 的运行时类型
        Class<?> beanType = beanFactory.getType("myBean");
        log.info("The runtime type of 'myBean' is: " + beanType.getName());
        // 使用 BeanFactory.getBean 方法获取特定 bean 的实例对象
        AppBeanCreateConfig.MyBean myBeanInstance = (AppBeanCreateConfig.MyBean) beanFactory.getBean("myBean");
        myBeanInstance.hello();
        // 关闭应用上下文
        context.close();
    }
}

输出结果如下。可以看到实例工厂方法没有设置class，但是运行时类型为MyBean。

10:51:25.111 [main] INFO io.yulin.learn.spring.s104.BeanRunTimeTypeTest -- The runtime type of 'myBean' is: io.yulin.learn.spring.s104.AppBeanCreateConfig$MyBean
Hello, optionalParameter

BeanFactory.getType()一些常见用途：

  • 类型检查：通过调用 getType() 方法，可以获取特定 bean 的实际类型，并根据这些类型信息执行相应的操作。这对于在运行时进行类型检查和验证非常有用。
  • 动态处理：在某些情况下，您可能需要根据 bean 的类型来动态地决定如何处理该 bean。通过 getType() 方法可以获取 bean 的类型信息，并根据需要执行相应的处理逻辑。
  • 条件化配置：在 Spring 应用程序中，有时根据 bean 的类型来进行条件化的配置会很有用。通过 getType() 方法可以获取 bean 的类型，从而根据不同的类型执行不同的配置。
  • 自定义逻辑：某些情况下，可能需要根据 bean 的类型来编写特定的业务逻辑。通过 getType() 方法可以获取 bean 的准确类型信息，并在代码中编写相应的逻辑。

关于作者

来自全栈程序员nine的探索与实践，持续迭代中。

欢迎关注或者点个小红心~

nine是个工程师
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IOC装配Bean过程解析
08-19
主要介绍了Spring IOC装配Bean过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring入门教程之bean的继承与自动装配详解
08-28
众所周知Spring里面的bean就类似是定义的一个组件,而这个组件的作用就是实现某个功能的，下面这篇文章主要给大家介绍了关于spring入门教程之bean继承与自动装配的相关资料，需要的朋友可以参考借鉴，下面随着小编来...
Spring Bean 生命周期常见错误
xiaoshitou_2015的博客
02-02 1024
显然 shutdown 方法未按照预期被执行了，这导致一个很有意思的 bug：在使用新的 Bean 生成方式之前，每一次宿舍管理服务被重启时，宿舍里所有的灯都不会被关闭。如何理解这个 bug?上述代码完整地展示了 Bean 初始化的三个关键步骤，createBeanInstance，populateBean，initializeBean，分别对应实例化 Bean，注入 Bean 依赖，以及初始化 Bean （例如执行 @PostConstruct 标记的方法 ）这三个功能，这也和上述时序图的流程相符。
【Spring系列02】快速上手Spring
qq_52384627的博客
09-03 139
😊😊😊欢迎来到本博客😊😊😊 📫作者简介：阿斯卡码，专注于研究Java框架/Vue，就读于河南中医药大学，刚刚入门项目开发📫 🏆 CSDN编程比赛奖章获得者/Java领域创作者🏆 🔥计划学习：深入学习Spring全家桶，Vue, mybatis,Mysql等领域。(目前涉及不深入)🔥 👍如果此文还不错的话，还请👍关注、点赞、收藏三连支持👍一下博主~
Spring 学习02：上手Spring
qq_43602877的博客
12-23 71
Spring 学习02：上手Spring 上一篇文章介绍了Spring，那接下来肯定就要上手了 Hello Spring： 导入jar包 在 pow.xml 导入jar包，spring 需要导入commons-logging进行日志记录 。 我们利用maven , 他会自动下载对应的依赖项 .junit用于测试类 <dependency> <groupId>org.springframework</groupId> <artifactId&
Spring---快速上手Spring
乐褀的博客
08-05 141
Spring—快速上手Spring 我们的征途是星辰大海，而非人间烟尘 文章目录Spring---快速上手SpringHelloSpring修改案例一IOC 创建对象的方式通过无参构造方法来创建通过有参构造方法来创建Spring配置 HelloSpring 导入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-we
快速上手Spring
胖胖爱吃肉~的博客
03-16 79
快速上手Spring HelloSpring 导入Jar包 注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 . <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.10.RELEAS
springcloud简单了解及上手
m0_71494074的博客
05-12 985
SpringCloud的nacos，feign , gateway的简单使用
Spring之装配Bean
jay_________的专栏
11-23 431
一、环境准备 1.spring-framework jar包的下载 https://repo.spring.io/webapp/#/artifacts/browse/simple/General/libs-release-local/org/springframework/spring/4.1.2.RELEASE      下载解压后文件夹目录如下图所示：      docs文件
Spring从入门到入土——Bean的作用域
冢狐的私人空间
05-05 851
Bean的作用域Bean的作用域SingletonPrototypeRequestSession Bean的作用域 ​ 在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 类别 说明 singleton 在Spring Ioc容器中仅存在一个Bean实例，Bean以单例方式存...
案例上手 Spring 全家桶
GitChat
07-21 6296
《案例上手 Spring 全家桶》课程亮点spring boot面试题 Spring 技术零基础轻松入门 spring boot 68 讲更全面地覆盖 Spring 全家桶核心模块 100+ 段代码示例，理解 Spring 全家桶要领 3 大项目实战，掌握 Spring 全家桶实际应用 精选 70 道 Spring 高频面试题检验学习成果 免费赠送 16+ 小时的 Spring 实战视频 Spr...
详解Spring简单容器中的Bean基本加载过程
08-30
本篇将对定义在 XMl 文件中的 bean，从静态的的定义到变成可以使用的对象的过程，即 bean 的加载和获取的过程进行一个整体的了解
Spring自动装配Bean实现过程详解
08-25
主要介绍了Spring自动装配Bean实现过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Bean常用的的装配方式详解
08-25
主要介绍了Spring Bean常用的的装配方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 896
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1207
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 669
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
springbean 自动装配
06-09
SpringBean 自动装配是 Spring 框架中的一种特性，它允许 Spring 容器自动将一个 Bean 对象注入到另一个 Bean 对象中，而不需要手动进行配置。SpringBean 自动装配可以大大减少配置文件的编写量，提高开发效率。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值