Spring Setter注入原理

最新推荐文章于 2023-06-07 16:52:28 发布
最新推荐文章于 2023-06-07 16:52:28 发布
阅读量4.9k 收藏 2
点赞数
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng_xiaoshi/article/details/105832004
版权

本文内容如有错误、不足之处，欢迎技术爱好者们一同探讨，在本文下面讨论区留言，感谢。欢迎转载，转载请注明出处（https://blog.csdn.net/feng_xiaoshi/article/details/105832004），谢谢。

文章目录

简介

本文讨论 Setter 注入方式的原理，通过了解 Setter 注入方式的原理，来加深对 Spring IOC 的认识。通过本文将了解如何使用 autowire属性的 byType，byName 执行依赖注入。以及手动模式的 API 配置元信息的案例。

前期工作
引入依赖

pom.xml 中添加 Spring 的库依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.6.RELEASE</version>         
</dependency>
创建依赖类

有一个依赖于实际上处理业务逻辑的服务的应用程序类：
IndexApp.java

public class IndexApp {
    private IndexService service;
...
}

IndexService 是一个接口：
IndexService.java

public interface IndexService {
    public String serve();
...    
}

该接口可以有多种实现。 一个潜在的实现 DefaultIndexServiceImpl:
DefaultIndexServiceImpl.java

public class IndexService implements IService {
    @Override
    public String serve() {
        return "Hello World";
    }
}

设计上，IndexApp 是一个高级组件，它依赖于称为 IndexService 的低级组件。
本质上，将 IndexApp 与 IndexService 的具体实现的关联关系实现脱钩，而和 IndexService 的接口进行关联，因为该实现可能会因各种因素而有所不同。

模式

Setter 的实现方式有手动和自动两种。

手动模式

依赖注入是一种通过外部容器提供对象的依赖关系的技术。 因此需要通过外部化配置来进行指定和约束需要装配的内容和规则。
主要有以下三种手动方式进行约束。

  • XML 资源配置元信息
  • Java 注解配置元信息
  • API 配置元信息
XML 资源配置元信息

XML

在 XML 的配置中将依赖项连接在一起:
bean-setter.xml

<bean
  id="defaultIndexService"
  class="com.feng.di.spring.DefaultIndexServiceImpl" />
      
<bean
  id="indexApp"
  class="com.feng.di.spring.IndexApp" >
    <property name="service" ref="defaultIndexService" />
</bean>

可以看出，XML 配置创建 DefaultIndexServiceImpl 的实例并为其分配 ID 。默认情况下，bean 是单例。与此同时创建 IndexApp 的实例，在这个 bean 中，使用 setter 方法注入另一个 bean 。

测试代码：

/**
 * 基于 XML 资源的依赖 Setter 方法注入示例
 */
public class XmlDependencySetterInjectionDemo {

    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(beanFactory);

        String xmlResourcePath = "classpath:META-INF/bean-setter.xml";
        // 加载 xml 资源，并生成 BeanDefinition 资源
        xmlReader.loadBeanDefinitions(xmlResourcePath);
        IndexApp indexApp = beanFactory.getBean(IndexApp.class);
    }
}
Java 注解配置元信息

Spring Annotation

从Spring 2.5开始，可以使用注释配置依赖项注入。因此，可以使用相关类，方法或字段声明上的注释，而不是使用XML来描述bean的连接，而是可以将bean配置移入组件类本身。
注释注入在XML注入之前执行。因此，对于通过两种方法连接的属性，后一种配置将覆盖前者。
默认情况下，Spring容器中的注释接线未打开。因此，在使用基于注释的连接之前，需要在Spring配置文件中启用它。

<?xml version = "1.0" encoding = "UTF-8"?>

<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-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

</beans>

一旦配置了<context：annotation-config />，就可以开始注释代码，以指示Spring应该自动将值连接到属性，方法和构造函数中。
下面是一些注释列表：

序号注释与说明
1@Required批注适用于bean属性设置器方法。
2@Autowired批注可以应用于bean属性设置器方法，非设置器方法，构造函数和属性。
3@Qualifier注释和@Autowired可以通过指定将要连接的确切bean来消除混淆。
4Spring支持基于JSR-250的注释，包括@ Resource，@ PostConstruct和@PreDestroy注释。
Service 类例子

假设 向用户发送电子邮件和短息消息。对于依赖项注入，需要为服务提供一个基类。因此，MessageService 是用于发送消息的单一方法声明的接口。


package com.feng.spring.di.services;

public interface MessageService {

	boolean sendMessage(String msg, String rec);
}

现在， 有实际的实现类来发送电子邮件和短信消息。


package com.feng.spring.di.services;

public class EmailService implements MessageService {

	public boolean sendMessage(String msg, String rec) {
		System.out.println("Email Sent to "+rec+ " with Message="+msg);
		return true;
	}
}


package com.feng.spring.di.services;

public class SmsService implements MessageService {

	public boolean sendMessage(String msg, String rec) {
		System.out.println("Sms message Sent to "+rec+ " with Message="+msg);
		return true;
	}
}
Component 类例子

为上述 Service 编写一个消费者类。


package com.feng.spring.di.consumer;

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

import com.feng.spring.di.services.MessageService;

@Component
public class MyApplication {

	// 基于变量的依赖注入
	//@Autowired
	private MessageService service;
	
//	基于构造参数的 dependency injection	
//	@Autowired
//	public MyApplication(MessageService svc){
//		this.service=svc;
//	}
	
	@Autowired
	public void setService(MessageService svc){
		this.service=svc;
	}
	
	public boolean processMessage(String msg, String rec){
		//验证，日志等信息
		return this.service.sendMessage(msg, rec);
	}
}

关于 MyApplication 类的注意点：

  • @Component 注释被添加到该类中，以便当 Spring 框架扫描组件时，该类将被视为组件。@Component 批注只能应用于类，其保留策略是运行时。
  • @Autowired 注解用于让 Spring 知道需要自动装配。这可以应用于字段，构造函数和方法。这个注释使我们能够在组件中实现基于构造函数，基于字段或基于方法的依赖注入。
配置类

对于基于注释的配置，我们需要编写一个Configurator类，该类将用于将实际的实现bean注入到组件属性中。


package com.feng.spring.di.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import com.feng.spring.di.services.EmailService;
import com.feng.spring.di.services.MessageService;

@Configuration
@ComponentScan(value={"com.feng.spring.di.consumer"})
public class DIConfiguration {

	@Bean
	public MessageService getMessageService(){
		return new EmailService();
	}
}
  • @Configuration 注解用于让 Spring 知道它是 Configuration 类。
  • @ComponentScan 注解与 @Configuration 注解一起使用以指定要查找组件类的包。
  • @Bean 批注用于使 Spring 框架知道该方法应用于使 Bean 实现注入到 Component 类中。

编写一个简单的程序来测试基于注释的 Spring Dependency Injection 示例:


package com.feng.spring.di.test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.journaldev.spring.di.configuration.DIConfiguration;
import com.journaldev.spring.di.consumer.MyApplication;

public class ClientApplication {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DIConfiguration.class);
		MyApplication app = context.getBean(MyApplication.class);
		
		app.processMessage("Hi Pankaj", "pankaj@abc.com");
		
		// 关闭上下文
		context.close();
	}
}

AnnotationConfigApplicationContext 是 AbstractApplicationContext 抽象类的实现，用于在使用注释时将服务自动装配到组件。AnnotationConfigApplicationContext 构造函数将 Class 作为参数，用于获取 Bean 实现以注入组件类。

getBean(Class) 方法返回 Component 对象，并使用配置自动装配对象。上下文对象是资源密集型的，因此在完成操​​作后应将其关闭。
程序运行输出以下信息：

May 02, 2020 9:14:01 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@17f052a3: startup date [Sat May 02 21:14:01 CST 2020]; root of context hierarchy
Email Sent to pankaj@abc.com with Message=Hi Pankaj
May 02, 2020 9:14:02 PM org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@17f052a3: startup date [Sat May 02 21:14:01 CST 2020]; root of context hierarchy
API 配置元信息

API 配置元信息是通过构造 BeanDefinition 来实现的，代码如下：
ApiDependencySetterInjectionDemo.java

package com.feng.spring.di;

import com.feng.spring.di.consumer.MyApplication;
import com.feng.spring.di.services.EmailService;
import com.feng.spring.di.services.MessageService;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;

public class ApiDependencySetterInjectionDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ApiDependencySetterInjectionDemo.class);

        // 生成 MyApplication 的 BeanDefinition
        BeanDefinition beanDefinition = createMyApplicationBeanDefinition();
        // 注册 MyApplication的Bean
        context.registerBeanDefinition("myApplication", beanDefinition);
        
        MyApplication myApplication = context.getBean(MyApplication.class);
        myApplication.processMessage("hello bean definition", "abc@outlook.com");
        context.close();
    }

    private static BeanDefinition createMyApplicationBeanDefinition(){
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyApplication.class);
        builder.addPropertyReference("service", "messageService");
        return builder.getBeanDefinition();
    }

    @Bean(name = "messageService")
    public MessageService getMessageService(){
        return new EmailService();
    }
}

输出信息如下：

May 02, 2020 10:06:19 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@238e0d81: startup date [Sat May 02 22:06:19 CST 2020]; root of context hierarchy
Email Sent to abc@outlook.com with Message=hello bean definition
May 02, 2020 10:06:19 PM org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@238e0d81: startup date [Sat May 02 22:06:19 CST 2020]; root of context hierarchy
自动模式
  • byName
  • byType

下面通过示例来解释自动模式：
Order.java

package com.feng.spring.di.beans;

public class Order {

    private String item;

    private String price;

    public String getItem() {
        return item;
    }
    public void setItem(String item) {
        this.item = item;
    }
    public String getPrice() {
        return price;
    }
    public void setPrice(String price) {
        this.price = price;
    }
}

PaymentGateway.java

package com.feng.spring.di.beans;

public class PaymentGateway {

    private Order order;

    public void setOrder(Order ord){
        this.order = ord;
    }

    public Order getOrder() {
        return order;
    }

    @Override
    public String toString(){
        return "ordering "+this.order.getItem()+" | price: "+this.order.getPrice();
    }
}

基于xml的配置文件，注入依赖项的常规方法：
spring-autowriting-conventional.xml

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

    <bean id="paymentGateway" class="com.feng.spring.di.beans.PaymentGateway" >
        <property name="order" ref="orderBean" />
    </bean>

    <bean id="orderBean" class="com.feng.spring.di.beans.Order" >
        <property name="item" value="Java Book" />
        <property name="price" value="RS 225" />
    </bean>
</beans>

基于 byType 模式的自动注入：
spring-autowriting-by-type.xml

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

    <bean id="paymentGateway" class="com.feng.spring.di.beans.PaymentGateway"
          autowire="byType"/>

    <bean id="orderBean" class="com.feng.spring.di.beans.Order" >
        <property name="item" value="Java Book" />
        <property name="price" value="RS 225" />
    </bean>
</beans>

基于 byName 模式的自动注入：
spring-autowriting-by-name.xml

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

    <bean id="paymentGateway" class="com.feng.spring.di.beans.PaymentGateway"
          autowire="byName"/>

    <bean id="order" class="com.feng.spring.di.beans.Order" >
        <property name="item" value="Java Book" />
        <property name="price" value="RS 225" />
    </bean>
</beans>

测试类
AutoWiringDependencyInjectDemo.java

package com.feng.spring.di;

import com.feng.spring.di.beans.PaymentGateway;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AutoWiringDependencyInjectDemo {

    public static void main(String a[]){
        String confFile = "spring-autowriting-by-name.xml";
        ConfigurableApplicationContext context
                = new ClassPathXmlApplicationContext(confFile);
        PaymentGateway paymentGateway = (PaymentGateway) context.getBean("paymentGateway");
        System.out.println(paymentGateway.toString());
    }
}

自动注入通过 byType和byName ，一般在 XML 配置文件中用的较多。

总结

在本文中，举例说明了如何使用 Spring Framework 使用基于 XML 的配置注入依赖项的示例，通过上面的5个案例，分别通过手动模式和自动模式介绍了 Setter 依赖注入的方式，通过对手动模式的 API 配置元信息，能够更多的理解它底层的一个设计初衷，比如通过 BeanDefinitionBuilder#addPropertyReference 来达到引入相关依赖的目的。

参考资料

Spring Setter-based Dependency Injection(基于Spring Setter的依赖注入)

XML-Based Injection in Spring(Spring中基于XML的注入)

Spring Dependency Injection(Spring 依赖注入)

Spring - Dependency Injection example with annotation（Spring-带有注释的依赖注入示例）

feng_xiaoshi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 依赖注入
Ctrl_kun的博客
12-27 1522
Spring依赖注入笔记
Spring依赖注入原理解析.doc
06-14
设值注入是通过setter方法来传递被调用者实例。例如，在上述示例中，`Chinese`类实现了`Person`接口，它依赖于`Axe`接口的实现。`Chinese`有一个`setAxe`方法，Spring容器可以调用这个方法将`Axe`的一个实例注入到`...
Spring 学习笔记
weixin_48494706的博客
08-23 142
1.最初在UserServiceImpl中调用dao层 需要用接口去接收实现类，如下： Userdao userdao=new UserdaoImpl(); 而在springmvc中则变成如下方式,通过set注入的方式，要配置bean private Userdao userdao; public void setUserdao(Userdao userdao){ this.userdao=userdao; } ...
高薪必备的一些Spring Boot高级面试题
程序猿DD
10-14 4643
点击蓝色“程序猿DD”关注我回复“资源”获取独家整理的学习资料！作者 | 码农小胖哥来源 |公众号「码农小胖哥」自Spring Boot诞生以来，就引起了业界轰动，目前...
【Spring 使用】依赖注入 -- 基于 setter 方法的注入
瞎叨叨的一天的博客
09-14 462
依赖注入的使用
通过set方式注入的bean为null_Spring 注入集合
weixin_39648539的博客
12-05 402
注入集合你已经看到了如何使用 value 属性来配置基本数据类型和在你的 bean 配置文件中使用标签的 ref属性来配置对象引用。这两种情况下处理奇异值传递给一个 bean。现在如果你想传递多个值，如 Java Collection 类型 List、Set、Map 和 Properties，应该怎么做呢。为了处理这种情况，Spring 提供了四种类型的集合的配置元素，如下所示：你可以使用或来连接...
Spring工作原理1
08-03
Spring支持多种注入方式，包括setter注入、接口注入和构造器注入。setter注入是最常见的，通过setter方法来设置对象的属性；接口注入是基于接口的依赖注入，通过实现特定接口来注入依赖；构造器注入则是在创建对象时...
spring原理2
08-08
2. **Setter 注入**：通过调用对象的 Setter 方法注入依赖，这是最常见的方式。 3. **接口注入**：通过实现特定接口并调用接口方法来注入依赖，这种方式较少使用。 **Spring 核心接口与配置** - **FactoryBean**：...
通过实例了解java spring使用构造器注入的原因
08-25
Setter 注入是 Spring 3.x 版本推荐的注入方式，通过 setter 方法注入依赖。这种方式可以让类在之后重新配置或者重新注入，但是在大型项目中可能会出现问题。 三、构造器注入的好处 构造器注入的方式有三个主要...
Spring工作原理简单探索
08-28
Spring 框架提供了三种注入方式：setter、interface 和 constructor。这些注入方式使得对象之间的关系没有通过代码来关联，而是通过配置类说明管理的。 五、Spring 框架的核心接口及核类配置文件 Spring 框架的...
Spring - -setter方式 向bean中注入各种类型的值
08-07
NULL 博文链接：https://lixiongqing.iteye.com/blog/2124696
spring注解注入为什么还要setter方法
阳光宅男
04-17 6032
本人以为spring提供的注解注入方式有别于setter方法就是可以免去shuxie
Spring注入方式一：setter 方法注入
zoulukantian2008的专栏
03-22 991
我们在spring中对于DAO层也就是数据层一般都是面向借口编程，我们create一个bean 他有一个业务方法add public interface personDAO{ void add(); } public class PersonDAOImpl implements personDAO{ publich void add () { System.
依赖注入_配置构造注入
天蓬元帅的博客
08-09 200
第一步:实体 public class Car { private String name; private Double price; ... } 第二步:配置 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema...
Spring学习之set注入详解
最新发布
weixin_51465537的博客
06-07 1307
这段代码是一个静态方法的实现，用于判断一个类型是否为简单类型。： 排除Void类型和void类型。： 使用ClassUtils工具类的方法判断类型是否为原始类型或其包装类。： 判断类型是否为枚举类型。： 判断类型是否为的子类，即字符串类型。： 判断类型是否为Number的子类，即数值类型。： 判断类型是否为Date类型。： 判断类型是否为Temporal的子类，用于表示时间。： 判断类型是否为URI类型。： 判断类型是否为URL类型。： 判断类型是否为Locale类型。： 判断类型是否为Class类型。
Spring实例参考06-setter注入的10种方式
qq_34378496的博客
12-07 369
本文供以下文章参考使用：Spring笔记__evenif的博客-CSDN博客java类： 配置文件： 主测试类：
Spring的构造注入、setter注入以及自动装配
lu677521的博客
01-09 7163
1、小案例 这里我们定义两个类方法，分别是MathDemo和EnglishDemo，分别执行学习数学和学习英语的方法；、 package com.test2; public class MathDemo { public void StudyMath(){ System.out.println("学习数学。。。。"); } } package com.test
Spring——setter方式注入和构造函数方式注入
weixin_33752045的博客
12-31 348
先写一个比较常见的结构： 其中UserDao跟UserManagerImpl是层与层之间的接口。 下面用这些类来演示setter方式注入跟构造函数注入来解决Manager层注入Dao问题。 一，setter方式注入 首先要在Manager实现类中定义Dao的私有成员变量，并为此变...
spring 自动注入原理
05-30
Spring自动注入的原理是基于依赖注入（DI）的概念，也就是将对象的创建和对象所需要的属性的赋值分开处理。Spring容器在启动时，会读取配置文件或注解，然后根据配置信息创建相应的Bean对象，并将其放入Bean池中。当需要使用该对象时，容器会从Bean池中取出该对象并注入其所需的属性，完成对象的创建和属性的赋值。 Spring 自动注入的方式有以下三种： 1. 构造函数注入：使用构造函数进行注入，通过在Bean的构造函数上添加@Autowired注解，Spring容器会自动寻找匹配的Bean对象并将其注入到构造函数中。 2. Setter方法注入：通过Setter方法进行注入，使用@Autowired注解在Setter方法上，Spring容器会自动寻找匹配的Bean对象并调用相应的Setter方法将其注入。 3. 字段注入：使用@Autowired注解在Bean的字段上，Spring容器会自动寻找匹配的Bean对象并将其注入到字段中。 无论采用哪种方式实现自动注入，Spring容器都会根据Bean的作用域（Scope）来判断是否需要创建新的对象。如果是单例（Singleton）作用域，则只会创建一个对象并将其放入Bean池中，每次获取时都会返回同一个对象；如果是原型（Prototype）作用域，则每次获取时都会创建一个新的对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值