Spring注入bean的几种方式

思静语

已于 2024-08-13 15:29:55 修改

阅读量958

点赞数 26

分类专栏： # Spring 文章标签： spring java

于 2024-08-13 15:26:53 首次发布

本文链接：https://blog.csdn.net/Fireworkit/article/details/141165036

版权

Spring 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

文章目录

使用注解注入Bean

在Spring中，如果你不使用XML配置文件，可以通过以下几种方式注入Bean：

1. 使用注解 (@Component、@Service、@Repository、@Controller) 和 @Autowired

1.1 @Component 注解
@Component 注解用于标注一个普通的Spring Bean，它会自动注册为Spring的组件，Spring容器会自动扫描并管理这些Bean。

@Component
public class Engine {
    // Engine implementation
}

1.2 @Service, @Repository, @Controller 注解
这些注解是 @Component 的特殊化，分别用于标注服务层、数据访问层和控制层的Bean。

@Service
public class CarService {
    // Service implementation
}

@Repository
public class CarRepository {
    // Repository implementation
}

@Controller
public class CarController {
    // Controller implementation
}

1.3 @Autowired 注解
@Autowired 注解用于自动装配依赖，Spring会自动在容器中查找并注入符合要求的Bean。

@Component
public class Car {
    private final Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }
}

可以将 @Autowired 放在构造器、Setter方法，或字段上。

@Component
public class Car {
    @Autowired
    private Engine engine;

    public Engine getEngine() {
        return engine;
    }
}

2. 使用@Configuration 和 @Bean

使用Java配置类替代XML文件，通过 @Configuration 注解标注配置类，使用 @Bean 注解定义Bean。
2.1 @Configuration 和 @Bean

@Configuration
public class AppConfig {

    @Bean
    public Engine engine() {
        return new Engine();
    }

    @Bean
    public Car car(Engine engine) {
        return new Car(engine);
    }
}

2.2 与@ComponentScan结合
可以在配置类中使用 @ComponentScan 注解来自动扫描指定包下的所有 @Component，@Service，@Repository，和 @Controller 注解的Bean。

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // Additional bean definitions if needed
}

使用@Qualifier 区分不同的Bean
当同一类型有多个Bean时，可以使用 @Qualifier 注解指定要注入的具体Bean。

@Component
public class Car {
    private final Engine engine;

    @Autowired
    public Car(@Qualifier("v8Engine") Engine engine) {
        this.engine = engine;
    }
}

@Configuration
public class AppConfig {

    @Bean
    public Engine v6Engine() {
        return new Engine("V6");
    }

    @Bean
    public Engine v8Engine() {
        return new Engine("V8");
    }
}

4. 使用构造函数注入

构造函数注入是推荐的方式，尤其是在使用 @Autowired 的时候。它确保了依赖项在对象构造时被注入，并且适合对必须提供的依赖项进行强制性注入。

@Component
public class Car {
    private final Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }
}

5. 使用@Value注入属性值

可以使用 @Value 注解从配置文件中注入简单的属性值。

@Component
public class Car {
    
    @Value("${car.brand}")
    private String brand;

    // getters and setters
}

6. 使用 @Primary 标注优先注入的Bean

当多个相同类型的Bean存在时，可以使用 @Primary 注解标注优先注入的Bean。

@Component
@Primary
public class V8Engine implements Engine {
    // Implementation
}

@Component
public class V6Engine implements Engine {
    // Implementation
}

通过注解和Java配置类，你可以很方便地实现Spring中的依赖注入，而不需要依赖XML配置文件。使用这些注解可以使代码更加简洁，并且更容易理解和维护。

Spring基于xml注入bean的几种方式

在Spring中，通过XML配置文件来注入Bean的方式主要包括以下几种：构造器注入、Setter注入、接口注入和集合注入。下面是每种方式的代码样例。

1. 构造器注入

构造器注入是通过构造函数来注入依赖的。Spring会根据构造器参数的类型或位置来确定要注入的Bean。
代码示例：

public class Car {
    private String brand;

    public Car(String brand) {
        this.brand = brand;
    }

    // Getters and Setters
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

XML配置:
<bean id="car" class="com.example.Car">
    <constructor-arg value="Toyota"/>
</bean>

2. Setter注入

Setter注入是通过Setter方法来注入依赖的。Spring会调用对应的Setter方法为Bean的属性注入值。
代码示例：
Bean Class:

public class Car {
    private String brand;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    // Getters and Setters
    public String getBrand() {
        return brand;
    }
}

XML配置:
<bean id="car" class="com.example.Car">
    <property name="brand" value="Honda"/>
</bean>

3. 接口注入（与Spring的FactoryBean结合使用）

接口注入通常用于一些特殊场景，比如使用Spring的 FactoryBean 接口。这个接口允许你定制对象的创建方式。
代码示例：
FactoryBean Class:

public class CarFactoryBean implements FactoryBean<Car> {
    private String brand;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public Car getObject() throws Exception {
        return new Car(brand);
    }

    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }
}

XML配置:

<bean id="carFactoryBean" class="com.example.CarFactoryBean">
    <property name="brand" value="BMW"/>
</bean>

<!-- 获取通过FactoryBean创建的Car对象 -->
<bean id="car" factory-bean="carFactoryBean" factory-method="getObject"/>

4. 集合注入

Spring允许通过XML配置将多个值注入到集合类型的属性中，例如 List、Set、Map 等。
代码示例：
Bean Class:

import java.util.List;

public class Garage {
    private List<Car> cars;

    public void setCars(List<Car> cars) {
        this.cars = cars;
    }

    // Getters and Setters
    public List<Car> getCars() {
        return cars;
    }
}

XML配置:

<bean id="car1" class="com.example.Car">
    <property name="brand" value="Tesla"/>
</bean>

<bean id="car2" class="com.example.Car">
    <property name="brand" value="Ford"/>
</bean>

<bean id="garage" class="com.example.Garage">
    <property name="cars">
        <list>
            <ref bean="car1"/>
            <ref bean="car2"/>
        </list>

    </property>

</bean>

5. 自动装配（Autowiring）注入

Spring也支持通过自动装配的方式注入Bean。可以在XML中配置自动装配策略，如 byName、byType 或 constructor。
代码示例：

public class Engine {
    private String type;

    public void setType(String type) {
        this.type = type;
    }

    // Getters and Setters
    public String getType() {
        return type;
    }
}

public class Car {
    private Engine engine;

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    // Getters and Setters
    public Engine getEngine() {
        return engine;
    }
}

XML配置:

<bean id="engine" class="com.example.Engine">
    <property name="type" value="V8"/>
</bean>
<bean id="car" class="com.example.Car" autowire="byType"/>

在上面的配置中，Spring会自动将名为 engine 的 Engine Bean 注入到 Car Bean 中的 engine 属性，因为它们的类型匹配。

6. 引入（inner beans）

有时我们不需要为依赖创建独立的Bean，可以在另一个Bean中直接定义依赖的Bean，这叫做内联Bean。
代码示例：

Bean Class:
public class Wheel {
    private String type;

    public void setType(String type) {
        this.type = type;
    }

    // Getters and Setters
    public String getType() {
        return type;
    }
}

public class Car {
    private Wheel wheel;

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    // Getters and Setters
    public Wheel getWheel() {
        return wheel;
    }
}

XML配置:

<bean id="car" class="com.example.Car">
    <property name="wheel">
        <bean class="com.example.Wheel">
            <property name="type" value="Alloy"/>
        </bean>

    </property>

</bean>

在此示例中，Wheel Bean 直接在 Car Bean 的配置中定义，而不是单独定义。