一文彻底搞懂Java项目中DI注入失败的六大常见原因与解法

@Service
public class OrderService {
    // 字段注入（便捷但不利于单元测试和不可变性）
    @Autowired
    private PaymentService paymentService;

    // 更推荐的方式：构造器注入
    private final UserService userService;
  
    public OrderService(UserService userService) {
        this.userService = userService;
    }
}

// 正确做法：注解加在实现类上
@Service
public class UserServiceImpl implements UserService {
    // ...
}

// 启动类在 com.example.app
@SpringBootApplication
public class Application { ... }

// UserServiceImpl 在 com.example.app.service → ✅ 被扫描
// UserServiceImpl 在 com.example.core.service → ❌ 不被扫描

@ComponentScan(basePackages = {"com.example.app", "com.example.core"})

# application.properties
app.name=MyOrderSystem
app.port=8080

@Component
public class AppConfig {
    @Value("${app.name}")   // ✅ 匹配
    private String appName;

    @Value("#{systemProperties['user.home']}") // 支持 SpEL 表达式
    private String userHome;
}

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private int port;
    // getter/setter
}

app.name=MyOrderSystem
app.port=8080

// 必须导入 Spring 的 Autowired
import org.springframework.beans.factory.annotation.Autowired;

mvn dependency:tree -Dincludes=org.springframework

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;
}

@Service
public class PaymentService {
    @Autowired
    private OrderService orderService; // 能成功注入
}

@Service
public class OrderService {
    private final PaymentService paymentService;
  
    public OrderService(@Lazy PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

// 新增服务
@Service
public class OrderPaymentCoordinator {
    public void processOrderAndPay() { ... }
}

// OrderService 和 PaymentService 均依赖 Coordinator，消除彼此依赖

public class OrderController {
    public void createOrder() {
        OrderService service = new OrderService(); // ❌ 手动 new
        service.process(); // 内部依赖（如 paymentService）为 null，NPE！
    }
}

@Controller
public class OrderController {
    @Autowired
    private OrderService orderService; // ✅ 由 Spring 注入

    public void createOrder() {
        orderService.process();
    }
}

@Service
public class OrderServiceFactory {
    @Autowired
    private PaymentService paymentService;

    public OrderService create() {
        OrderService service = new OrderService();
        service.setPaymentService(paymentService); // 手动设置依赖
        return service;
    }
}

@Component
public class SpringContextHelper implements ApplicationContextAware {
    private static ApplicationContext ctx;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        ctx = applicationContext;
    }

    public static <T> T getBean(Class<T> clazz) {
        return ctx.getBean(clazz);
    }
}

// 使用
OrderService service = SpringContextHelper.getBean(OrderService.class);

public class MyUtils { // 普通工具类，未被 Spring 管理
    @Autowired
    private OrderService orderService; // 总是 null！

    public void doSomething() {
        orderService.process(); // NPE
    }
}

@Component // 添加注解
public class MyUtils {
    @Autowired
    private OrderService orderService; // ✅ 正常注入
}

public class MyUtils {
    public void doSomething(OrderService orderService) {
        orderService.process(); // 依赖由外部传入
    }
}

@Service
public class ClientService {
    @Autowired
    private OrderService orderService;

    public void run() {
        MyUtils utils = new MyUtils();
        utils.doSomething(orderService); // 传入依赖
    }
}

public class DateUtils {
    public static String format(LocalDateTime time) {
        return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }
}
// 无需依赖注入，无状态，可直接调用