【2026版】Spring面试题

最新推荐文章于 2026-04-20 15:49:06 发布
原创 最新推荐文章于 2026-04-20 15:49:06 发布 · 1.4k 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #面试 #spring #后端

文章目录

参考：https://www.yuque.com/hollis666、https://www.mianshiya.com、https://javaguide.cn

1. 介绍一下Spring的IOC

所谓的IOC（inversion of control），就是控制反转的意思。

在传统的程序设计中，应用程序代码通常控制着对象的创建和管理。例如，一个对象需要依赖其他对象，那么它会直接new出来对象。

而在IOC 中，控制关系发生了反转。控制权被转移到Spring容器中，容器负责创建和管理对象，并在需要的时候将它们注入到应用程序中。

所以，原来这个对象的控制权在我们的代码中，我们自己new的对象，在Spring中，应用程序不再控制对象的创建，而是被动地接受由容器注入的对象。

2. 介绍一下Spring的AOP

Spring 的 AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架中的一项核心特性，用于将应用中的横切关注点与业务逻辑解耦。横切关注点通常指的是日志记录、安全控制、事务管理、性能监控等，它们往往会散落在多个业务模块中，造成代码冗余和维护困难。AOP 的核心思想是通过“切面”将这些公共逻辑从业务代码中抽离出来，并在程序运行时以动态代理或字节码增强的方式将其织入到目标对象的方法调用中。

3. 为什么Spring不建议使用基于字段的依赖注入？

单一职责问题
根据SOLID设计原则来讲，一个类的设计应该符合单一职责原则，就是一个类只能做一件功能，当我们使用基于字段注入的时候，随着业务的暴增，字段越来越多，我们是很难发现我们已经默默中违背了单一职责原则的。

但是如果我们使用基于构造器注入的方式，因为构造器注入的写法比较臃肿，所以它就在间接提醒我们，违背了单一职责原则，该做重构了。

可能产生NPE

对于一个bean来说，它的初始化顺序为：

静态变量或静态语句块 -> 实例变量或初始化语句块 -> 构造方法 -> @Autowired

所以，在静态语句块，初始化语句块，构造方法中使用Autowired表明的字段，都会引起NPE问题

@Component
class Test {
    @Autowired
    private Bean bean;

    private final String beanName;

    public Test() {
        // 此时bean尚未被初始化，会抛出NPE
        this.beanName = bean.getName();
    }
}

不利于测试

使用了Autowired注解，说明这个类依赖了Spring容器，这让我们在进行UT的时候必须要启动一个Spring容器才可以测试这个类，显然太麻烦，这种测试方式非常重，对于大型项目来说，往往启动一个容器就要好几分钟，这样非常耽误时间。

4. Spring支持哪些注入方式?

  1. 字段注入
@Autowired
private Bean bean;
  1. 构造器注入
@Component
class Test {
    private final Bean bean;

    @Autowired
    public Test(Bean bean) {
        this.bean = bean;
    }
}
  1. setter注入
@Component
class Test {
    private Bean bean;

    @Autowired
    public void setBean(Bean bean) {
        this.bean = bean;
    }
}

5. Spring Bean的生命周期是怎么样的？

  • 实例化：Spring容器根据配置文件或注解实例化Bean对象。
  • 属性注入：Spring将依赖（通过构造器、setter方法或字段注入）注入到Bean实例中。
  • 初始化前的扩展机制：如果Bean实现了BeanNameAware等aware接口，则执行aware注入。
  • 初始化前（BeanPostProcessor）：在Bean初始化之前，可以通过BeanPostProcessor接口对Bean进行一些额外的
    处理。
  • 初始化：调用InitializingBean接口的afterPropertiesSet方法或通过init-method属性指定的初始化方法。
  • 初始化后（BeanPostProcessor）：在Bean初始化后，可以通过BeanPostProcessor进行进一步的处理。
  • 使用Bean：Bean已经初始化完成，可以被容器中的其他Bean使用。
  • 销毁：当容器关闭时，Spring调用DisposableBean接口的destroyO方法或通过destroy-method属性指定的销毁方
    法。

在这里插入图片描述

6. @PostConstruct、init-method和afterPropertiesSet执行顺序

在Spring框架中，使用@PostConstruct、自定义的init-method方法，和InitializingBean接口和afterPropertiesSet方法都是用于在Bean初始化阶段执行特定方法的方式。他们的执行顺序是：构造函数>@PostConstruct > afterPropertiesSet > init-method

7. Spring的事务传播机制有哪些？

Spring的事务规定了7种事务的传播级别，默认的传播机制是REQUIRED

  • REQUIRED，如果不存在事务则开启一个事务，如果存在事务则加入之前的事务，总是只有一个事务在执行
  • REQUIRES_NEW，每次执行新开一个事务，如果当前存在事务，则把当前事务挂起
  • SUPPORTS，有事务则加入事务，没有事务则普通执行
  • NOT_SUPPORTED，有事务则暂停该事务，没有则普通执行
  • MANDATORY，强制有事务，没有事务则报异常
  • NEVER，有事务则报异常
  • NESTED，如果之前有事务，则创建嵌套事务，嵌套事务回滚不影响父事务，反之父事务影响嵌套事务

8. Autowired和Resource的关系？

支持方不同

Autowired是Spring提供的自动注入注解，只有Spring容器会支持。
Resource是JDK官方提供的自动注入注解（JSR-250）。它等于说是一个标准或者约定，所有的IOC容器都会支持这个注解。

byName和byType匹配顺序不同

Autowired在获取bean的时候，先是byType的方式，再是byName的方式。
Resource在获取bean的时候，和Autowired恰好相反，先是byName方式，然后再是byType方式。

作用域不同

Autowired可以作用在构造器，字段，setter方法上

Resource 只可以使用在字段，setter方法上，不支持构造器注入

可选性不同

Autowire可以通过 required = false属性设置依赖bean可以不必须存在。如果找不到要注入 Bean 时会注入 null，不报错。

Resource没有直接的 required属性。用它注入的Bean必须存在。如果找不到匹配的 Bean，会抛出异常。

9. BeanFactory和FactroyBean的关系？

BeanFactory是Spring IoC容器的一个接口，用来获取Bean以及管理Bean的依赖注入和生命周期。

FactoryBean是一个接口，用于定义一个工厂Bean，它可以产生某种类型的对象。当在Spring配置文件中定义一个Bean时，如果这个Bean实现了FactoryBean接口，那么Spring容器不直接返回这个Bean实例，而是返回FactoryBean#getObject()方法所返回的对象。

10. Spring在业务中常见的使用方式?

通过IoC实现策略模式

Spring IoC 可以通过 @Autowired 或 @Resource 自动注入所有策略实现类，然后通过 Map<String, Strategy> 选择使用。

public interface PaymentStrategy {
    void pay();
}

@Component("alipay")
public class AliPayStrategy implements PaymentStrategy {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}

@Component("wechat")
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}

@Service
public class PaymentService {
    @Autowired
    private Map<String, PaymentStrategy> paymentStrategies;

    public void pay(String type) {
        paymentStrategies.get(type).pay();
    }
}

通过 IoC 容器自动管理和注入策略类，避免了 if-else 逻辑，提升可扩展性。

通过AOP实现拦截

  • 参数校验
@Target({ ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamsCheck {
    boolean ignore() default false;
}

@Aspect
@Component
public class ValidateAspect {

    @Around("@annotation(com.hollis.annotation.ParamCheck)")
    public void ParamCheckAround(JoinPoint joinPoint) throws Throwable {
        // 判断是否需要校验
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        ParamsCheck paramsCheckAnnotation = method.getAnnotation(ParamsCheck.class);
        if (paramsCheckAnnotation != null && paramsCheckAnnotation.ignore()) {
            return joinPoint.proceed();
        }
        Object[] objects = joinPoint.getArgs();
        for (Object arg : objects) {
            if (arg == null) {
                break;
            }
           // 校验参数，失败抛出异常
        }
    }
}
  • 日志打印
@Aspect
@Component
public class LogAspect {
    @Around("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    public Object logExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("方法 " + joinPoint.getSignature() + " 执行耗时: " + (end - start) + "ms");
        return result;
    }
}

通过Event异步解耦

// 定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    public OrderCreatedEvent(Object source) {
        super(source);
    }
}

// 发布事件
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder() {
        System.out.println("订单创建成功");
        publisher.publishEvent(new OrderCreatedEvent(this));
    }
}

// 监听事件
@Component
public class NotificationListener {
    @EventListener
    @Async
    public void onOrderCreated(OrderCreatedEvent event) {
        System.out.println("发送通知：订单已创建");
    }
}

通过Spring管理事务

@Component
public class TransactBean {

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void test() {
        transactionTemplate.execute((status) -> {
            // doTransaction
            return null;
        });
    }
}

11. Spring中如何开启事务？

编程式事务

 @Autowired
    protected TransactionTemplate transactionTemplate;

  	public void test(){
      return transactionTemplate.execute(transactionStatus -> {
         //事务操作
      });
    }

		public void test1(){
      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
          @Override
          protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
              
          }
      });
    }

声明式事务

@Transactional
public void test() {
     // 事务操作  
}

12. Spring中用到了哪些设计模式?

  • 单例模式：Spring 的Bean 默认是单例模式，通过Spring 容器管理Bean的生命周期，保证每个Bean只被创建-
    次，并在整个应用程序中重用。
  • 工厂模式：Spring使用工厂模式通过BeanFactory和ApplicationContext创建并管理Bean对象。
  • 代理模式：SpringAOP基于动态代理技术，使用代理模式实现切面编程，提供了对AOP编程的支持。
  • 观察者模式：Spring中的事件机制基于观察者模式，通过ApplicationEventPublisher发布事件，由
    ApplicationListener监听事件，实现了对象间的松耦合。
  • 模板方法模式：Spring中的JdbcTemplate使用了模板方法模式，将一些固定的流程封装在父类中，子类只需实现一些
    抽象方法即可。
  • 策略模式：Spring中的Handlerlnterceptor和HandlerExecutionChain使用了策略模式，允许开发者自定义处理器拦
    截器，按照一定顺序执行。
  • 责任链模式：Spring中的过滤器和拦截器使用了责任链模式，多个过滤器和拦截器按照一定顺序执行，每个过滤器和拦
    截器可以拦并做出相应的处理

13. 什么是Spring的循环依赖问题？

在Spring框架中，循环依赖是指两个或多个bean之间相互依赖，形成了一个循环引用的情况。如果不加以处理，这种情况会导致应用程序启动失败。

在Spring中，解决循环依赖的方式就是引入了三级缓存。

在SpringBoot 2.6以前，是默认支持循环依赖的，但是在 SpringBoot 2.6 开始，默认已经不开启对循环依赖的支持了

14. 什么是Spring的三级缓存?

在Spring的BeanFactory体系中，BeanFactory是Spring IoC容器的基础接口，其DefaultSingletonBeanRegistry类实现了BeanFactory接口，并且维护了三级缓存：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  //一级缓存，保存完成的Bean对象
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  //三级缓存，保存单例Bean的创建工厂
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  //二级缓存，存储"半成品"的Bean对象
  private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
}

singletonObjects是一级缓存，存储的是完整创建好的单例bean对象。 在创建一个单例bean时，会先从singletonObjects中尝试获取该bean的实例，如果能够获取到，则直接返回该实例，否则继续创建该bean。

earlySingletonObjects是二级缓存，存储的是尚未完全创建好的单例bean对象。 在创建单例bean时，如果发现该bean存在循环依赖，则会先创建该bean的"半成品"对象，并将"半成品"对象存储到earlySingletonObjects中。当循环依赖的bean创建完成后，Spring会将完整的bean实例对象存储到singletonObjects中，并将earlySingletonObjects中存储的代理对象替换为完整的bean实例对象。这样可以保证单例bean的创建过程不会出现循环依赖问题。

singletonFactories是三级缓存，存储的是单例bean的创建工厂。 当一个单例bean被创建时，Spring会先将该bean的创建工厂存储到singletonFactories中，然后再执行创建工厂的getObject()方法，生成该bean的实例对象。在该bean被其他bean引用时，Spring会从singletonFactories中获取该bean的创建工厂，创建出该bean的实例对象，并将该bean的实例对象存储到singletonObjects中。

15. Spring事务失效可能是哪些原因？

@Transactional 应用在非 public 修饰的方法上

public class MyService {
    @Transactional
    private void doInternal() {
        System.out.println("Doing internal work...");
    }
}

private方法，只会在当前对象中的其他方法中调用，也就是会进行对象的自调用，这种情况是用this调用的，并不会走到代理对象，而@Transactional是基于动态代理实现的，所以代理会失效。

同一个类中方法调用，导致@Transactional失效

public class MyService {
    public void doSomething() {
        doInternal(); // 自调用方法
    }

  	@Transactional
    public void doInternal() {
        System.out.println("Doing internal work...");
    }
}

final、static方法

由于AOP是通过创建代理对象来实现的，而无法对final方法进行子类化和覆盖，所以无法拦截这些方法。

还有就是调用static方法，因为这类方法是属于这个类的，并不是对象的，所以无法被AOP。

异常被catch捕获导致@Transactional失效

public class MyService {
	@Transactional
    public void doSomething() {
      	try{
			doInternal(); 
        }catch(Exception e){
        	logger.error(e);
        }
    }
}

因为异常被捕获，所以就没办法基于异常进行rollback了，所以事务会失效。

事务中用了多线程

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        saveOrder(); // 数据库操作
        new Thread(() -> updateStock()).start(); // 开新线程
    }

    public void updateStock() {
        // 更新库存
    }
}

如果是我们常用的@Transactional这种声明式事务的话，在多线程情况下是无法生效的。主要是因为@Transactional 的事务管理使用的是 ThreadLocal 机制来存储事务上下文，而 ThreadLocal 变量是线程隔离的，即每个线程都有自己的事务上下文副本。因此，在多线程环境下，Spring 的声明式事务会“失效”，即新线程中的操作不会被包含在原有的事务中。

16. SpringMVC是如何将不同的Request路由到不同Controller中的？

  1. 客户端请求：用户通过浏览器发送HTTP请求，所有请求都被DispatcherServlet接收。
  2. 请求映射：DispatcherServlet根据配置的处理器映射器（HandlerMapping）查找与请求URL对应的控制器
    (Controller)。
  3. 调用控制器方法：找到控制器后，DispatcherServlet将请求转发给对应的控制器方法进行处理。控制器方法处理业务逻
    辑后，通常返回一个ModelAndView对象，包含数据模型和视图名称。
  4. 视图解析：DispatcherServlet根据控制器返回的视图名称，使用视图解析器（ViewResolver）将逻辑视图名称解析为实
    际的视图（如JSP、Thymeleaf等）。
  5. 视图渲染返回：视图渲染引擎根据数据模型渲染视图，并将生成的HTML响应返回给客户端

SpringMVC还支持返回JSON数据响应，用于构建RESTfulWeb服务，因此上述视图解析部分，如果是JSON响应，则SpringMVC会将对象序列化为JSON，后续返回给客户端。

在这里插入图片描述

17. Springboot是如何实现自动配置的？

SpringBoot的自动配置是通过@EnableAutoConfiguration注解实现，这个注解包含
@Import（{AutoConfigurationImportSelector.class}）注解，导入的这个类会去扫描classpath下所有的META-
INF/spring.factories中的文件，根据文件中指定的配置类加载相应的Bean的自动配置。

这些 Bean 通常会使用@ConditionalonClass、@ConditionalonMissingBean、@ConditionalonProperty 等条件注解。来控制
自动配置的加载条件，例如仅在类路径中存在某个类时，才加载某些配置。

18. SpringBoot的启动流程是怎么样的？

1.启动main方法

  • 应用从main（）方法启动，并通过SpringApplication.run（）引导应用启动。

2.创建SpringApplication

  • 应用会创建 SpringApplication对象，推断应用类型、设置初始化器、设置启动监听器、确定主应用类。

3.准备环境（ConfigurableEnvironment)

  • SpringBoot在启动过程中准备应用环境，加载配置文件、系统环境变量以及命令行参数。

4.创建并刷新ApplicationContext

  • 创建应用上下文，加载配置类和自动配置类，注册Bean并执行依赖注入等初始化操作。

5.在刷新上下文时启动嵌入式Web服务器

  • 对于Web应用，SpringBoot会自动启动嵌入式Web容器（如Tomcat），并注册相关的Servlet和Filter。

6.发布应用已启动事件

  • 对应监听stated事件逻辑会被触发。

7.执行CommandLineRunner和ApplicationRunner

  • 在应用启动完成后，执行实现了CommandLineRuner 和 ApplicationRunner 接口的初始化逻辑。

8.发布ready事件、应用启动完成

  • 触发ApplicationReadyEvent，应用进入运行状态，处理业务请求或任务。
    在这里插入图片描述

19. Spring的AOP在什么场景下会失效？

  1. 私有方法调用
  2. 静态方法调用
  3. final方法调用
  4. 类内部自调用

20. SpringBoot和Spring的区别是什么？

Spring是一个非常强大的企业级Java开发框架，提供了一系列模块来支持不同的应用需求，如依赖注入、面向切面编程、事务管理、Web应用程序开发等。而SpringBoot的出现，主要是起到了简化Spring应用程序的开发和部署，特别是用于构建微服务和快速开发的应用程序。

相比于Spring，SpringBoot主要在这几个方面来提升了我们使用Spring的效率，降低开发成本：

  • 自动配置：Spring Boot通过Auto-Configuration来减少开发人员的配置工作。我们可以通过依赖一个starter就把一坨东西全部都依赖进来，使开发人员可以更专注于业务逻辑而不是配置。
  • 内嵌Web服务器：Spring Boot内置了常见的Web服务器（如Tomcat、Jetty），这意味着您可以轻松创建可运行的独立应用程序，而无需外部Web服务器。
  • 约定大于配置：SpringBoot中有很多约定大于配置的思想的体现，通过一种约定的方式，来降低开发人员的配置工作。如他默认读取spring.factories来加载Starter、读取application.properties或application.yml文件来进行属性配置等。

21. 在Spring中如何使用Spring Event做事件驱动?

Spring Event的使用需要定义以下三个内容：

  • 事件（Event）：事件是一个普通的Java对象，用于封装关于事件发生的信息。通常，事件类会包含一些数据字段，以便监听器能够获取事件的相关信息。
  • 事件发布者（Event Publisher）：事件发布者是负责触发事件并通知所有注册的监听器的组件。
  • 事件监听器（Event Listener）：事件监听器是负责响应特定类型事件的组件。它们实现了一个接口或者使用注解来标识自己是一个事件监听器，并定义了在事件发生时需要执行的逻辑。

假设我们在用户注册成功之后，需要发送一条欢迎短信，那么就可以通过事件来实现。

首先定义一个Event，需要继承ApplicationEvent类。

public class RegisterSuccessEvent extends ApplicationEvent {

    public RegisterSuccessEvent(RegisterInfo registerInfo) {
        super(registerInfo);
    }
}

然后再定义一个事件的监听者：

/**
 * 案件中心内部事件监听器
 *
 * @author Hollis
 */
@Component
public class RegisterEventListener {

    @EventListener(RegisterSuccessEvent.class)
    //@Async
    public void onApplicationEvent(RegisterSuccessEvent event) {
        RegisterInfo registerInfo = (RegisterInfo) event.getSource();

        //执行发送欢迎短信的逻辑
    }
}

以上这个监听器，在监听到一个RegisterSuccessEvent事件被发出来之后，会调用onApplicationEvent方法，我们就可以在这个方法中实现我们的发送欢迎短信的业务逻辑。

有了监听者，那么发送者也需要定义：

@Service
public class RegisterService{

  @Autowired
  protected ApplicationContext applicationContext;

	public RegisterResponse register(RegisterInfo registerInfo){

		//用户注册核心代码

  	//发送一个注册完成的事件
    applicationContext.publishEvent(new RegisterSuccessEvent(registerInfo));

  }

}

默认情况下，Spring Event的调用时同步调用的。如果想要实现异步调用，也是支持的，最简单的方式就是借助@Async 注解，但是，一般来说不建议大家直接用@Async，最好是自定义线程池来实现异步

22. 为什么不建议直接使用Spring的@Async？

@Async中关于线程池的使用部分在AsyncExecutionInterceptor中，在这个类中有一个getDefaultExecutor方法， 当我们没有做过自定义线程池的时候，就会用SimpleAsyncTaskExecutor这个线程池。

@Override
protected Executor getDefaultExecutor(BeanFactory beanFactory) {
    Executor defaultExecutor = super.getDefaultExecutor(beanFactory);
    return (defaultExecutor != null ? defaultExecutor : new SimpleAsyncTaskExecutor());
}

SimpleAsyncTaskExecutor 并不是真的线程池，它是不会重用线程的，每次调用都会创建一个新的线程，也没有最大线程数设置。并发大的时候会产生严重的性能问题。

所以，我们应该自定义线程池来配合@Async使用，而不是直接就用默认的。

@Configuration
@EnableAsync
public class AsyncExecutorConfig {
    @Bean("registerSuccessExecutor")
    public Executor caseStartFinishExecutor() {

        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("registerSuccessExecutor-%d").build();

        ExecutorService executorService = new ThreadPoolExecutor(100, 200,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

        return executorService;
    }

}

/**
 * 案件中心内部事件监听器
 *
 * @author Hollis
 */
@Component
public class RegisterEventListener {

    @EventListener(RegisterSuccessEvent.class)
     @Async("registerSuccessExecutor")
    public void onApplicationEvent(RegisterSuccessEvent event) {
        RegisterInfo registerInfo = (RegisterInfo) event.getSource();

        //执行发送欢迎短信的逻辑
       
    }
}

在@Async中指定registerSuccessExecutor即可。这样在后续执行时，就会用到我们自定义的线程池了。

23. Spring 中的 Bean 是线程安全的吗？

Prototype的Bean是线程安全的，无状态的Singleton的Bean是线程安全的。有状态的Singleton的Bean是非线程安全的。

Spring的Bean是否线程安全，这个要取决于他的作用域。Spring的Bean有多种作用域，其中用的比较多的就是Singleton和Prototype。

默认情况下，Spring Bean 是单例的（Singleton）。这意味着在整个 Spring 容器中只存在一个 Bean 实例。

如果将 Bean 的作用域设置为原型的（Prototype） ，那么每次从容器中获取 Bean 时都会创建一个新的实例。对于Prototype这种作用域的Bean，他的Bean 实例不会被多个线程共享，所以不存在线程安全的问题。

但是对于Singleton的Bean，就可能存在线程安全问题了，但是也不绝对，要看这个Bean中是否有共享变量。

如以下Bean：

@Service
public class CounterService {
    private int count = 0;

    public int increment() {
        return ++count;
    }
}

默认情况下，Spring Bean 是单例的，count字段是一个共享变量，那么如果多个线程同时调用 increment 方法，可能导致计数器的值不正确。那么这段代码就不是线程安全的。

我们通常把上面这种Bean叫做有状态的Bean，有状态的Bean就是非线程安全的，我们需要自己来考虑他的线程安全性问题。

那如果一个Singleton的Bean中是无状态的，即没有成员变量，或者成员变量只读不写，那么他就是个线程安全的。

24. Spring中如何实现多环境配置？

我们平常在开发的时候，会有多套环境，开发环境、测试环境、预发布环境以及生产环境，不同的环境中应用的配置可能不太一样。那么在如何利用Spring来管理这些配置呢？

  • 定义 Profiles：在配置类或配置文件中定义不同的 Profiles，例如使用 @Profile(“dev”) 在 Java 配置类上。
@Configuration
@Profile("dev")
public class DevConfig {
    // 开发环境的特定配置
}

@Configuration
@Profile("prod")
public class ProdConfig {
    // 生产环境的特定配置
}
  • 激活 Profile：可以通过多种方式激活 Profile，如设置环境变量、JVM 参数、Web 应用的上下文参数或在 application.properties 文件中使用 spring.profiles.active 属性。
环境变量：SPRING_PROFILES_ACTIVE=prod
JVM 参数：-Dspring.profiles.active=prod

25. 如何自定义一个starter？

在Spring Boot中，创建一个自定义starter可以简化特定功能或组件的配置过程，让其他项目能够轻松地重用这些功能。

一文搞懂SpringBoot自动装配原理

26. 如何根据配置动态生成Spring的Bean？

基于条件的 Bean 注册

Spring提供了@Conditional（或者@CondationOnProperties）注解，允许你在满足特定条件时才创建Bean。你可以定义自己的条件，这些条件实现了Condition接口。

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("my.condition.enabled", Boolean.class, false);
    }
}

@Configuration
public class MyConfiguration {
    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        return new MyBean();
    }
}

my.condition.enabled可以通过配置文件或者配置中心进行配置，然后当my.condition.enabled属性为true时，MyBean才会被创建。

使用@ConfigurationProperties

@ConfigurationProperties注解可以将配置文件中的属性绑定到Bean的属性上，然后就可以基于他做动态配置了。

@ConfigurationProperties(prefix = "app.datasource")
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
    // 省略getters和setters
}

@Configuration
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceConfig {
    @Autowired
    private DataSourceProperties properties;

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl(properties.getUrl());
        dataSource.setUsername(properties.getUsername());
        dataSource.setPassword(properties.getPassword());
        return dataSource;
    }
}

编程式Bean注册

我们还可以通过实现BeanDefinitionRegistryPostProcessor接口来编程式地注册Bean。

public class DynamicBeanRegistrar implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        if (满足某个条件) {
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(MyDynamicBean.class);
            registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 通常不需要在这个方法中实现任何逻辑
    }
}

使用@Profile

@Profile注解允许根据活动的Spring Profiles来创建Bean。一般是用于区分开发、测试和生产环境的。

@Configuration
public class ProfileConfig {
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2).build();
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // 返回生产环境的DataSource实例
    }
}

27. SpringBoot和传统的双亲委派有什么不一样吗？

传统的采用双亲委派的类加载机制大家都知道，要加载一个类的额时候，先委托父类加载器加载该类；如果父类加载器无法找到（类不存在），才由当前 ClassLoader 加载；这样保证了核心类库（rt.jar）不会被重复加载，避免了类冲突问题。

Spring Boot 打破了传统的双亲委派模型，采用 自定义的 LaunchedURLClassLoader 进行类加载，主要为了支持 “Fat JAR”（可执行 JAR） 的运行。

在 Spring Boot 中，使用 Maven 或 Gradle 构建项目时，lib/ 目录中的第三方依赖是以 JAR 形式打包进主 JAR 内部，默认会生成一个包含所有依赖项的 fat jar。

传统的 Application ClassLoader 只能从 外部 classpath 加载类，无法直接加载 JAR 包内嵌的其他 JAR（fat jar）。 因此 Spring Boot 需要自定义类加载器。

为了支持 Fat JAR 运行模式，Spring Boot 使用 LaunchedURLClassLoader 替代 AppClassLoader，打破双亲委派机制，核心做法是：

  • 先加载 BOOT-INF/classes 目录下的应用类（优先于 JDK 类）。
  • 再加载 BOOT-INF/lib/ 目录下的依赖 JAR（传统 AppClassLoader 无法加载嵌套 JAR）。
  • 最后才交给父类加载器（即 JDK 提供的 AppClassLoader）。

也就是说Spring Boot 先尝试加载自身的类和依赖 JAR，找不到才交给父类加载器，从而打破双亲委派。
在这里插入图片描述

Spring AI 面试题及答案
不务正业的猿
12-18 482
SpringAI是Spring官方推出的AI集成框架，旨在简化Java开发者调用大语言模型等AI服务。它抽象了AI模型交互流程，提供ChatClient、ChatModel等统一接口，支持OpenAI、Azure等多种模型提供商。通过SpringBoot自动配置，开发者只需配置API密钥等参数即可快速接入AI能力。框架支持Prompt模板、向量检索(RAG)、结构化输出映射等功能，并内置异常处理和重试机制。SpringAI采用模块化设计，允许扩展自定义模型和向量存储，同时通过MCP协议支持本地模型集成。在部
【Java面试题汇总】Spring篇（2026版）
种一棵树最好的时间是十年前，其次是现在
06-15 7185
IoC、DI、aop、事务、为什么不建议@Transactional、事务传播级别、@Autowired和@Resource注解的区别、BeanFactory和FactoryBean的区别、Bean的作用域,以及默认的作用域、Bean的生命周期、循环依赖、三级缓存、
Spring AI相关的面试题
坚持写博客，大家的关注是我前进的动力！
03-23 2656
通过Spring Cloud的配置中心，如Spring Cloud Config，可以实现AI服务配置的集中管理和动态刷新，方便在不同环境和集群中统一管理AI模型的参数和API密钥等配置信息。此外，还可以对服务层进行单元测试，模拟AI客户端的响应，验证业务逻辑的正确性，确保在不同的AI回答情况下应用能够正确处理。此外，对于非关系型数据库，如MongoDB，Spring Data也提供了相应的支持，开发者可以根据实际需求选择合适的数据库类型和Spring Data模块，实现AI应用数据的高效存储和检索。
万字详解 RAG 向量索引算法和向量数据库
最新发布
JavaGuide
04-20 620
向量索引算法是向量数据库的核心，它的核心任务是解决一个数学难题：如何在海量的高维向量中，极速地找到和给定查询向量最相似的那几个。它的本质，是一种空间划分和数据组织的艺术。如果没有索引，我们要找一个相似向量，就必须把数据库里所有的向量都比较一遍，这叫暴力搜索。在百万、亿级的数据量下，这种方法的延迟是灾难性的。向量索引的目标，就是通过预先组织好数据，让我们在查询时能够智能地跳过绝大部分不相关的向量，只在一个很小的候选集里进行精确比较。没有索引= 在整个城市挨家挨户找一个人有索引。
Spring AI Java程序员的AI之Spring AI（四）
qq1071643762的博客
10-18 1916
基于Llama3和Spring AI，以及ChatGPT Web来实现一个Java经典面试题智能小助手
面试官：谈谈对SpringAI的理解？
磊哥聊Java
06-13 1386
面试题大全：www.javacn.siteSpring AI 已经发布了好长时间了，目前已经更新到 1.0 版本了，所以身为 Java 程序员的你，如果还对 Spring AI 一点都不了解的话，那就有点太落伍了。言归正传，那什么是 Spring AI？如何快速进行 Spring AI 开发呢？1.什么是Spring AI？Spring AI 是 Spring 官方社区项目，旨在简化 Java A...
SpringAI以及Langchain4j、RAG等高频面试题
m0_68880377的博客
03-04 749
本文档整理了SpringAI、LangChain4j、大模型接入、Prompt设计和RAG实现等AI开发相关的高频面试题及回答要点。主要内容包括：1) SpringAI的核心架构、多模型切换和RAG实现；2) LangChain4j的组件设计及开源模型集成；3) 大模型接入流程与流式输出处理；4) Prompt工程的设计技巧；5) RAG的核心流程与优化策略；6) Function Calling的实现与问题解决；7) MCP协议的概念与应用。文档采用问答形式，提供了从基础概念到实战优化的系统解答，适合AI
【2026版】Spring Boot面试题
2401_89221867的博客
12-16 680
场景优势体现网页端控制智能设备浏览器无需插件，通过 WebSocket 直接与 MQTT Broker 通信，实时性强跨网络设备通信WebSocket 的 80/443 端口易穿透防火墙，解决传统 MQTT 端口被屏蔽的问题混合终端接入设备（TCP/MQTT）、网页（WebSocket/MQTT）、服务端可统一接入同一 BrokerMQTT 与 WebSocket 的结合是“协议复用 + 场景适配”底层：WebSocket 提供可靠的长连接通道，解决网络穿透和网页端接入问题；上层。
【Java面试题汇总】Spring,SpringBoot,SpringMVC,Mybatis,JavaWeb篇（2026版）
种一棵树最好的时间是十年前，其次是现在
04-21 4622
Soring Boot的起步依赖、启动流程、自动装配、常用的注解、Spring MVC的执行流程、对MVC的理解、RestFull风格、为什么service层要写接口、MyBatis的缓存机制、$和#有什么区别、resultType和resultMap区别、cookie和session的区别是什么？session的工作原理
2025年Java高级工程师面试实录：聚焦Spring AI、MCP、RAG、向量数据库与Embedding模型
yjdevil159的博客
05-15 1326
RDB的优点是恢复速度快，占用空间小；本次面试围绕Java高级工程师岗位要求，重点考察了候选人在Spring AI、MCP、RAG、向量数据库、Embedding模型等新技术领域的掌握情况，以及对计算机基础、源码原理的深入理解。整体来看，JY表现出扎实的技术功底和良好的表达能力，能够准确回答各类问题并给出合理解释，展现出较强的综合能力，具备胜任高级Java工程师岗位的潜力。在分布式AI系统中，MCP可以确保模型版本的一致性，支持灰度发布、A/B测试等功能，并且可以通过统一的接口进行模型状态的查询和调整。
【面试系列】Java开发--AI常见面试题
小天一直在路上
02-21 5190
介绍常用AI工具（编程、对话、图像、办公），解释AI术语（AIGC、LLM、DeepLearning），分析DeepSeek优缺点及服务器问题解决方案，探讨本地部署、数据隐私、智能客服、流式输出、智能体应用，并认为AI是程序员的辅助工具而非替代者
spring常见面试题(2024最新)
热门推荐
酷酷的馫博客
02-27 5万+
spring常见面试题(2023最新)
​Spring AI面试全攻略：核心概念、实战详解与高频问题解析
一起探索IT的世界
10-15 1364
随着生成式人工智能（Generative AI）的爆发式发展，将AI能力高效、便捷地集成到现有应用中已成为开发者的刚需。Spring框架，作为Java生态系统事实上的标准，自然不会缺席这场变革。Spring AI项目的诞生，正是为了简化AI功能的集成，为Spring开发者提供一套熟悉的、声明式的API来调用各种AI模型
大厂Java面试实录：AIGC场景下的Spring AI与RAG技术深度剖析
HKZ111的博客
06-05 520
分布式系统保障：消息队列+补偿事务Spring AI集成：Prompt工程+向量检索Agentic架构：多Agent协同解决复杂查询// 避免AI幻觉的关键代码你是一名电商客服，请根据以下知识严格回答：用户问题：{question}""");
从零入门Spring AI：谢飞机的大厂AI面试奇遇记
wujie10的专栏
05-15 719
欢迎来到我们公司的技术面试环节，请做个自我介绍。：你好！我是一个Java程序员，虽然对AI一知半解，但我愿意学习，而且写代码时总能“飞”出点新花样 😂。
Java大厂面试真题：从Spring Boot到AI微服务的三轮技术拷问（一）
chenmingxing11的博客
11-10 1070
这场面试涵盖了传统Java开发 + 微服务 + AI融合的全栈能力要求。分布式系统设计能力高并发处理经验对AI技术的基本理解与集成能力全链路监控与容错意识💡建议学习路径精通 Spring Boot + Spring Cloud掌握 Redis、Kafka 实战应用学习 Spring AI 与 RAG 架构动手搭建一个企业级文档问答系统只有这样，才能在下一次面试中，笑着说出：“您问的我都懂。
2025年Java程序员AI技术栈面试实战：Spring AI、MCP、RAG、向量数据库与Embedding模型全解析
yjdevil159的博客
05-06 1129
本次面试围绕Spring AI、MCP、RAG、向量数据库、Embedding模型等AI核心技术栈展开，分为三轮提问，分别涉及基础概念、计算机基础与源码原理。通过这些问题，全面考察了候选人的技术广度与深度，尤其在AI工程实践中的理解与落地能力。希望本文能为正在准备AI技术栈面试的Java程序员提供有价值的参考。
互联网大厂Java求职面试：Spring AI与大模型交互的高级模式与自定义开发
在未来等你的专栏
05-19 1330
面试官您的回答展示了扎实的技术功底和丰富的实战经验。虽然有时候表达方式比较幽默，但能看得出您对技术的热情和深入的理解。请您回家等待我们的通知。本文详细探讨了Spring AI与大模型交互的高级模式与自定义开发，涵盖了系统架构设计、技术选型决策、性能优化等多个方面。希望通过这些内容，能够为读者提供有价值的参考和启示。
【面试】Spring框架面试题
雨下一整晚real的博客
09-25 3146
一、谈谈你理解的 Spring 是什么？ Spring是一个生态，包含了23个开源框架，可以构建Java应用所需的一切基础设施 Spring通常指Spring Framework 核心解释 Spring是一个开源的、轻量级的容器（包含并管理对象的生命周期）框架 Spring是为了解决企业级开发中业务逻辑层中对象之间的耦合问题 Spring的核心是IoC和AOP 二、Spring的优缺点有哪些？ 从IoC、AOP、事务管理、JDBC、模板集成（简化开发）、源码方面进行解释 IoC：集中管理Bean对
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值