spring注入的几种方式（文件配置以及注解方式）

已于 2022-07-20 17:39:00 修改
阅读量4.5k 收藏 15
点赞数 2
分类专栏： 笔记 文章标签： spring java 后端
于 2022-07-20 17:25:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ha_lee/article/details/125888583
版权

前言

spring利用IOC（控制反转）机制，将创建对象的权利交给了spring框架，从而降低程序的耦合。spring有文件配置和注解两种策略来实现Bean对象的创建和注入，这两种方式可以相互代替，后面将对应记录两种方式的使用。

一、文件配置的方式

1.在根目录创建配置文件

命名为config.xml，配置spring必要内容：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

2.通过构造方法注入

通过调用bean所属类的带参构造器为bean的属性注入值。这也就意味着，如果需要使用构造器注入，就得为类提供包含参数的构造方法。

  • id：注入的bean实例变量名
  • class：指定全限定类名
  • scope：指定作用范围，"prototype"多例，"singleton"单例（默认）
  • name：指定构造函数参数名
  • index：指定构造函数参数索引
  • type：通过参数类型指定参数
  • value：指定参数值（基本类型，String类型）
  • ref：指定参数值（Bean类型，在配置文件中配置过的bean）
<!--
使用<constructor-arg>标签指定构造函数的参数以及设定的参数值
基本类型和String类型使用value赋值，引用Bean类型使用ref
同时，参数除了使用name，也可以使用index、type来指定
-->
<bean id="car" class="XMLBean.Car">
    <constructor-arg name="price" value="10000"></constructor-arg>
    <constructor-arg name="speed" value="80"></constructor-arg>
</bean>

<bean id="user" class="XMLBean.User">
    <constructor-arg name="age" value="50"></constructor-arg>
    <constructor-arg name="car" ref="car"></constructor-arg>
    <constructor-arg name="name" value="周润发"></constructor-arg>
</bean>

3.通过set方法注入

如果需要使用set注入，那么必须要为属性提供set方法，Spring容器就是通过调用bean的set方法为属性注入值的。而在xml文件中，使用set注入的方式就是通过property标签，如下所示：

<bean id="car" class="XMLBean.Car">
    <property name="price" value="10000"></property>
    <property name="speed" value="80"></property>
</bean>

<bean id="user" class="XMLBean.User">
    <property name="age" value="50"></property>
    <property name="car" ref="car"></property>
    <property name="name" value="周润发"></property>
</bean>

使用set注入一些复杂的数据类型/集合：

<!--注入集合数据/复杂数据类型：
    用于List结构集合的标签：
        List，set，array
    用于Map结构集合的标签：
        map,pro
    结构相同，标签可以互换
-->
<bean id="accountDao3" class="AccountDaoImpl3">
    <property name="strings">
        <array>
            <value>AAA</value>
            <value>BBB</value>
        </array>
    </property>
    <property name="myList">
        <list>
            <value>AAA</value>
            <value>BBB</value>
        </list>
    </property>
    <property name="myMap">
        <map>
            <entry key="AAA" value="aaa"></entry>
            <entry key="BBB">
                <value>bbb</value>
            </entry>
        </map>
    </property>
    <property name="myProperty">
        <props>
            <prop key="AAA">aaa</prop>
            <prop key="BBB">bbb</prop>
        </props>
    </property>

</bean>

3.使用静态工厂注入

静态工厂注入就是编写一个静态的工厂方法，这个工厂方法会返回我们需要的产品类，然后在配置文件中，指定使用这个工厂方法创建bean。首先需要一个静态工厂，如下所示：

public class StaticFactory {
    //生产一个汽车类
    public static Car getCar() {
        return new Car(123, 54321);
    }
}

下面需要在xml中配置car这个bean，并指定它由工厂方法进行创建:

  • id：指定产品bean的变量名
  • class：指定工厂的全限定类名
  • factory-method指定工厂类生产产品的方法
<bean id="mycar" class="XMLBean.StaticFactory" factory-method="getCar">
</bean>

<bean id="user" class="XMLBean.User">
    <property name="age" value="50"></property>
    <property name="car" ref="mycar"></property>
    <property name="name" value="周润发"></property>
</bean>

4.使用实例工厂注入

实例工厂与静态工厂类似，不同的是，静态工厂调用工厂方法不需要先创建工厂类的对象，因为静态方法可以直接通过类调用，所以在上面的配置文件中，并没有声明工厂类的bean。但是，实例工厂，需要有一个实例对象，才能调用它的工厂方法。先看看实例工厂的定义：

public class InstanceFactory {
    /**
     * 实例工厂方法，返回一个Car的实例对象
     */
    public Car getCar() {
        return new Car(100, 70000);
    }
}

首先将实例化工厂Bean注入IOC容器中，之后注入产品bean，并指明工厂类和生产方法：

<bean id="instanceFactory" class="XMLBean.InstanceFactory">
</bean>  <!--将实例化工厂bean注入-->

<!--注入产品bean，并指明工厂bean和生产方法-->
<bean id="mycar" factory-bean="instanceFactory" factory-method="getCar">
</bean>

<bean id="user" class="XMLBean.User">
    <property name="age" value="50"></property>
    <property name="car" ref="mycar"></property>
    <property name="name" value="周润发"></property>
</bean>

测试实例

public class XmlBeanTest {
    @Test
    public void test1() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("config.xml");
        // 获取user这个bean
        User user = context.getBean("user",User.class);
        // 输出产看结果
        System.out.println(user);
    }
}

二、使用注解的方式

使用注解的好处：找到类就找到了bean注入的位置，不需要使用文件I/O，在大型系统中能够加快运行速度。
配置bean.xml文件：

<beans xmlns=http://www.springframework.org/schema/beans
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<!--可以隐式地自动向Spring容器注册4个BeanPostProcessor,
	这样就可以使用@ Resource 、@ PostConstruct、@ PreDestroy、@PersistenceContext、
	@Autowired、@Required等注解了实现自动注入-->
    <context:annotation-config/>

	<!--扫描的包的位置-->
    <context:component-scan base-package="包名"></context:component-scan>
</beans>

注解分为3类：

1.用于创建对象的注解

和xml配置中编写一个<bean>标签实现功能一样

  • @Component(value=)
    作用：将当前类对象存入spring容器中
    属性：value:用于指定bean的id；不写时，默认为类名首字母小写

  • @Controller：一般用于表现层
    @Service：一般用于业务层
    @Repository：一般用于持久层
    以上三个注解的作用和属性与Component是一模一样的。spring提供了三层注解，使对象更佳清晰。

将User类注入IOC容器中：

@Component(value = "user")  //将User类放入IOC容器中
public class User {

    private String name;
    private int age;
    private Car car;

    public User() {
    }
    public User(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

测试结果
可以看到@Component已经将User类注入，但是没有注入参数值。

public class AnnotationBeanTest {
    @Test
    public void test2() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        // 获取user这个bean
        User user = context.getBean("user", User.class);
        // 输出产看结果
        System.out.println(user);
    }
}

结果：
User{name='null', age=0, car=null}

2.用于注入数据的注解

和xml配置中<bean>标签下写一个<property>作用一样

@Autowired

作用： 按照类型自动注入，只要有唯一一个bean对象类型和注入类型匹配，就可以注入成功。ps: 如果ico容器中没有任何bean对象的类型和要注入的变量类型匹配，则报错；如果有多个类型匹配时，会先匹配相同类型名称，再匹配id——@Repository(“id”)
出现位置： 可以是变量上，也可以是方法上
细节： 在使用注释注入时，可以没有set方法

@Component("car") //放入spring容器中
public class Car {
    // 只包含基本数据类型的属性
    private int speed;
    private double price;

    public Car() {
    }
    public Car(int speed, double price) {
        this.speed = speed;
        this.price = price;
    }

    public int getSpeed() {
        return speed;
    }
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car{" +
                "speed=" + speed +
                ", price=" + price +
                '}';
    }
}

@Component(value = "user") //放入spring容器中
public class User {

    private String name;
    private int age;
    
    @Autowired //根据类型，自动找到IOC中的Car类型Bean注入
    private Car car;

    public User() {
    }
    public User(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

测试：
可以发现car不在是null，而是已经有一个初始值。这说明@Autowired已经将IOC容器中的car注入给了私有变量car。

public class AnnotationBeanTest {
    @Test
    public void test2() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        // 获取user这个bean
        User user = context.getBean("user", User.class);
        // 输出产看结果
        System.out.println(user);
    }
}

结果：
User{name='null', age=0, car=Car{speed=0, price=0.0}}

小结：
1.在成员变量上注入：

@Autowired //会找到spring容器中匹配的bean赋值给car
private Car car;

2.在构造函数上注入：

@Autowired //有多个参数时，注解写参数前面
public User(@Value("李连杰") String name, @Value("56") int age, @Autowired Car car) {
	//"李连杰"会注入给name
	//"56"会注入给age
	//查找合适bean注入给car
    this.name = name;
    this.age = age;
    this.car = car;
}

3.set注入：

@Autowired //调用set函数，将适当的bean注入给this.car
public void setCar(Car car) {
    this.car = car;
}

@Qualifier

作用： 在按照类型注入的基础上再按照名称注入。他在给类成员注入时不能单独使用，但是在给方法参数注入时可以。

@Autowired
@Qualifier("car")//给类成员变量注入时和@Autowired一起用
private Car car;

属性： value，用于指定bean的id

@Resourse

作用：直接参照bean的id注入，可以独立使用
属性： name:用于指定bean的id

@Resource(name = "car")
private Car car;

注：以上@Autowired、@Qualifier、@Resourse三个注入只能注入其他bean类型的数据，而基本类型和String类型无法使用这些注解，另外，集合类型的注入只能用过xml的方式来实现

@value

作用：用于注入基本类型和String类型的数据
属性：value:用于指定数据的值，可以使用spring中的spEL(spring的el表达式)
spEL的写法：$(表达式)

在User类中注入String和int类型的值：

//在成员变量中注入
@Value("成龙")
private String name;
@Value("60")
private int age;

//set注入
@Value("成龙")
public void setName(String name) {
    this.name = name;
}
@Value("60")
public void setAge(int age) {
    this.age = age;
}

3.用于改变作用范围

<bean>标签中适用scope属性实现功能一样
@Scope
作用：用于指定bean的范围
属性：value:常取值：singleton(单例，默认) 、prototype(多例)

4.和生命周期相关

@PreDestroy
作用：用于指定销毁方法
@PostConstruct
作用：用于指定初始化方法

5.使用配置注解代替xml配置文件

@Configuration
作用：指定当前类是一个配置类
细节：当名为Configuration类作为AnnotationConfigApplicationContext()参数时可以不添加@Configuration，否则必须要添加。

@ComponentScan
作用：通过此注解指定spring创建容器时要扫描的包
属性：value:它和basePackages的作用是一样的

@bean
作用：把当前方法的返回值作为bean对象存入spring的ioc容器中
属性：用于指定bean的id,不写时默认值是当前方法的名称
细节：当用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象，查找的方式和@Autowired注解的作用是一样的

public class SpringConfiguration {

    @Bean("car") //表示将函数返回的对象放入spring容器中
    public Car createCar(@Value("66") int speed, @Value("88888")double price){ //通过注解注入参数
        return new Car(speed,price);
    }

    @Bean("user")//表示将函数返回的对象放入spring容器中
    public User createUser(@Value("陈浩南") String name,@Value("33") int age,@Qualifier(value = "car") Car car){
        return new User(name,age,car);
    }
}

注：有了配置类，之前Car和User类前的@Component注解可以删除了。相当于已经通过配置类将响应的Bean放入了spring容器中。

测试

public class AnnotationBeanTest {
    @Test
    public void test2() {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 获取user这个bean
        User user = context.getBean("user", User.class);
        // 输出产看结果
        System.out.println(user);
    }
}

结果：
User{name='陈浩南', age=33, car=Car{speed=66, price=88888.0}}

@PropertySource
作用：用于指定properties文件的位置
属性：value：指定文件名的路径和名称；关键字：classpath表示在类路径下

//jdbc.properties文件：
jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/students
jdbc.username=root
jdbc.password=1234

@ComponentScan("com")
@PropertySource("classpath:jdbcConfigeration.properties")
public class SpringConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${user}")
    private String uer;
    @Value("${password}")
    private String password;

    @Bean  //将一个DataSource对象放入ioc容器
    public DataSource createDatasource(){
        try{
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(uer);
            ds.setPassword(password);
            System.out.println(driver+url+uer+password);
            return  ds;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

@Import
作用：用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解（不省略也可）。当使用@Import注解之后，有@Import注解的就是父配置类，而导入的是子配置类
属性：value[config.Class…] 用于指定配置类的字节码

@Configuration
@ComponentScan(basePackages = "com") 
@Import({ JdbcConfig.class})  //导入子配置类
public class SpringConfiguration { 
	//...
} 


@Configuration 
@PropertySource("classpath:jdbc.properties") 
public class JdbcConfig{ 
	//...
}

类对象配置总结：

  1. 创建一个config类，用@Configuration来注解
  2. 使用@ComponentScan(“包名”)来规定spring容器的扫描的包
  3. 使用@PropertySource("classpath: ")引入.properties配置文件（选用）
  4. 创建spring容器，以config.Class作为参数
  5. 用容器.getBean()获取bean类对象(提前用@bean或者三个创建对象的注解将对象放入IOC容器)
  6. 用@Value(“$()”)将.properties中的键值对成员变量进行注入
ha_lee
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring入门之Spring 常用的三种注入方式
black__cj的博客
08-24 1037
Spring 常用的三种注入方式 Spring 通过 DI（依赖注入）实现 IOC（控制反转），常用的注入方式主要有三种：构造方法注入，set 方法注入，基于注解的注入。 一、通过构造方法注入 先简单了解一下测试项目的结构，用 maven 构建的，四个包： entity：存储实体，里面只有一个 User 类 dao：数据访问，一个接口，两个实现类 service：服务层，一个接口，一个实现类，实现类依赖于 IUserDao test：测试包 在 spring 的配置文件中注册 UserService，将 U
Spring事务Transaction配置的五种注入方式详解
08-30
Spring事务Transaction配置的五种注入方式详解 Spring框架中的事务管理是通过TransactionManager来实现的，TransactionManager是Spring事务管理的核心组件。Spring提供了多种方式来配置事务，下面将详细介绍Spring...
spring 常用的注入方式有哪些？
热门推荐
ConstXiong
07-16 1万+
spring 常用的注入方式有哪些？ 1、xml中配置 bean 的申明、注册 <bean> 节点注册 bean <bean> 节点的 factory-bean 参数指工厂 bean，factory-method 参数指定工厂方法 bean 的注入 <property> 节点使用 set 方式注入 <constructor-arg> ...
SpringBoot学习（三）-配置文件和注解
最新发布
ligangit的博客
07-08 582
记录SpringBoot的学习，配置文件和注解，特别注意配置文件加载顺序
Spring方法注入
用平常的心，做不平常的事
08-10 162
[quote]在大部分情况下，容器中的bean都是singleton类型的。如果一个singleton bean要引用另外一个singleton bean，或者一个非singleton bean要引用另外一个非singleton bean时，通常情况下将一个bean定义为另一个bean的property值就可以了。不过对于具有不同生命周期的bean来说这样做就会有问题了，比如在调用一个single...
Spring中注入的三种方式
王硕的专栏
04-19 188
Spring中注入的三种方式   Type1 接口注入   我们常常借助接口来将调用者与实现者分离。如： Public class ClassA{ private InterfaceB clzB; public init(){ Object obj=Class.forName(Config.BImplementation).newInstance(); clzB=(Int...
Spring 注入方式
Imzhipo的博客
03-15 7415
Spring 注入方式有三中 1.setter注入 2.构造器注入 3.基于注解的注入 1.setter注入 在InjectionServiceImple 中有 变量 injectionDao 并有其的set方法 还有一点需要注意：如果通过set方法注入属性，那么spring会通过默认的空参构造方法来实例化对象，所以如果在类中写了一个带有参数的构造方法，一定要把空参数的构造方法写上，否则spring没有办法实例化对象，导致报错。 2.构造器注入 注意：配置文件中的nam.
详解Spring通过@Value注解注入属性的几种方式
08-30
本文将详细介绍通过`@Value`注解注入属性的几种常见方式。 ### 1. 基于属性文件注入 #### 1.1 `PropertyPlaceholderConfigurer` 当需要从属性文件（如`dev.properties`）中读取值时，可以使用`...
spring学习：依赖注入的几种方式讨论
08-09
本文将深入探讨Spring中的依赖注入实现方式，以及如何通过样例文件`sample-autoconfig`进行理解和实践。 一、XML配置的依赖注入 在Spring早期版本中，XML配置是最常见的DI方式。开发者在Spring的配置文件（如`...
详解Spring-boot中读取config配置文件的两种方式
08-29
本文将深入探讨两种在Spring Boot中读取`config`配置文件的方法，特别是核心配置文件`application.properties`或`application.yml`以及自定义配置文件。 ### 一、读取核心配置文件信息 Spring Boot的核心配置文件...
Spring三种注入方式（二）
03-20
NULL 博文链接：https://gary0416.iteye.com/blog/889228
Spring的3种注入方式
09-18 182
关于Spring的注入方式 spring的三种注入方式： 接口注入（不推荐） getter，setter方式注入（比较常用） 构造器注入（死的应用） 关于getter和setter方式的注入： autowire="defualt" autowire=“byName” autowire="bytyp...
Spring的注入方式
CTO成长之路——Rosanu
05-09 808
spring的三种注入方式： 接口注入（不推荐） getter，setter方式注入（比较常用） 构造器注入（死的应用） 关于getter和setter方式的注入： autowire="defualt" autowire=“byName” autowire="bytype" 例如：有如下两个类需要注入 1 package org.jia; 2 3
Spring常用的三种注入方式
qq_41273137的博客
04-03 4679
Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：构造方法注入（实体类），setter注入，基于注解的注入。
Spring常用的注入方式
cxbtdd的博客
11-05 70
这三种注入方式既可以基于xml配置文件注入，也可以基于@Configuration注解的配置类注入。下面是通过配置文件方式注入的三种方式。如果是基于@Configuration配置类方式注入，就不用写配置文件，但是需要编写配置类，在配置类上加上@Configuration和@ComponentScan(“需要扫描的包名”)注解，同时在UserService和UserDao上加上@Component注解，通常是在Service类上加上@Service注解，在Dao类上加上@Repository注解。
Spring注入的几种形式
neaudiy的专栏
08-08 789
package com.bean; public class Product { public Product(int id, String name) { this.id = id; this.name = name; } private in
spring注入的几种方式
iteye_1985的博客
03-23 287
1、setter方式（最常用）   就是在bean中的属性必须有setter方法 然后在xml在配置 2、构造方法（不常用） 参考官方api的例子：   &lt;beans&gt; &lt;bean name="foo" class="x.y.Foo"&gt; &lt;constructor-arg&gt; &lt;bean clas...
spring的几种注入方式
qiuz1024的博客
08-26 632
在spring中，依赖注入的方式有很多种，我个人认为在spring中注入方式有3中，分别是通过属性filed注入、构造方法注入、set方法注入。接下来通过代码具体分析一下。 1、属性filed @Autowired加在属性上，采用的是filed反射注入。 @Component public class StayService { @Autowired private StayDao stayD...
Spring Bean装配方式详解：XML、注解与Java配置
本文将深入探讨Spring框架中Bean的三种常用装配方式：基于XML的装配、基于注解的装配以及基于Java配置类的装配。首先，我们回顾基于XML的装配，这是Spring早期的主要装配方式，它通过在XML配置文件中定义`<bean>`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值