java 构造函数

在Java中，构造函数是用于初始化对象的特殊方法。构造函数具有与类同名的方法，并且没有返回类型。以下是Java构造函数的一些关键点和示例：

特点：

1. 名称与类名相同：构造函数的名称必须与类的名称完全一致。
2. 没有返回类型：构造函数不返回任何类型，包括void。
3. 自动调用：当创建类的对象时，构造函数被自动调用。
4. 可以重载：可以在一个类中定义多个构造函数，每个构造函数具有不同的参数列表。
5. 默认构造函数：如果没有定义任何构造函数，Java编译器会提供一个默认的无参构造函数。

构造函数的类型：

1. 无参构造函数：没有参数的构造函数。
2. 有参构造函数：含有参数的构造函数，用于初始化对象时传递不同的值。

示例代码：

class Car {
    String model;
    int year;

    // 无参构造函数
    Car() {
        this.model = "Default Model";
        this.year = 0;
    }

    // 有参构造函数
    Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用无参构造函数
        Car car1 = new Car();
        car1.displayInfo();

        // 使用有参构造函数
        Car car2 = new Car("test", 0000);
        car2.displayInfo();
    }
}

执行结果：

Model: Default Model, Year: 0
Model: test, Year: 0000

在这个例子中，我们定义了一个Car类，有两个构造函数。第一个是无参构造函数，默认赋值给model和year。第二个是有参构造函数，允许在创建对象时指定model和year的值。

springboot 构造函数

在Spring Boot和Spring框架中，构造函数通常用于依赖注入。Spring通过构造函数将所需的依赖项注入到类中。在Spring应用程序中，使用构造函数注入可以确保类的依赖项在对象创建时就被完全初始化。

构造函数注入的优点:

1. 不可变性：通过构造函数注入，依赖项在对象创建后就是不可变的。
2. 可测试性：容易进行单元测试，因为依赖项可以通过构造函数的参数传递。
3. 完成初始化：在对象创建时就可以保证其依赖项的完整性。

如何在Spring Boot中使用构造函数注入:

以下是一个简单的例子，演示了如何在Spring Boot中使用构造函数注入^{1 2}：

示例代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    // 构造函数注入
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

在上面的代码中，我们有一个UserService类，该类依赖于UserRepository。通过使用构造函数注入，我们确保在UserService实例化时，userRepository已经被注入。如果@Autowired不想用（因为在Spring 4.3以后，如果只存在一个构造函数的话，@Autowired是可以省略的）。

配合Spring Boot应用：

下面是一个更完整的Spring Boot应用示例：

Application.java - 主应用程序入口

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

UserRepository.java - 模拟的仓库接口

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

User.java - 实体类（假设有一个User实体）

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    private Long id;
    private String name;

    // Getters and setters
    // ...
}

这个例子演示了如何通过构造函数注入将UserRepository注入到UserService中，以便在服务类中可以使用该仓库进行数据库操作。这样做使得代码更清晰、可维护，还便利了测试过程。

springboot 有参构造

在Spring Boot中，有参构造函数通常用作显式的依赖注入方式之一，通过构造函数将所需的依赖项注入到类中。Spring会自动识别构造函数，并使用上下文中定义的bean来满足依赖关系。

有参构造函数注入

有参构造函数注入是一种依赖注入的方式，其中通过构造函数传递所需的依赖项。在Spring 4.3及更高版本中，如果类只有一个构造函数，Spring会自动使用该构造函数进行注入，无需显式添加@Autowired注解。

示例代码

以下示例展示了如何在Spring Boot中使用有参构造函数进行依赖注入：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

// 一个示例服务类
@Service
public class OrderService {

    private final PaymentService paymentService;
    private final NotificationService notificationService;

    // 使用有参构造函数进行依赖注入
    @Autowired
    public OrderService(PaymentService paymentService, NotificationService notificationService) {
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }

    public void placeOrder(Order order) {
        // 处理支付
        paymentService.processPayment(order.getAmount());

        // 发送通知
        notificationService.notifyUser(order.getUser());

        // 订单处理逻辑
        System.out.println("Order placed successfully!");
    }
}

支持的依赖类

假设还有相应的PaymentService和NotificationService类：

import org.springframework.stereotype.Service;

// 支付服务
@Service
public class PaymentService {
    public void processPayment(double amount) {
        System.out.println("Processed payment of $" + amount);
    }
}

// 通知服务
@Service
public class NotificationService {
    public void notifyUser(String user) {
        System.out.println("Notification sent to user: " + user);
    }
}

主应用程序入口

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

说明

1. OrderService 使用了两个服务：PaymentService 和 NotificationService，它们通过构造函数参数传递进行注入。
2. 自动装配：构造函数注入是通过@Autowired进行的，不过在Spring 4.3之后，如果类只有一个构造函数，可以省略@Autowired。
3. 无循环依赖：构造函数注入避免了循环依赖问题，确保在实例化时所有依赖项都已经准备就绪。

这样设计能够确保代码的清晰性和模块化，同时也保持了服务组件的独立性和测试的便利性。

springboot 无参构造

在Spring Boot中，使用无参构造函数的情况一般出现在需要用默认值初始化对象或当类中没有复杂的依赖关系时。在很多情况下，Spring自身会使用无参构造函数来初始化bean，特别是当没有声明任何构造函数时，Java会提供一个默认的无参构造函数。

使用无参构造函数的场景

无参构造函数通常用于简单的POJO（Plain Old Java Objects）或DTO（Data Transfer Objects），它们不需要Spring进行管理的复杂依赖注入。

示例代码

下面是一个简单的示例，演示如何在Spring Boot中使用无参构造函数：

import org.springframework.stereotype.Service;

@Service
public class SimpleService {

    private String message;

    // 无参构造函数
    public SimpleService() {
        this.message = "Default Message";
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void showMessage() {
        System.out.println("Message: " + message);
    }
}

在这个示例中，SimpleService类拥有一个无参构造函数，用于初始化message字段为默认值。

POJO或DTO类示例

通常，无参构造函数也用于数据传输对象：

public class UserDTO {

    private Long id;
    private String name;
    private String email;

    // 无参构造函数
    public UserDTO() {
    }

    public UserDTO(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

说明

1. 默认构造：当类中没有其他构造函数时，Java会自动提供一个无参构造函数。
2. Spring使用：在Spring中，若未明定义构造函数或使用默认无参构造函数，Spring可以通过反射创建bean实例。
3. 不参与依赖注入：无参构造函数不涉及依赖注入，适用于简单的对象实例化。

这种简单的无参构造在Spring Boot项目中适用于那些不需要复杂初始化的类，例如只包含数据的DTO类或简单的服务类。这有助于保持代码的简单性和清晰性。

@RequiredArgsConstructor

@RequiredArgsConstructor 是 Lombok 提供的一个注解，用于自动生成类的构造函数。这个构造函数会包含所有被 final 修饰的字段以及带有 @NonNull 注解的字段。使用这个注解可以减少样板代码，尤其是在需要依赖注入的场景中。

使用场景

在Spring Boot中，@RequiredArgsConstructor 常用于服务类中，通过构造函数注入依赖项。它可以自动生成一个包含所有 final 字段的构造函数，这些字段通常是需要注入的依赖。

示例代码

以下是一个使用 @RequiredArgsConstructor 的示例：

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class OrderService {

    private final PaymentService paymentService;
    private final NotificationService notificationService;

    public void placeOrder(Order order) {
        // 处理支付
        paymentService.processPayment(order.getAmount());

        // 发送通知
        notificationService.notifyUser(order.getUser());

        // 订单处理逻辑
        System.out.println("Order placed successfully!");
    }
}

说明

1. 自动生成构造函数：@RequiredArgsConstructor 会自动生成一个构造函数，该构造函数包含所有 final 字段。在这个例子中，paymentService 和 notificationService 是 final 字段，因此它们会被包含在构造函数中。

2. 依赖注入：在Spring中，@RequiredArgsConstructor 常用于构造函数注入。Spring会自动识别生成的构造函数，并使用上下文中的bean来满足这些依赖。

3. 减少样板代码：使用 @RequiredArgsConstructor 可以减少手动编写构造函数的样板代码，使代码更简洁。

使用Lombok的注意事项

• IDE支持：确保你的IDE（如IntelliJ IDEA或Eclipse）安装了Lombok插件，以便正确识别和处理Lombok注解。
• 编译器配置：在项目的构建工具（如Maven或Gradle）中配置Lombok依赖，以确保在构建时正确处理Lombok注解。

通过使用 @RequiredArgsConstructor，开发者可以更专注于业务逻辑，而不必担心构造函数的编写和维护。

不使用@RequiredArgsConstructor

如果不使用 @RequiredArgsConstructor，你需要手动编写构造函数来实现依赖注入。手动编写构造函数虽然稍显繁琐，但可以让你对构造函数的行为有更明确的控制。

手动编写构造函数示例

以下是一个不使用 @RequiredArgsConstructor 的示例，展示如何手动编写构造函数来进行依赖注入：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final PaymentService paymentService;
    private final NotificationService notificationService;

    // 手动编写的构造函数
    @Autowired
    public OrderService(PaymentService paymentService, NotificationService notificationService) {
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }

    public void placeOrder(Order order) {
        // 处理支付
        paymentService.processPayment(order.getAmount());

        // 发送通知
        notificationService.notifyUser(order.getUser());

        // 订单处理逻辑
        System.out.println("Order placed successfully!");
    }
}

说明

1. 构造函数注入：通过手动编写构造函数，将 PaymentService 和 NotificationService 作为参数传入，并使用 @Autowired 注解进行依赖注入。

2. final 关键字：paymentService 和 notificationService 被声明为 final，确保它们在对象创建后不可变。

3. @Autowired 注解：虽然在Spring 4.3及更高版本中，如果类只有一个构造函数，可以省略 @Autowired，但显式使用 @Autowired 可以提高代码的可读性。

手动编写构造函数的优点

• 明确性：手动编写构造函数可以让代码更明确，特别是在需要对构造函数进行特殊处理时。
• 灵活性：可以在构造函数中添加额外的逻辑，如参数验证或初始化操作。

手动编写构造函数虽然增加了一些样板代码，但在某些情况下（如需要自定义逻辑或不使用Lombok时）是必要的。通过这种方式，你可以完全控制对象的初始化过程。

参考:

---

1. 为什么Spring不推荐使用@Autowired进行字段注 ↩︎

2. @Autowired @Resource ↩︎