为什么我的 Spring @Autowired 字段为空？

Question

注意：这是针对常见问题的规范答案。

我有一个 Spring @Service 类 (MileageFeeCalculator)，它有一个 @Autowired 字段 (rateService)，但当我尝试使用它时，该字段是 null。日志显示MileageFeeCalculator bean 和MileageRateService bean 都在创建中，但是每当我尝试在我的服务bean 上调用mileageCharge 方法时，我都会得到NullPointerException。为什么 Spring 不自动装配该字段？

控制器类：

@Controller
public class MileageFeeController {    
    @RequestMapping("/mileage/{miles}")
    @ResponseBody
    public float mileageFee(@PathVariable int miles) {
        MileageFeeCalculator calc = new MileageFeeCalculator();
        return calc.mileageCharge(miles);
    }
}

服务类：

@Service
public class MileageFeeCalculator {

    @Autowired
    private MileageRateService rateService; // <--- should be autowired, is null

    public float mileageCharge(final int miles) {
        return (miles * rateService.ratePerMile()); // <--- throws NPE
    }
}

应该在 MileageFeeCalculator 中自动装配的服务 bean，但它不是：

@Service
public class MileageRateService {
    public float ratePerMile() {
        return 0.565f;
    }
}

当我尝试GET /mileage/3 时，我得到了这个异常：

java.lang.NullPointerException: null
    at com.chrylis.example.spring_autowired_npe.MileageFeeCalculator.mileageCharge(MileageFeeCalculator.java:13)
    at com.chrylis.example.spring_autowired_npe.MileageFeeController.mileageFee(MileageFeeController.java:14)
    ...

Answer 1

注释@Autowired 的字段是null，因为Spring 不知道您使用new 创建的MileageFeeCalculator 的副本，也不知道自动装配它。

The Spring Inversion of Control (IoC) container 具有三个主要的逻辑组件：一个注册中心（称为ApplicationContext），其中包含可供应用程序使用的组件（bean），一个配置器系统，通过匹配与上下文中的 bean 的依赖关系，以及可以查看许多不同 bean 的配置并确定如何以必要的顺序实例化和配置它们的依赖关系求解器。

IoC 容器并不神奇，它无法了解 Java 对象，除非您以某种方式告知它它们。当您调用new 时，JVM 会实例化一个新对象的副本并将其直接交给您——它从不经过配置过程。您可以通过三种方式配置 bean。

我已经在this GitHub project 发布了所有这些代码，使用 Spring Boot 启动；您可以查看每种方法的完整运行项目，以了解使其工作所需的一切。 使用NullPointerException 标记：nonworking

注入你的 bean

最好的选择是让 Spring 自动装配所有 bean；这需要最少的代码并且最易于维护。要使自动装配工作如你所愿，还可以像这样自动装配MileageFeeCalculator：

@Controller
public class MileageFeeController {

    @Autowired
    private MileageFeeCalculator calc;

    @RequestMapping("/mileage/{miles}")
    @ResponseBody
    public float mileageFee(@PathVariable int miles) {
        return calc.mileageCharge(miles);
    }
}

如果您需要为不同的请求创建服务对象的新实例，您仍然可以使用the Spring bean scopes 进行注入。

通过注入 @MileageFeeCalculator 服务对象起作用的标签：working-inject-bean

使用@Configurable

如果您确实需要使用new 创建的对象进行自动装配，您可以use the Spring @Configurable annotation along with AspectJ compile-time weaving 注入您的对象。这种方法将代码插入到对象的构造函数中，以提醒 Spring 它正在创建，以便 Spring 可以配置新实例。这需要在您的构建中进行一些配置（例如使用 ajc 编译）并打开 Spring 的运行时配置处理程序（@EnableSpringConfigured 使用 JavaConfig 语法）。 Roo Active Record 系统使用这种方法来允许您的实体的new 实例注入必要的持久性信息。

@Service
@Configurable
public class MileageFeeCalculator {

    @Autowired
    private MileageRateService rateService;

    public float mileageCharge(final int miles) {
        return (miles * rateService.ratePerMile());
    }
}

在服务对象上使用@Configurable 起作用的标记：working-configurable

手动查找 bean：不推荐

这种方法仅适用于在特殊情况下与遗留代码交互。几乎总是最好创建一个 Spring 可以自动装配并且遗留代码可以调用的单例适配器类，但是可以直接向 Spring 应用程序上下文询问 bean。

为此，您需要一个 Spring 可以引用 ApplicationContext 对象的类：

@Component
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;   
    }

    public static ApplicationContext getContext() {
        return context;
    }
}

然后您的旧代码可以调用 getContext() 并检索它需要的 bean：

@Controller
public class MileageFeeController {    
    @RequestMapping("/mileage/{miles}")
    @ResponseBody
    public float mileageFee(@PathVariable int miles) {
        MileageFeeCalculator calc = ApplicationContextHolder.getContext().getBean(MileageFeeCalculator.class);
        return calc.mileageCharge(miles);
    }
}

通过在 Spring 上下文中手动查找服务对象来工作的标签：working-manual-lookup

Answer 2

如果您没有编写 Web 应用程序，请确保完成 @Autowiring 的类是 Spring bean。通常，spring 容器不会意识到我们可能认为是 spring bean 的类。我们必须告诉 Spring 容器我们的 Spring 类。

这可以通过在 appln-contxt 中配置来实现，或者更好的方法是将类注解为 @Component 并且请不要使用 new 运算符创建注解的类。 确保您从 Appln-context 中获取它，如下所示。

@Component
public class MyDemo {


    @Autowired
    private MyService  myService; 

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
            System.out.println("test");
            ApplicationContext ctx=new ClassPathXmlApplicationContext("spring.xml");
            System.out.println("ctx>>"+ctx);

            Customer c1=null;
            MyDemo myDemo=ctx.getBean(MyDemo.class);
            System.out.println(myDemo);
            myDemo.callService(ctx);


    }

    public void callService(ApplicationContext ctx) {
        // TODO Auto-generated method stub
        System.out.println("---callService---");
        System.out.println(myService);
        myService.callMydao();

    }

}

Answer 3

实际上，您应该使用 JVM 管理的对象或 Spring 管理的对象来调用方法。 从控制器类中的上述代码中，您正在创建一个新对象来调用具有自动连接对象的服务类。

MileageFeeCalculator calc = new MileageFeeCalculator();

所以它不会那样工作。

解决方案将此 MileageFeeCalculator 作为控制器本身中的自动连接对象。

如下所示更改您的 Controller 类。

@Controller
public class MileageFeeController {

    @Autowired
    MileageFeeCalculator calc;  

    @RequestMapping("/mileage/{miles}")
    @ResponseBody
    public float mileageFee(@PathVariable int miles) {
        return calc.mileageCharge(miles);
    }
}

Answer 4

我曾经遇到过同样的问题，当时我不太习惯 IoC 世界的生活。我的一个 bean 的 @Autowired 字段在运行时为空。

根本原因是，我没有使用由 Spring IoC 容器维护的自动创建的 bean（其 @Autowired 字段确实已正确注入），而是 newing 我自己的该 bean 类型的实例并使用它.当然这个的@Autowired字段是null，因为Spring没有机会注入它。

Answer 5

你的问题是新的（java风格的对象创建）

MileageFeeCalculator calc = new MileageFeeCalculator();

带有注解@Service、@Component、@Configuration的bean在
中创建 服务器启动时 Spring 的应用程序上下文。但是当我们创建对象时 使用 new 运算符，对象未在已创建的应用程序上下文中注册。例如我使用过的 Employee.java 类。

看看这个：

public class ConfiguredTenantScopedBeanProcessor implements BeanFactoryPostProcessor {

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    String name = "tenant";
    System.out.println("Bean factory post processor is initialized"); 
    beanFactory.registerScope("employee", new Employee());

    Assert.state(beanFactory instanceof BeanDefinitionRegistry,
            "BeanFactory was not a BeanDefinitionRegistry, so CustomScope cannot be used.");
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

    for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
        if (name.equals(definition.getScope())) {
            BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(definition, beanName), registry, true);
            registry.registerBeanDefinition(beanName, proxyHolder.getBeanDefinition());
        }
    }
}

}

Answer 6

我是 Spring 新手，但我发现了这个可行的解决方案。请告诉我这是否是一种不受欢迎的方式。

我让 Spring 在这个 bean 中注入 applicationContext：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class SpringUtils {

    public static ApplicationContext ctx;

    /**
     * Make Spring inject the application context
     * and save it on a static variable,
     * so that it can be accessed from any point in the application. 
     */
    @Autowired
    private void setApplicationContext(ApplicationContext applicationContext) {
        ctx = applicationContext;       
    }
}

如果需要，您也可以将此代码放在主应用程序类中。

其他类可以这样使用：

MyBean myBean = (MyBean)SpringUtils.ctx.getBean(MyBean.class);

通过这种方式应用程序中的任何对象都可以获取任何 bean（也可以用new 进行实例化）并且以静态方式。

Answer 7

这似乎是罕见的情况，但这是发生在我身上的事情：

我们使用 @Inject 代替 Spring 支持的 javaee 标准 @Autowired。每个地方都运行良好，豆子注入正确，而不是一个地方。 bean注入似乎一样

@Inject
Calculator myCalculator

最后我们发现错误是我们（实际上是Eclipse自动完成功能）导入了com.opensymphony.xwork2.Inject而不是javax.inject.Inject！

总而言之，请确保您的注释（@Autowired、@Inject、@Service，...）具有正确的包！

Answer 8

此处未提及的内容在this 文章“执行顺序”段落中进行了描述。

在“学习”我必须用 @Component 或派生的 @Service 或 @Repository （我猜还有更多）注释一个类之后，为了自动装配其中的其他组件，让我感到震惊的是，这些其他组件仍然为空在父组件的构造函数中。

使用@PostConstruct 解决了这个问题：

@SpringBootApplication
public class Application {
    @Autowired MyComponent comp;
}

和：

@Component
public class MyComponent {
    @Autowired ComponentDAO dao;

    public MyComponent() {
        // dao is null here
    }

    @PostConstruct
    public void init() {
        // dao is initialized here
    }
}

Answer 9

以下其中一项将起作用：

1. 您使用 @Autowired 的类不是 Bean（我确定您可能在某处使用过 new()）。

2. 在 SpringConfig 类中，您没有提到 Spring 应该寻找 @Component 的包（我说的是 @ComponentScan(basePackages"here")）

如果以上两个不起作用....开始放置 System.out.println() 并找出问题所在。

Answer 10

如果在测试类中发生这种情况，请确保您没有忘记对类进行注释。

例如，在Spring Boot中：

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTests {
    ....

---

过了一段时间...

Spring Boot continues to evolve。不再需要使用@RunWith如果您使用正确版本的 JUnit。

要让@SpringBootTest 独立工作，您需要使用JUnit5 instead of JUnit4 中的@Test。

//import org.junit.Test; // JUnit4
import org.junit.jupiter.api.Test; // JUnit5

@SpringBootTest
public class MyTests {
    ....

---

如果此配置错误，您的测试将编译，但 @Autowired 和 @Value 字段（例如）将是 null。由于 Spring Boot 是通过魔术运行的，因此您可能没有多少途径可以直接调试此故障。

Answer 11

另一种解决方案是拨打电话： SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this)
像这样对 MileageFeeCalculator 构造函数：

@Service
public class MileageFeeCalculator {

    @Autowired
    private MileageRateService rateService; // <--- will be autowired when constructor is called

    public MileageFeeCalculator() {
        SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this)
    }

    public float mileageCharge(final int miles) {
        return (miles * rateService.ratePerMile()); 
    }
}

Answer 12

我认为您错过了指示 spring 扫描带有注释的类。

你可以在你的spring应用的配置类中使用@ComponentScan("packageToScan")来指示spring进行扫描。

@Service, @Component等注解添加元描述。

Spring 只注入那些被创建为 bean 或用注解标记的类的实例。

注解的类在注入前需要spring识别，@ComponentScan指示spring查找注解的类。当 Spring 找到 @Autowired 时，它会搜索相关的 bean，并注入所需的实例。

只添加注解，不修复也不方便依赖注入，Spring需要知道去哪里找。

Answer 13

简单来说，@Autowired 字段为null 主要有两个原因

• 你的课程不是春豆。

• 田野不是豆子。

Answer 14

更新：真正聪明的人很快就会指出this的答案，这解释了下面描述的怪异

原始答案：

我不知道它是否对任何人有帮助，但即使在做看似正确的事情时，我也遇到了同样的问题。在我的 Main 方法中，我有这样的代码：

ApplicationContext context =
    new ClassPathXmlApplicationContext(new String[] {
        "common.xml",
        "token.xml",
        "pep-config.xml" });
    TokenInitializer ti = context.getBean(TokenInitializer.class);

在token.xml 文件中我有一行

<context:component-scan base-package="package.path"/>

我注意到 package.path 不再存在，所以我已经放弃了这条线。

在那之后，NPE 开始出现。在 pep-config.xml 我只有 2 个 bean：

<bean id="someAbac" class="com.pep.SomeAbac" init-method="init"/>
<bean id="settings" class="com.pep.Settings"/>

并且 SomeAbac 类有一个属性声明为

@Autowired private Settings settings;

由于某些未知原因，init() 中的设置为 null，当 <context:component-scan/> 元素根本不存在时，但当它存在并且有一些 bs 作为 basePackage 时，一切正常。这行现在看起来像这样：

<context:component-scan base-package="some.shit"/>

它有效。可能有人可以提供解释，但对我来说现在就足够了）

Answer 15

这是导致 NullPointerException MileageFeeCalculator calc = new MileageFeeCalculator(); 的罪魁祸首我们使用的是 Spring - 不需要手动创建对象。对象的创建将由 IoC 容器负责。

Answer 16

您还可以在服务类上使用@Service 注释并将所需的bean classA 作为参数传递给其他bean classB 构造函数并使用@Autowired 注释classB 的构造函数来解决此问题。此处为 sn-p 示例：

@Service
public class ClassB {

    private ClassA classA;

    @Autowired
    public ClassB(ClassA classA) {
        this.classA = classA;
    }

    public void useClassAObjectHere(){
        classA.callMethodOnObjectA();
    }
}

Answer 17

还要注意，如果出于某种原因，您在 @Service 中创建了一个方法为 final，那么您将从它访问的自动装配的 bean 将始终是 null。

Answer 18

这仅在单元测试的情况下有效。

我的服务类有一个服务注解，它是@autowired 另一个组件类。当我测试组件类时为空。因为对于服务类，我使用new创建对象

如果您正在编写单元测试，请确保您没有使用 new object() 创建对象。改用 injectMock。

这解决了我的问题。这是一个有用的link

Answer 19

与问题不完全相关，但如果字段注入为空，基于构造函数的注入仍然可以正常工作。

    private OrderingClient orderingClient;
    private Sales2Client sales2Client;
    private Settings2Client settings2Client;

    @Autowired
    public BrinkWebTool(OrderingClient orderingClient, Sales2Client sales2Client, Settings2Client settings2Client) {
        this.orderingClient = orderingClient;
        this.sales2Client = sales2Client;
        this.settings2Client = settings2Client;
    }

Answer 20

另外，不要注入static 成员，它将是null。

Answer 21

如果您使用private 方法，它将是null，请尝试在控制器中将private 更改为public。