自学内容网 自学内容网
自学内容网 > 正文

Spring IoC——针对实习面试

🕗 发布于 2024-11-19 18:11 spring  面试  java  实习  笔记  

目录

Spring IoC

在这里插入图片描述

谈谈你对Spring IoC的理解

Spring IoC（Inversion of Control，控制反转）是Spring框架的核心特性之一，它提供了一种机制，允许对象之间的依赖关系被自动管理，而不是通过硬编码的方式在组件内部直接创建或查找它们的依赖关系。控制反转是一种设计原则，而不是一个具体的技术实现，用来减少计算机程序的耦合度，提高模块间的独立性。

在Spring IoC中，主要涉及以下几个概念：

  1. 容器（Container）：Spring IoC容器是一个管理对象生命周期和依赖关系的系统。它负责创建对象、配置对象、组装对象，并管理对象的整个生命周期。

  2. Bean（豆）：在Spring中，由IoC容器管理的对象被称为Bean。这些Bean由容器实例化、配置和组装，并且它们通常由容器进行管理。

  3. 依赖注入（Dependency Injection, DI）：这是实现控制反转的主要方式之一。在依赖注入中，一个对象的依赖关系不是由对象自己创建，而是由外部容器注入。这种方式可以是构造器注入、字段注入或setter方法注入。

  4. 配置元数据（Configuration Metadata）：这些是定义了Bean如何创建和组装的信息。在Spring中，可以通过XML配置文件、注解（如@Component、@Service、@Repository等）或者Java配置类来提供这些元数据。

  5. 生命周期回调（Lifecycle Callbacks）：Spring允许在Bean的生命周期中的特定点执行自定义代码，例如初始化（@PostConstruct）和销毁（@PreDestroy）阶段。

  6. 作用域（Scope）：Spring IoC容器可以管理不同作用域的Bean，例如单例（Singleton）、原型（Prototype）、请求（Request）、会话（Session）等。

  7. 自动装配（Autowiring）：Spring提供了自动装配功能，可以根据一定的规则（如类型匹配、名称匹配等）自动将依赖关系注入到Bean中。

Spring IoC的主要优点包括：

  • 降低耦合度：由于依赖关系是由容器管理的，因此组件之间的耦合度降低。
  • 提高模块化：每个组件都可以独立于其他组件进行开发和测试。
  • 代码重用：通过将对象的创建和配置从使用它们的代码中分离出来，可以更容易地重用代码。
  • 易于测试：由于对象的依赖关系是由容器管理的，因此在测试时可以轻松地替换依赖关系，进行单元测试。

总的来说，Spring IoC提供了一种灵活、可配置的方式来管理应用程序中的对象，使得开发人员可以更专注于业务逻辑，而不是对象的创建和管理。

IoC和DI有区别吗？

IoC（控制反转）和DI（依赖注入）这两个概念经常一起出现，它们在很多情况下被交替使用，但实际上它们是两个相关但不同的概念。

IoC（控制反转）

IoC是一种设计原则，它的核心思想是将对象的创建和它们之间的依赖关系的控制权从对象本身转移到外部容器。这样做的目的是为了降低系统的耦合度，提高模块化和可维护性。在IoC中，对象不负责查找或创建它们的依赖，而是通过容器来提供这些依赖。

DI（依赖注入）

DI是实现IoC的一种具体技术手段。在DI中，一个对象的依赖关系被外部源（通常是IoC容器）“注入”到对象中。这种注入可以发生在对象的生命周期中的不同点，比如在对象创建时通过构造器注入、在对象的属性设置时通过setter方法注入，或者在对象的某个字段直接注入。

IoC与DI的区别

  • 概念层面：IoC是一个更广泛的概念，它描述了一种对象创建和依赖管理的模式。DI是实现IoC的一种方式，它专注于如何将依赖关系注入到对象中。

  • 实现方式：IoC可以通过多种方式实现，包括依赖注入、服务定位器模式等。而DI特指通过构造器、setter方法或字段注入等方式将依赖关系注入到对象中。

  • 关注点：IoC关注的是如何管理对象的生命周期和它们之间的依赖关系，而DI关注的是如何将这些依赖关系具体地注入到对象中。

在实际应用中，DI是实现IoC最常见的方式，尤其是在Spring框架中，DI被广泛用于管理Bean的依赖关系。因此，虽然IoC和DI在概念上有所区别，但在很多情况下，它们被紧密地联系在一起，DI成为了实现IoC的首选方式。

什么是Spring Bean？作用域有哪些？

在Spring框架中，Spring Bean 是由Spring IoC容器管理的对象。这些对象由容器实例化、配置和组装，并且它们通常由容器进行管理。Spring Bean是构成Spring应用的基本构建块，它们可以是服务、数据访问对象（DAO）、控制器、工具类等。

Spring Bean的作用域

Spring Bean可以有不同的作用域，这些作用域定义了Bean的生命周期和在不同请求或会话中的可见性。以下是Spring支持的主要作用域：

  1. singleton（单例）：

    • 这是默认的作用域。在Spring IoC容器中，每个由容器管理的Bean定义对应一个唯一的Bean实例。Singleton Beans是线程安全的，并且在整个容器的生命周期内只创建一次。

  2. prototype（原型）：

    • 对于prototype作用域的Bean，每次请求（例如通过容器的getBean方法）都会创建一个新的Bean实例。Prototype Beans不是线程安全的，并且它们的生命周期很短，通常由容器创建后立即释放。

  3. request（请求）：

    • 每个HTTP请求都会创建一个新的Bean，并且该Bean仅在请求的生命周期内有效。这些Bean只在当前请求内可见，对于Web应用程序来说非常有用。

  4. session（会话）：

    • 一个会话对应一个Bean实例，Spring容器为每个HTTP Session创建一个Bean实例。这些Bean在会话的生命周期内有效。

  5. application（应用程序）：

    • 一个Web应用程序对应一个Bean实例，该Bean在应用程序的整个生命周期内有效，直到Web应用程序被卸载。

  6. websocket（WebSocket）：

    • 一个WebSocket对应一个Bean实例，该Bean在WebSocket的生命周期内有效。

除了这些标准作用域，Spring还允许通过实现org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope方法来注册自定义作用域。

作用域的选择

选择Bean的作用域通常取决于应用程序的需求和Bean的用途。
例如，对于需要共享状态的服务，可能会选择singleton作用域，而对于每个用户请求都需要独立实例的服务，则可能会选择prototype作用域。对于Web应用程序，request和session作用域常用于管理与特定请求或用户会话相关的数据。

Bean是线程安全的吗？

在Spring框架中，Bean是否线程安全并不是由Spring容器直接决定的，而是由Bean的实现和使用方式决定的。以下是一些关于Spring Bean线程安全的关键点：

  1. 单例Bean（singleton）：

    • 默认情况下，Spring容器中的单例Bean是线程不安全的，因为它们是全局共享的。如果多个线程共享同一个Bean实例，并且该实例包含非线程安全的成员变量，那么在并发访问时可能会出现问题。
    • 要使单例Bean线程安全，需要确保Bean的实现是线程安全的，或者通过同步代码块、使用线程安全的集合类等方式来管理并发访问。

  2. 原型Bean（prototype）：

    • 原型作用域的Bean在每次请求时都会创建一个新的实例，因此它们天生是线程安全的，因为每个线程或请求都会获得自己的Bean实例，不存在共享状态的问题。

  3. 其他作用域（如request、session、application等）：

    • 这些作用域的Bean在特定的上下文（如HTTP请求、会话或应用程序）内是唯一的，因此它们在该上下文中是线程安全的。但是，如果Bean内部包含非线程安全的成员变量或方法，那么在并发访问时仍然可能出现问题。

  4. 线程安全的实现：

    • 如果需要确保Bean的线程安全，可以通过以下方式实现：
      • 使用同步代码块或方法来管理对共享资源的访问。
      • 使用线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。
      • 确保Bean的业务逻辑是无状态的，或者状态不共享给多个线程。
      • 使用不可变对象，因为不可变对象本质上是线程安全的。

  5. Spring提供的线程安全支持：

    • Spring提供了一些工具和注解来帮助实现线程安全，例如@Transactional注解可以确保数据库操作的原子性和一致性，从而间接提供线程安全。

总之，Bean的线程安全取决于其实现和使用方式。即使是单例Bean，也可以通过适当的设计和同步机制来实现线程安全。而对于原型Bean和其他作用域的Bean，虽然它们在特定上下文中是唯一的，但仍需要确保Bean内部的实现是线程安全的。

说一下Spring Bean的生命周期

  1. 实例化（Instantiation）
    • Spring容器通过反射机制使用Bean的默认构造函数（如果没有其他特殊的构造函数定义）来创建Bean的实例。这是Bean生命周期的开始阶段。例如，假设有一个简单的Java类UserService：
    public class UserService {
    public UserService() {
        System.out.println("UserService正在被实例化");
    }
}
    • 当这个UserService被定义为Spring Bean并由容器管理时，容器会调用这个构造函数来创建对象实例。
  2. 属性赋值（Populate Properties）
    • 在实例化之后，Spring容器会根据在配置文件（如XML配置或基于Java的配置）中定义的属性值来填充Bean的属性。如果使用基于注解的配置，例如@Value注解可以用于注入简单的值，@Autowired等注解可以用于注入其他Bean的引用。
    • 假设UserService有一个属性userRepository，配置如下：
    @Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    //...
}
    • Spring会在这个阶段找到UserRepository的实例，并将其注入到UserService的userRepository属性中。
  3. BeanNameAware接口回调（如果实现了该接口）
    • 如果Bean实现了BeanNameAware接口，Spring容器会调用setBeanName方法，将Bean的名称传递给Bean实例。这使得Bean能够知道自己在容器中的名称。例如：
    public class MyBean implements BeanNameAware {
    private String beanName;
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean名称是： " + name);
    }
}
  4. BeanFactoryAware接口回调（如果实现了该接口）
    • 当Bean实现了BeanFactoryAware接口时，Spring会调用setBeanFactory方法，将创建它的BeanFactory实例注入到Bean中。这样Bean就可以通过这个工厂来获取其他Bean等操作。
    public class MyBean implements BeanFactoryAware {
    private BeanFactory beanFactory;
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("已注入BeanFactory");
    }
}
  5. ApplicationContextAware接口回调（如果实现了该接口）
    • 类似地，如果Bean实现了ApplicationContextAware接口，Spring会调用setApplicationContext方法，将ApplicationContext实例注入到Bean中。这使得Bean可以访问容器的各种资源，如获取其他Bean、发布事件等。
    public class MyBean implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("已注入ApplicationContext");
    }
}
  6. BeanPostProcessor的前置处理方法（postProcessBeforeInitialization）调用
    • Spring会遍历所有注册的BeanPostProcessor，并调用它们的postProcessBeforeInitialization方法，对Bean进行前置处理。这些处理器可以对Bean进行一些修改，如添加额外的属性或方法调用等。
    • 例如，自定义一个BeanPostProcessor：
    public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前处理Bean： " + beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后处理Bean： " + beanName);
        return bean;
    }
}
  7. InitializingBean接口回调（如果实现了该接口）或自定义初始化方法调用
    • 如果Bean实现了InitializingBean接口，Spring会调用afterPropertiesSet方法，用于执行一些初始化操作。另外，也可以通过在配置中指定init - method来定义一个自定义的初始化方法。
    • 例如，对于实现InitializingBean的Bean：
    public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行InitializingBean的初始化方法");
    }
}
    • 或者通过XML配置自定义初始化方法：
    <bean id="myBean" class="com.example.MyBean" init - method="customInitMethod">
</bean>
    • 对应的Java方法：
    public class MyBean {
    public void customInitMethod() {
        System.out.println("执行自定义初始化方法");
    }
}
  8. BeanPostProcessor的后置处理方法（postProcessAfterInitialization）调用
    • 与前置处理类似，Spring会再次遍历BeanPostProcessor，调用它们的postProcessAfterInitialization方法，对Bean进行后置处理。这是Bean初始化后的最后一次处理机会。
  9. Bean的使用（Usage）
    • 此时，Bean已经完全初始化并可以被应用程序使用。它可以被注入到其他Bean中，或者被容器管理的其他组件调用其方法来完成业务逻辑。
  10. 销毁（Destruction）
  • 当容器关闭或者Bean不再需要时（例如在一个Web应用中，当应用服务器关闭时），如果Bean实现了DisposableBean接口，Spring会调用destroy方法。同时，如果在配置中指定了destroy - method（如在XML配置中），也会执行这个自定义的销毁方法。
  • 例如，对于实现DisposableBean的Bean：
public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("执行DisposableBean的销毁方法");
    }
}
  • 或者通过XML配置自定义销毁方法：
<bean id="myBean" class="com.example.MyBean" destroy - method="customDestroyMethod">
</bean>
  • 对应的Java方法：
public class MyBean {
    public void customDestroyMethod() {
        System.out.println("执行自定义销毁方法");
    }
}

事实上这部分过程复杂，实习面试应该不会问这么深的问题，了解即可

注入Bean的方式有哪些？

  1. 构造函数注入（Constructor Injection）
    • 原理：通过Bean的构造函数来注入依赖。当容器创建Bean实例时，会根据构造函数的参数类型和数量，查找匹配的Bean来进行注入。
    • 示例：
    public class UserService {
    private UserRepository userRepository;
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}
    • 在这个例子中，UserService的构造函数接受一个UserRepository类型的参数。当Spring容器创建UserService实例时，会查找UserRepository类型的Bean，并将其注入到UserService的构造函数中。这种方式的优点是可以保证Bean在创建时所有必需的依赖都已经注入，对象的状态是完整的。
  2. Setter方法注入（Setter Injection）
    • 原理：使用Bean的Setter方法来注入依赖。Spring容器会在Bean实例化后，通过调用Setter方法将依赖的Bean注入进去。
    • 示例：
    public class UserService {
    private UserRepository userRepository;
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}
    • 在这里，Spring容器会先创建UserService的实例，然后查找UserRepository类型的Bean，通过调用setUserRepository方法将其注入。这种方式的优点是更加灵活，允许在对象创建后再注入依赖，例如可以在某些条件下重新设置依赖。
  3. 字段注入（Field Injection）
    • 原理：直接在Bean的字段上使用注解（如@Autowired）来注入依赖。Spring容器会通过反射机制将依赖的Bean注入到对应的字段中。
    • 示例：
    public class UserService {
    @Autowired
    private UserRepository userRepository;
}
    • 这种方式是最简洁的，但也有一些缺点。例如，它使得单元测试变得困难，因为无法通过构造函数或Setter方法来提供模拟的依赖。不过在简单的应用场景下，它可以快速地实现依赖注入。
  4. 接口注入（Interface Injection）
    • 原理：通过实现特定的接口来完成依赖注入。容器会根据接口的定义来注入相应的实现类。不过这种方式在Spring中使用较少。
    • 示例（假设存在这样的接口和实现）：
    • 定义接口：
    public interface Injectable {
    void injectDependency(Object dependency);
}
    • 实现类：
    public class MyBean implements Injectable {
    private Object dependency;
    @Override
    public void injectDependency(Object dependency) {
        this.dependency = dependency;
    }
}
    • 在这种方式下，容器需要识别Injectable接口，并调用injectDependency方法来注入依赖。在实际的Spring应用中，这种方式因为比较复杂，没有构造函数注入、Setter注入和字段注入那么常用。

在Spring框架中，最常用的是构造函数注入和Setter方法注入，尤其是在遵循依赖注入最佳实践和编写可测试代码时，这两种方式更受青睐。字段注入虽然简洁，但在某些场景下可能会带来一些维护和测试上的问题。


原文地址：https://blog.csdn.net/weixin_73527957/article/details/143852999

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • 深入理解 AWS Route 53 加权路由策略：实现多区域负载均衡

    在当今的云计算环境中，有效管理和分配流量对于确保应用程序的高可用性和性能至关重要。AWS Route 53 的加权路由策略提供了一个强大的工具来实现这一目标。在本文中，我们将深入探讨加权路由策略的概念

    阅读更多2024-11-21
  • Elasticsearch：如何部署文本嵌入模型并将其用于语义搜索

    如何部署文本嵌入模型并将其用于语义搜索。它使你能够生成文本的向量表示并对生成的向量执行向量相似性搜索。示例中使用的模型在上公开可用。该示例使用来自的公共数据集。它由来自 Microsoft Bing

    阅读更多2024-11-21
  • 深入理解CRC：通信可靠性的关键

    循环冗余校验（CRC, Cyclic Redundancy Check）是现代数据传输和存储中不可或缺的技术，用于提高系统的可靠性和数据完整性。CRC的强大之处在于其能够高效检测并定位传输错误，确保数

    阅读更多2024-11-21
  • 低速接口项目之串口Uart开发(一)——串口UART

    在 RS-232 标准中，最常用的配置是八个数据位+无奇偶校验+一个停止位，按照一个完整的字节包括一位起始位、8 位数据位、一位停止位即总共十位数据来算，要想完整的实现这十位数据的发送，就需要 11个

    阅读更多2024-11-21
  • 网络安全基础

    相对性、时效性、相关性、不确定性、复杂性以及重要性等。指网络系统的硬件、软件及其系统中的数据受到保护，不因偶然的或者恶意的原因而遭受到破坏、更改、泄露，系统连续可靠正常地运行，网络服务不中断。1、机密

    阅读更多2024-11-21
  • Docker1：认识docker、在Linux中安装docker

    Docker：快速构建、运行、管理应用的工具。简单来说，帮助我们部署项目、以及项目依赖的各种组件。Docker是一个典型的运维工具。以上就是在Linux中，安装docker的全部详细过程，感兴趣就关注

    阅读更多2024-11-21
  • 基于Springboot+Vue医院急诊系统(源码+PPT+LW+调试部署)

    基于Spring Boot + Vue的医院急诊系统，旨在为患者提供便捷的医院急诊服务，同时提升医院的信息化管理水平。系统分为前台和后台两部分，前台功能包括医生信息、医院病房、医院论坛、医院资讯、个人

    阅读更多2024-11-21
  • Gin 框架中的表单处理与数据绑定

    Gin框架允许注册自定义验证规则。import ("regexp"// 注册自定义验证规则})首先，根据表单的需要定义一个或多个结构体。这些结构体应该清晰地反映表单数据的结构和类型

    阅读更多2024-11-21
  • CAAS 和 IAAS

    和是两种云服务模式，分别代表不同层次的云计算服务。

    阅读更多2024-11-21
  • Spark 分布式计算中网络传输和序列化的关系（二）

    Spark 中序列化和网络传输的优化直接关系到分布式计算的整体性能。结合高效的序列化工具（如 Kryo）和合理的网络传输策略（如压缩、分区优化），可以显著提高数据处理效率。中，网络传输和序列化是数据处

    阅读更多2024-11-21
自学内容网
Copyright © 2015-2024