Spring常见面试题知识点总结（一）

1. Spring框架基础：

Spring框架的发展历史。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
Spring框架的发展历史可以追溯到2002年。以下是Spring框架的主要发展阶段：

1. 2002年：Spring 1.0发布

   • Spring框架由Rod Johnson发布第一个版本，旨在简化企业级Java开发。Spring 1.0包含了IoC容器、AOP支持、事务管理等核心功能。

2. 2004年：Spring 1.2发布

   • Spring 1.2引入了对AspectJ的集成，进一步加强了AOP功能。同时，引入了对Java 5特性的支持，如泛型和注解。

3. 2004年：Spring 2.0发布

   • Spring 2.0是一个里程碑版本，引入了许多重要的新特性，包括注解驱动的IoC和AOP、Java 5支持、基于POJO的持久性框架（Spring DAO）、新的Web模块等。

4. 2007年：Spring 2.5发布

   • Spring 2.5继续构建在2.0的基础上，引入了许多新功能，如注解驱动的组件扫描、Spring EL（表达式语言）等。同时，这个版本进一步加强了对Java 5和Java 6的支持。

5. 2009年：Spring 3.0发布

   • Spring 3.0带来了许多重要的变化，其中包括Spring Expression Language（SpEL）、REST支持、模块化的环境配置、Spring 3.0注解等。此版本还删除了对J2EE的依赖，使Spring更加独立。

6. 2013年：Spring 3.2发布

   • Spring 3.2引入了许多改进，包括对Java 7的支持、新的缓存抽象、对Servlet 3.0的支持等。

7. 2014年：Spring 4.0发布

   • Spring 4.0引入了对Java 8的支持、泛型和条件化的注解等新功能。此外，Spring 4.0对REST和Websocket的支持也有所增强。

8. 2015年：Spring 4.1发布

   • Spring 4.1进一步增强了对Java 8的支持，同时引入了新的注解、SpEL语法的改进和对JMS的改进。

9. 2016年：Spring 4.2发布

   • Spring 4.2引入了对HTTP/2的支持、对WebSockets的改进、新的注解、条件化的注解等。

10. 2018年：Spring 5.0发布

    • Spring 5.0是一个重要的版本，首次完全采用了Java 8，并开始支持Java 9和Java 10。引入了Reactive编程模型，提供了Spring WebFlux，支持响应式编程。

11. 2020年：Spring 5.2发布

    • Spring 5.2继续在5.x系列上进行改进，引入了对Java 13和14的支持、对RSocket的支持、新的测试注解等。

12. 2021年：Spring 5.3发布

    • Spring 5.3进一步加强了对Java 17的支持，提供了更多的功能改进和性能优化。

Spring框架的核心目标和优势。

Spring框架的核心目标是简化企业级Java应用程序的开发和集成，通过提供全面的基础设施和支持来实现这一目标。以下是Spring框架的核心目标和优势：

核心目标：

1. 简化开发： 提供了一种轻量级的开发方式，通过IoC和依赖注入，减少了大量样板代码，使开发更加简洁。

2. 提高可测试性： 通过将业务逻辑与底层框架解耦，使代码更容易进行单元测试和集成测试。

3. 促进松耦合： 通过控制反转（IoC）和面向切面编程（AOP）等特性，帮助实现系统组件之间的松耦合，提高系统的可维护性和可扩展性。

4. 提供一致性： 提供一致的事务管理、异常处理和数据访问方式，使开发者能够更容易理解和应用这些关键领域。

5. 支持各种数据访问： 集成了不同的数据访问技术，包括JDBC、ORM框架（如Hibernate）、JPA等，使得数据访问更加便捷。

6. 提供全面的功能： Spring框架提供了广泛的功能，包括事务管理、安全性、缓存、邮件、调度等，使得开发者能够快速构建出健壮、全功能的应用。

7. 支持面向切面编程： 通过AOP的支持，能够将横切关注点（如日志、事务、安全性）与核心业务逻辑分离，提高代码的可维护性。

8. 支持响应式编程： 引入了Reactive编程模型，提供了对响应式流的支持，使得构建高性能、异步、非阻塞的应用更为容易。

优势：

1. 模块化： Spring框架是模块化的，开发者可以根据项目需要选择使用特定的模块，提高了灵活性和可维护性。

2. 松耦合： 通过IoC和AOP的支持，实现了组件之间的松耦合，降低了组件之间的依赖性，提高了系统的灵活性。

3. 可扩展性： 框架的设计允许开发者通过自定义扩展点来扩展功能，使得应用程序更容易适应变化。

4. 广泛的社区支持： Spring框架拥有庞大而活跃的社区，提供了大量的文档、教程和社区支持，使得开发者可以更轻松地学习和使用框架。

5. 良好的设计理念： Spring框架遵循了良好的设计原则，如开闭原则、单一职责原则，使得框架的代码清晰、可读性强。

6. 与其他技术的整合： Spring框架可以与许多其他流行的技术和框架无缝整合，如Hibernate、MyBatis、Spring Boot等。

7. 强大的事务管理： 提供了灵活、强大的事务管理机制，支持声明式事务和编程式事务，确保了数据的一致性和可靠性。

8. 广泛的应用领域： Spring框架在企业级应用、Web应用、移动应用、云计算等领域都有广泛的应用，是一个通用的解决方案。

Spring的版本和发布周期。

Spring框架的版本和发布周期取决于其各个模块的更新和改进。以下是Spring框架的一些主要版本及其发布周期的概要：

1. Spring 1.0： 发布于2004年。

2. Spring 2.0： 发布于2006年11月。

   • 引入了注解驱动的IoC和AOP。
   • 对Java 5的支持。

3. Spring 2.5： 发布于2007年11月。

   • 引入了注解驱动的依赖注入。
   • 引入了Spring MVC的注解支持。
   • 对Java 6的支持。

4. Spring 3.0： 发布于2009年12月。

   • 引入了Spring Expression Language (SpEL)。
   • 放弃了对J2EE的依赖，支持Java 5及以上版本。
   • 引入了REST风格的Spring MVC。

5. Spring 3.1： 发布于2011年12月。

   • 引入了条件化的Bean声明和加载。
   • 对Java 7的支持。

6. Spring 3.2： 发布于2012年12月。

   • 对Java 8的初步支持。
   • 引入了对Servlet 3.0的支持。

7. Spring 4.0： 发布于2013年12月。

   • 对Java 8的完整支持。
   • 引入了条件化的注解。
   • 引入了WebSocket支持。

8. Spring 4.1： 发布于2014年9月。

   • 对Java 8的更多支持。
   • 对REST和Spring MVC的改进。

9. Spring 4.2： 发布于2015年7月。

   • 对Java 8的更多支持。
   • 对WebSockets和REST的改进。

10. Spring 4.3： 发布于2016年6月。

    • 对Java 8的更多支持。
    • 对泛型的改进。

11. Spring 5.0： 发布于2017年9月。

    • 对Java 8的完整支持。
    • 引入了响应式编程模型。
    • 移除了对Servlet 2.5和3.0的支持。

12. Spring 5.1： 发布于2018年10月。

    • 对Java 11的支持。
    • 对WebFlux和Spring MVC的改进。

13. Spring 5.2： 发布于2019年7月。

    • 对Java 13和14的支持。
    • 对WebFlux的改进。

14. Spring 5.3： 发布于2020年10月。

    • 对Java 17的支持。
    • 引入了新的测试注解。

15. Spring 5.4： 发布于2020年11月。

    • 对Java 17的支持。
    • 引入了对模块路径的支持。

Spring生态系统的其他项目，如Spring Boot、Spring Cloud等。

Spring生态系统是一个庞大的生态系统，包含许多项目，其中一些是核心框架的扩展或补充。以下是Spring生态系统的一些重要项目：

1. Spring Boot：

   • 简介： Spring Boot是用于简化和加速Spring应用程序开发的项目。它提供了开箱即用的默认配置，并支持自动配置，使得开发者可以更专注于业务逻辑。
   • 关键特性： 自动配置、嵌入式Web服务器（如Tomcat、Jetty）、约定大于配置、快速开发、生产就绪的特性。

2. Spring Cloud：

   • 简介： Spring Cloud是用于构建分布式系统的一组工具。它提供了微服务架构的解决方案，包括服务发现、配置管理、负载均衡等。
   • 关键特性： 服务发现、负载均衡、分布式配置、断路器、消息总线等。

3. Spring Data：

   • 简介： Spring Data是一组用于简化数据访问的项目。它提供了对各种数据存储的抽象和简化的数据访问模型。
   • 关键特性： 统一的Repository模型、查询方法、对关系型数据库和NoSQL数据库的支持。

4. Spring Security：

   • 简介： Spring Security是用于在Spring应用程序中提供身份验证和授权的框架。它支持多种身份验证机制和授权模型。
   • 关键特性： 身份验证、授权、基于角色的访问控制、OAuth支持等。

5. Spring Batch：

   • 简介： Spring Batch是一个用于批处理应用程序的框架。它提供了大量的工具和功能，用于处理大规模数据的批量处理。
   • 关键特性： 事务性批处理、可伸缩的并行处理、失败重试、任务监控等。

6. Spring Integration：

   • 简介： Spring Integration是一个用于构建企业集成模式（EIP）的框架。它提供了消息传递和消息驱动的方式，用于构建分布式系统。
   • 关键特性： 通道和适配器模式、消息路由、事务性消息、集成流程等。

7. Spring WebSocket：

   • 简介： Spring WebSocket是用于实现WebSocket通信的模块。它使得在Spring应用程序中可以轻松实现实时的双向通信。
   • 关键特性： 支持WebSocket协议、STOMP协议、广播和点对点通信等。

8. Spring Boot Admin：

   • 简介： Spring Boot Admin是用于监控和管理Spring Boot应用程序的一套工具。它提供了Web界面，显示了注册的Spring Boot应用程序的运行状况和详细信息。
   • 关键特性： 应用程序监控、日志查看、环境配置等。

2. 控制反转（IoC）：

IoC的概念和原理。

IoC（Inversion of Control）是一种软件设计思想，它反转了传统的程序设计流程中对象的控制权。在传统的程序设计中，程序员通过直接调用对象的方法来控制对象的行为。而在IoC中，控制权被反转，对象不再由程序员直接控制，而是由容器（框架）来控制。

概念：

IoC的核心思想是将对象的创建、组装和管理交给框架或容器，而不是由程序员手动进行控制。在IoC中，对象的生命周期和依赖关系由容器来管理，程序员只需要关注业务逻辑的编写。IoC通过依赖注入（Dependency Injection）来实现，即将一个对象所需的依赖关系注入到对象中。

原理：

IoC的原理主要包括以下几个方面：

1. 控制反转： 在IoC中，控制权被反转，对象的创建和管理由容器来负责。这种反转是通过将对象的创建和依赖关系的管理从应用程序代码中移出，交给容器来完成。

2. 依赖注入： IoC通过依赖注入来实现对象之间的解耦。依赖注入是指将一个对象所需的依赖关系注入到对象中，而不是由对象自己创建或查找依赖对象。这可以通过构造函数注入、方法注入、属性注入等方式实现。

3. 容器： IoC容器是负责管理和组装对象的框架。容器负责创建对象、注入依赖关系、管理对象的生命周期等任务。常见的IoC容器包括Spring容器、Guice等。

4. 配置： IoC容器通过配置文件或注解等方式来配置对象的创建和依赖关系。配置文件中描述了对象的类型、依赖关系、生命周期等信息，容器根据配置来完成对象的创建和管理。

5. 生命周期管理： IoC容器负责管理对象的生命周期，包括对象的创建、初始化、使用和销毁等阶段。容器根据配置信息来决定对象的创建和销毁时机。

示例：

以下是一个简单的Java示例，演示了IoC的概念和原理：

// 服务接口
public interface Service {
    void execute();
}

// 具体的服务实现类
public class MyService implements Service {
    @Override
    public void execute() {
        System.out.println("Executing MyService");
    }
}

// 客户端类
public class Client {
    private Service service;

    // 通过构造函数注入依赖关系
    public Client(Service service) {
        this.service = service;
    }

    public void performAction() {
        // 客户端使用服务
        service.execute();
    }
}

// 应用程序入口
public class Application {
    public static void main(String[] args) {
        // 创建IoC容器
        // 在Spring框架中，可以使用ApplicationContext来作为IoC容器
        ApplicationContext context = new ApplicationContext();

        // 从容器中获取服务对象
        Service myService = context.getBean(MyService.class);

        // 客户端通过构造函数注入依赖关系
        Client client = new Client(myService);

        // 客户端执行操作
        client.performAction();
    }
}

在上述示例中，Client类依赖于Service接口，通过构造函数注入了具体的MyService实现。IoC容器负责管理MyService的创建和注入到Client中，实现了对象之间的解耦。这是一个简化的示例，实际中Spring等IoC框架会提供更丰富的功能和配置方式。

Spring容器的类型，如BeanFactory和ApplicationContext。

Spring容器是用于管理和组装对象的核心组件。Spring提供了不同类型的容器，其中两个主要的容器是BeanFactory和ApplicationContext。

1. BeanFactory：
   • 概念： BeanFactory是Spring框架中最基本的容器接口。它负责管理Spring中的对象（称为Bean）的生命周期和依赖关系。
   • 特点： BeanFactory是一个轻量级的容器，延迟加载（懒加载）机制，即只有在需要使用Bean时才会进行实例化。
   • 使用场景： 对于资源有限的环境或需要按需加载Bean的场景，可以使用BeanFactory。

// 示例代码
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
MyService myService = (MyService) beanFactory.getBean("myService");

2. ApplicationContext：
   • 概念： ApplicationContext是BeanFactory的扩展，提供了更多的功能和特性。它是一个全功能的容器，负责管理Bean的生命周期、依赖注入、AOP等。
   • 特点： ApplicationContext在启动时就会将所有的Bean实例化，提供更快的访问速度，支持多种配置方式，包括XML配置、注解配置和Java配置等。
   • 使用场景： 在大多数场景中，推荐使用ApplicationContext，因为它提供了更多的功能和更方便的配置方式。

// 示例代码
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
MyService myService = (MyService) applicationContext.getBean("myService");

总体而言，BeanFactory是一个基础的容器接口，而ApplicationContext是更高级和功能更全面的容器。在实际开发中，大多数情况下会选择使用ApplicationContext，因为它提供了更多的便利特性，并支持更灵活的配置方式。

XML配置和注解配置的IoC容器设置。

在Spring中，IoC容器的配置方式主要包括XML配置和注解配置两种方式。这两种配置方式分别使用不同的元数据形式，用于描述Bean的定义、依赖关系、生命周期等信息。

1. XML配置方式：

XML配置是一种传统的配置方式，通过XML文件描述应用程序的Bean定义和配置信息。以下是一个简单的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 -->
    <bean id="myService" class="com.example.MyService">
        <!-- 设置属性 -->
        <property name="message" value="Hello, Spring!"/>
    </bean>

    <!-- 其他配置... -->

</beans>

2. 注解配置方式：

注解配置是一种基于Java注解的配置方式，通过在Java类上使用注解来定义Bean和配置信息。以下是一个简单的注解配置示例：

// AppConfig.java

@Configuration // 声明该类为配置类
public class AppConfig {

    @Bean // 定义一个Bean
    public MyService myService() {
        MyService service = new MyService();
        service.setMessage("Hello, Spring!");
        return service;
    }

    // 其他配置...

}

在上述示例中，@Configuration注解表示这是一个配置类，@Bean注解表示该方法返回的对象将被注册为一个Bean。

使用方式：

XML配置方式的容器获取：

// 使用XML配置方式
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
MyService myService = (MyService) beanFactory.getBean("myService");

注解配置方式的容器获取：

// 使用注解配置方式
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
MyService myService = (MyService) applicationContext.getBean(MyService.class);

注意： 在实际项目中，通常会使用更先进的Spring Boot来简化配置和提供更多功能。Spring Boot主要使用注解配置，且不需要显式的XML配置文件。

使用构造函数和Setter方法进行依赖注入。

在Spring中，依赖注入可以通过构造函数注入和Setter方法注入两种方式来实现。这两种方式都是为了将依赖关系传递给Bean。以下是使用构造函数和Setter方法进行依赖注入的示例：

1. 构造函数注入：

通过构造函数注入是一种简单且常用的依赖注入方式。通过在类的构造函数中接收依赖对象，Spring容器在创建Bean的时候会自动将依赖对象传递进来。

// ServiceA.java
public class ServiceA {
    private ServiceB serviceB;

    // 构造函数注入
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    // 其他方法...
}

// ServiceB.java
public class ServiceB {
    // 具体实现...
}

<!-- applicationContext.xml -->
<bean id="serviceA" class="com.example.ServiceA">
    <constructor-arg ref="serviceB"/> <!-- 通过构造函数注入ServiceB依赖 -->
</bean>

<bean id="serviceB" class="com.example.ServiceB"/>

2. Setter方法注入：

通过Setter方法注入是另一种常见的依赖注入方式。通过在类中定义Setter方法，Spring容器在创建Bean后会调用这些方法，将依赖对象传递给Bean。

// ServiceC.java
public class ServiceC {
    private ServiceD serviceD;

    // Setter方法注入
    public void setServiceD(ServiceD serviceD) {
        this.serviceD = serviceD;
    }

    // 其他方法...
}

// ServiceD.java
public class ServiceD {
    // 具体实现...
}

<!-- applicationContext.xml -->
<bean id="serviceC" class="com.example.ServiceC">
    <property name="serviceD" ref="serviceD"/> <!-- 通过Setter方法注入ServiceD依赖 -->
</bean>

<bean id="serviceD" class="com.example.ServiceD"/>

使用方式：

// 使用构造函数注入
ServiceA serviceA = (ServiceA) applicationContext.getBean("serviceA");

// 使用Setter方法注入
ServiceC serviceC = (ServiceC) applicationContext.getBean("serviceC");

在上述示例中，ServiceA通过构造函数注入了ServiceB，而ServiceC通过Setter方法注入了ServiceD。Spring容器负责解析XML配置，创建Bean，并自动注入相关的依赖关系。选择使用构造函数注入还是Setter方法注入，通常取决于项目的具体需求和设计风格。

基于接口的依赖注入。

在Spring中，基于接口的依赖注入是通过在类中定义接口类型的成员变量，并通过构造函数或Setter方法将实现该接口的具体类注入到Bean中。这种方式提高了代码的灵活性和可维护性，允许在运行时更容易替换实现类。

以下是一个基于接口的依赖注入的示例：

1. 接口定义：

// Service.java
public interface Service {
    void execute();
}

2. 接口实现类：

// ServiceImplA.java
public class ServiceImplA implements Service {
    @Override
    public void execute() {
        System.out.println("Executing ServiceImplA");
    }
}

// ServiceImplB.java
public class ServiceImplB implements Service {
    @Override
    public void execute() {
        System.out.println("Executing ServiceImplB");
    }
}

3. 使用接口的类：

// Client.java
public class Client {
    private Service service;

    // 构造函数注入
    public Client(Service service) {
        this.service = service;
    }

    // Setter方法注入
    public void setService(Service service) {
        this.service = service;
    }

    public void performAction() {
        // 调用接口方法
        service.execute();
    }
}

4. XML配置：

<!-- applicationContext.xml -->

<bean id="serviceImplA" class="com.example.ServiceImplA"/>
<bean id="serviceImplB" class="com.example.ServiceImplB"/>

<bean id="client" class="com.example.Client">
    <constructor-arg ref="serviceImplA"/> <!-- 构造函数注入 ServiceImplA -->
    <!-- 或者使用 Setter 方法注入 -->
    <!-- <property name="service" ref="serviceImplA"/> -->
</bean>

5. 获取Bean：

// 获取Client Bean
Client client = (Client) applicationContext.getBean("client");
client.performAction();

在上述示例中，Client类通过构造函数注入或Setter方法注入Service接口类型的依赖，通过XML配置文件将具体实现类ServiceImplA注入到Client中。这样，通过更换具体的实现类，可以轻松地改变Client的行为，实现了依赖注入的灵活性。

3. 依赖注入（DI）：

DI的定义和优势。

DI（Dependency Injection）依赖注入 是一种设计模式，它通过将对象所需的依赖关系从对象本身分离出来，由外部容器（通常是框架或容器）来负责管理和注入。依赖注入的目的是解耦组件之间的依赖关系，提高代码的灵活性、可维护性和可测试性。

依赖注入的定义：

在依赖注入中，对象不再负责创建或查找它所依赖的对象，而是由外部容器负责将依赖关系注入到对象中。依赖注入有两种主要形式：

1. 构造函数注入（Constructor Injection）： 通过对象的构造函数将依赖关系传递给对象。
2. Setter方法注入（Setter Injection）： 通过对象的Setter方法将依赖关系注入到对象。

依赖注入的优势：

1. 解耦和模块化： 依赖注入将对象的依赖关系从对象本身解耦出来，使得对象的设计更加模块化。各个模块之间的依赖关系更加清晰，易于理解和维护。

2. 可测试性： 由于依赖关系是外部容器注入的，因此在进行单元测试时，可以轻松地替换依赖的模拟对象，从而提高代码的可测试性。

3. 灵活性： 依赖注入使得系统更加灵活，能够在运行时更容易地替换具体的实现类，而不需要修改依赖类的代码。

4. 可维护性： 由于依赖关系集中在容器中管理，当需要修改依赖关系时，只需修改容器的配置而不影响依赖类的代码。这提高了代码的可维护性。

5. 可扩展性： 通过依赖注入，系统的功能可以更容易地进行扩展。新增一个模块只需要配置容器，而不需要修改其他模块的代码。

6. 提高代码复用： 通过依赖注入，依赖的对象可以被多个模块共享，从而提高代码的复用性。

Spring中如何通过@Autowired和@Qualifier进行注入。

在Spring中，@Autowired和@Qualifier是两个常用的注解，用于实现自动装配（Autowired）时对依赖的指定（Qualifier）。

1. @Autowired注解：

@Autowired注解用于自动装配Spring容器中的Bean。它可以标记在构造函数、Setter方法、字段（属性）上，Spring容器会在需要注入依赖时自动查找匹配的Bean，并将其注入到目标对象中。

1.1 构造函数注入：

public class MyClass {
    private MyDependency myDependency;

    @Autowired
    public MyClass(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    // 其他方法...
}

1.2 Setter方法注入：

public class MyClass {
    private MyDependency myDependency;

    @Autowired
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    // 其他方法...
}

1.3 字段注入：

public class MyClass {
    @Autowired
    private MyDependency myDependency;

    // 其他方法...
}

2. @Qualifier注解：

@Qualifier注解用于在存在多个匹配的Bean时，指定具体要注入的Bean。它通常与@Autowired一起使用。

public class MyClass {
    private MyDependency myDependency;

    @Autowired
    @Qualifier("specificBeanName") // 指定要注入的Bean的名称
    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    // 其他方法...
}

在上述示例中，@Autowired注解用于告诉Spring容器要自动注入MyDependency类型的Bean。而@Qualifier("specificBeanName")则指定了要注入的具体Bean的名称。

如果没有使用@Qualifier，且存在多个匹配的Bean时，Spring会抛出异常。使用@Qualifier可以明确指定要注入的Bean，避免歧义。

注意： 在使用@Autowired和@Qualifier时，通常建议将@Autowired放在构造函数或Setter方法上，然后结合@Qualifier使用。这样可以提高代码的可读性和一致性。

使用@Value进行属性注入。

在Spring中，@Value注解用于通过配置文件注入属性值或直接注入常量值。这个注解可以用在字段、方法参数、构造函数参数上，以便在运行时将值注入到标记的位置。

1. 注入属性值：

1.1 注入配置文件中的属性值：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @Value("${my.property.key}")
    private String myPropertyValue;

    // 其他方法...
}

在上述示例中，@Value("${my.property.key}")用于从配置文件中读取名为my.property.key的属性值并注入到myPropertyValue字段中。

1.2 直接注入常量值：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @Value("Hello, Spring!")
    private String myConstantValue;

    // 其他方法...
}

在这个例子中，@Value("Hello, Spring!")直接将常量字符串 “Hello, Spring!” 注入到myConstantValue字段中。

2. 注入方法参数：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private String myPropertyValue;

    // 注入到方法参数
    public void setMyPropertyValue(@Value("${my.property.key}") String myPropertyValue) {
        this.myPropertyValue = myPropertyValue;
    }

    // 其他方法...
}

在这个例子中，@Value("${my.property.key}")被用于注入到setMyPropertyValue方法的参数中。

3. 注入构造函数参数：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private final String myPropertyValue;

    // 构造函数注入
    public MyComponent(@Value("${my.property.key}") String myPropertyValue) {
        this.myPropertyValue = myPropertyValue;
    }

    // 其他方法...
}

在这个例子中，@Value("${my.property.key}")用于注入到构造函数的参数中。

注意： 使用@Value注解时，确保配置文件中存在对应的属性键，并且在类上使用@Component或其他适当的注解，以便Spring容器能够扫描并创建该类的Bean。

使用Java配置类进行依赖注入。

在Spring中，可以使用Java配置类（JavaConfig）来进行依赖注入，取代传统的XML配置方式。通过Java配置，可以更灵活地配置Bean及其依赖关系，并且可以利用Java的编译时类型检查。

以下是一个简单的Java配置类的示例：

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean
    public MyComponent myComponent(MyService myService) {
        return new MyComponent(myService);
    }
}

在这个示例中，@Configuration注解表明这是一个Java配置类。@Bean注解用于定义Bean，方法的名称即为Bean的名称。MyService和MyComponent是两个简单的类，myComponent方法中的myService参数表示对MyService的依赖。

使用这个配置类，可以通过AnnotationConfigApplicationContext来加载配置：

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        MyComponent myComponent = context.getBean(MyComponent.class);
        myComponent.doSomething();

        context.close();
    }
}

这样，Spring容器会根据Java配置类中的定义，创建相应的Bean，并自动解决Bean之间的依赖关系。

此外，Java配置类还可以使用@Import注解导入其他配置类，实现更好的模块化。

@Configuration
@Import({DatabaseConfig.class, ServiceConfig.class})
public class AppConfig {

    // Bean definitions...
}

这样，可以将不同模块的配置分开，提高配置的可维护性。

使用Java泛型注入集合。

在Spring中，可以使用泛型来进行集合的依赖注入。下面是一个简单的示例，演示如何使用Java泛型注入集合：

import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class MyComponent<T> {

    private List<T> myCollection;

    public MyComponent(List<T> myCollection) {
        this.myCollection = myCollection;
    }

    public void displayCollection() {
        System.out.println("Elements in the collection:");
        for (T element : myCollection) {
            System.out.println(element);
        }
    }
}

在这个示例中，MyComponent类是一个泛型类，它接收一个List<T>类型的集合作为构造函数的参数。通过这种方式，可以实现对不同类型的集合进行注入。

然后，可以通过使用@Autowired注解和@Qualifier注解来将具体类型的集合注入到MyComponent中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class AppService {

    @Autowired
    @Qualifier("stringList")
    private MyComponent<String> stringComponent;

    @Autowired
    @Qualifier("integerList")
    private MyComponent<Integer> integerComponent;

    public void displayCollections() {
        stringComponent.displayCollection();
        integerComponent.displayCollection();
    }
}

在上述示例中，AppService类中分别注入了两个MyComponent对象，分别对应String类型和Integer类型的集合。使用@Qualifier注解指定具体的集合Bean名称，确保正确的集合被注入到对应的MyComponent中。

接下来，需要在配置类中定义这两个集合Bean：

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

import java.util.Arrays;
import java.util.List;

@Configuration
public class AppConfig {

    @Bean("stringList")
    public List<String> stringList() {
        return Arrays.asList("One", "Two", "Three");
    }

    @Bean("integerList")
    public List<Integer> integerList() {
        return Arrays.asList(1, 2, 3);
    }
}

在这个配置类中，通过@Bean注解定义了两个不同类型的集合Bean，并使用不同的Bean名称。

最后，在启动应用程序时，通过AppService对象调用displayCollections方法，可以看到输出结果中包含了两个集合的元素。

这种方式利用了Java泛型的灵活性，使得可以轻松实现对不同类型集合的注入。

关注公众号 洪都新府笑颜社，发送 “面试题” 即可免费领取一份超全的面试题PDF文件！！！！