Spring依赖关系的配置

最新推荐文章于 2024-03-19 16:25:38 发布
最新推荐文章于 2024-03-19 16:25:38 发布
阅读量699 收藏
点赞数
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kiikgu/article/details/77950516
版权

一. Spring依赖关系的配置

UML类图中类之间的关系

     UML类图中的关系包含：依赖关系、泛化关系、关联关系、聚合关系、组合关系、实现关系

1. 依赖关系

    一种使用的关系，A类的变化引起了B类的变化，就说明B依赖于A。依赖关系有如下3种情况：
     1. A类是B类（方法中）的局部变量
     2. A类是B类方法中的参数
     3. A类向B类传递消息

2. 泛化关系

    类与类、接口和接口之间的继承关系。A类是B类和C类的父类，则A类具有B类和C类的共同特征，是B类和C类的泛化。

3. 关联关系

     类之间的联系，如：客户和订单。

  • 双向关联
  • 单项关联
  • 自关联
  • 重数性关联

4. 聚合关系

     整体与部分的关系，整体和部分可以分开。如：Car、Engine的关系，Computor、keyboard、mouse的关系

5. 组合关系

     整体与部分的关系，整体和部分不能分开，如：head、mouth的关系

6. 实现关系

     接口和类之间存在实现关系。

IoC的依赖关系

  1. Bean对Ioc容器的依赖
  2. Ioc容器注入Bean的依赖资源，如: 类、文件、常量数据等

依赖注入带来的好处？

  • 可以动态替换Bean，使程序更加灵活
  • 更好实践面向接口编程
  • 更好实践优先使用对象组合，而不是继承

面向接口编程、和优先使用对象组合可以降低耦合，增加代码复用。

Ioc容器依赖注入方式

     Ioc有2种依赖注入方式：构造器注入、setter注入

构造器注入

构造器：

public HelloServiceImpl3(String message, HelloService subService) {
    this.message = message;
    this.subService = subService;
  }

1. 通过参数索引注入

  <bean id = "helloService1" class="com.kiikgu.HelloServiceImpl">
    <constructor-arg index="0" value="Hello World 1" />
  </bean>

  <bean id="helloSerivceByIndex" class="com.kiikgu.HelloServiceImpl3">
    <constructor-arg index="0" value="Hello World 3" />
    <constructor-arg index="1" ref="helloService1" />
  </bean>
  • index参数在构造器中的位置

2. 通过参数类型注入

  <bean id="helloServiceByType" class="com.kiikgu.HelloServiceImpl3">
    <constructor-arg type="java.lang.String" value="hello world 4" />
    <constructor-arg type="com.kiikgu.HelloService" ref="helloService1" />
  </bean>

3. 通过参数名称注入

  <bean id="helloServiceByName" class="com.kiikgu.HelloServiceImpl3">
    <constructor-arg name="message" value="hello world" />
    <constructor-arg name="subService" value="helloService1" />
  </bean>

4. 通过静态工厂和实例工厂注入

以静态工厂举例：

  <bean id="helloServiceByFactoryIndex" class="com.kiikgu.HelloServiceFactory" factory-method="getHelloService">
    <constructor-arg index="0" value="Hello World 3" />
    <constructor-arg index="1" ref="helloService1" />
  </bean>

  <bean id="helloServiceByFactoryType" class="com.kiikgu.HelloServiceFactory" factory-method="getHelloService">
    <constructor-arg type="java.lang.String" value="hello world 4" />
    <constructor-arg type="com.kiikgu.HelloService" ref="helloService1" />
  </bean>

  <bean id="helloServiceByFactoryName" class="com.kiikgu.HelloServiceFactory" factory-method="getHelloService">
    <constructor-arg name="message" value="hello world 5" />
    <constructor-arg name="subService" ref="helloService1" />
  </bean>

setter注入

  <bean id="helloService2"  class="com.kiikgu.HelloServiceImpl">
    <property name="message" value="hello world" />
    <property name="innerService" ref="helloService1" />
  </bean>

注入常量

  <bean id="helloService2"  class="com.kiikgu.HelloServiceImpl">
    <property name="flag" value="on" />
    <property name="message" value="hello world" />
    <property name="innerService" ref="helloService1" />
  </bean>

在注入boolean类型的域时，Spring做了适配，值可以填：”true/false“、”yes/no“、”on/off“、”1/0“

注入集合、数组和词典

Bean定义

public class CollectionDIBean {
  private List<String> list;
  private Set<String> set;
  private Collection<String> collection;
  private String[] array;
  private String[][] array1;
  private Map<String, Integer> map;

  public List<String> getList() {
    return list;
  }

  public void setList(List<String> list) {
    this.list = list;
  }

  public Set<String> getSet() {
    return set;
  }

  public void setSet(Set<String> set) {
    this.set = set;
  }

  public Collection<String> getCollection() {
    return collection;
  }

  public void setCollection(Collection<String> collection) {
    this.collection = collection;
  }

  public String[] getArray() {
    return array;
  }

  public void setArray(String[] array) {
    this.array = array;
  }

  public String[][] getArray1() {
    return array1;
  }

  public void setArray1(String[][] array1) {
    this.array1 = array1;
  }

  public Map<String, Integer> getMap() {
    return map;
  }

  public void setMap(Map<String, Integer> map) {
    this.map = map;
  }

  public void printList() {
    System.out.println(Arrays.toString(list.toArray()));
  }

  public void printSet() {
    System.out.println(Arrays.toString(set.toArray()));
  }

  public void printCollection() {
    System.out.println(Arrays.toString(collection.toArray()));
  }

  public void printArray() {
    System.out.println(Arrays.toString(array));
  }

  public void printArray1() {
    System.out.println(Arrays.deepToString(array1));
  }

  public void printMap() {
    for (String key : map.keySet()) {
      System.out.println(String.format("%s:%s", key, map.get(key)));
    }
  }
}

配置文件

  <bean id="collectionDIBean" class="com.kiikgu.CollectionDIBean">
    <!--list -->
    <property name="list">
      <list value-type="java.lang.String">
        <value>cat</value>
        <value>dog</value>
        <value>fox</value>
        <value>panda</value>
      </list>
    </property>

    <!--set-->
    <property name="set">
      <set value-type="java.lang.String">
        <value>123</value>
        <value>123</value>
        <value>345</value>
      </set>
    </property>

    <!--collection-->
    <property name="collection">
      <list>
        <value>1</value>
        <value>2</value>
        <value>3</value>
      </list>
    </property>

    <!--array-->
    <property name="array">
      <array>
        <value>a1</value>
        <value>a2</value>
        <value>a3</value>
      </array>
    </property>

    <!--array-->
    <property name="array1">
      <array>
        <array>
          <value>a11</value>
          <value>a12</value>
        </array>
        <array>
          <value>a21</value>
          <value>a22</value>
        </array>
      </array>
    </property>

    <!--map-->
    <property name="map">
      <map>
        <entry key="k1" value="1" />
        <entry key="k2" value="2" />
        <entry key="k3" value="3" />
      </map>
    </property>
  </bean>

测试一下：

CollectionDIBean collectionDIBean = context.getBean("collectionDIBean", CollectionDIBean.class);
collectionDIBean.printList();
collectionDIBean.printSet();
collectionDIBean.printCollection();
collectionDIBean.printArray();
collectionDIBean.printArray1();
collectionDIBean.printMap();

[cat, dog, fox, panda]
[123, 345]
[1, 2, 3]
[a1, a2, a3]
[[a11, a12], [a21, a22]]
k1:1
k2:2
k3:3

注入Properites

bean定义

public class PropertiesDIBean {
  private Properties values;

  public Properties getValues() {
    return values;
  }

  public void setValues(Properties values) {
    this.values = values;
  }

  public void printValues() {
    for (Object key : values.keySet()) {
      System.out.println(String.format("%s : %s", key, values.get(key)));
    }
  }
}

配置

  <bean id="propertiesDIBean" class="com.kiikgu.PropertiesDIBean">
    <property name="values">
      <props>
        <prop key="p1">v1</prop>
        <prop key="p2">v2</prop>
        <prop key="p3">v3</prop>
      </props>
    </property>
  </bean>

测试一下吧：

PropertiesDIBean propertiesDIBean = context.getBean("propertiesDIBean", PropertiesDIBean.class);
propertiesDIBean.printValues();

p3 : v3
p2 : v2
p1 : v1

引用其它Bean

基本配置：使用ref标签

<bean id="helloService3" class="com.kiikgu.HelloServiceImpl3">
    <constructor-arg type="java.lang.String" value="hello ref" />
    <constructor-arg type="com.kiikgu.HelloService">
      <ref bean="helloService1" />
    </constructor-arg>
  </bean>
<bean id="helloService3" class="com.kiikgu.HelloServiceImpl3">
    <constructor-arg type="java.lang.String" value="hello ref" />
    <constructor-arg type="com.kiikgu.HelloService" ref="helloService1"/>
  </bean>

高级配置：\

引用父容器中的bean

<!--spring-learn-parent.xml-->
<bean id = "helloService1" name="helloService1Name" class="com.kiikgu.HelloServiceImpl">
    <constructor-arg index="0" value="Hello parent" />
    <property name="flag" value="true" />
  </bean>
<!--spring-learn.xml -->
<bean id = "helloService1" name="helloService1Name" class="com.kiikgu.HelloServiceImpl">
    <constructor-arg index="0" value="hello son" />
    <property name="flag" value="yes" />
  </bean>

   <bean id="helloService3" class="com.kiikgu.HelloServiceImpl3">
    <property name="message" value="123" />
    <property name="subService">
      <ref parent="helloService1" />
    </property>
  </bean>

测试一下：

ApplicationContext parentContext = new ClassPathXmlApplicationContext("spring-learn-parent.xml");
ApplicationContext childContext = new ClassPathXmlApplicationContext(new String[]{"spring-learn.xml"}, parentContext);
HelloService helloService = childContext.getBean("helloService3", HelloService.class);
helloService.sayHello();

Hello parent
123

注入内部Bean

内部bean是在\或\内部用\标签定义的Bean，该内部bean对其它外部bean不可见

 <bean id="helloService4" class="com.kiikgu.HelloServiceImpl3">
    <property name="message" value="outer bean" />
    <property name="subService">
      <bean id="innerBean" class="com.kiikgu.HelloServiceImpl">
        <constructor-arg name="message" value="inner bean" />
        <property name="flag" value="1"/>
      </bean>
    </property>
  </bean>

注入null

使用标签 \

 <bean id="helloService4" class="com.kiikgu.HelloServiceImpl3">
    <property name="message"><null /></property>

对象图导航注入

Bean定义

public class NavigationDIBeanC {
  private String name;

}

public class NavigationDIBeanB {

  private NavigationDIBeanC c;

  private Map<String, String> values;

}

public class NavigationDIBeanA {

  private NavigationDIBeanB b;

}

省略了get、set方法

配置

  <bean id="nc" class="com.kiikgu.NavigationDIBeanC" />
  <bean id="nb" class="com.kiikgu.NavigationDIBeanB" />
  <bean id="na" class="com.kiikgu.NavigationDIBeanA">
    <property name="b" ref="nb" />
    <property name="b.c" ref="nc" />
    <property name="b.values">
      <map>
        <entry key="123" value="123" />
      </map>
    </property>
    <property name="b.c.name" value="test" />
  </bean>
  • 这种方法不推荐使用

使用p命名空间简化setter注入

<?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:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 <bean id="nc" class="com.kiikgu.NavigationDIBeanC" p:name="test1" />

指定命名空间：xmlns:p=”http://www.springframework.org/schema/p”

<bean id=”nc” class=”com.kiikgu.NavigationDIBeanC” p:name=”test1” />
相当于：
<property name=”name” value=”test1” />

总结

本节介绍了Spring DI的配置，包括：类之间的关系、Spring Ioc容器对Bean依赖关系的各种注入方式。

参考

http://blog.csdn.net/hguisu/article/details/7609483
http://jinnianshilongnian.iteye.com/blog/1415277

王小坤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring XML 配置扩展机制
06-27
... xsi:schemaLocation=...-- 提供方应用信息，用于计算依赖关系 --> <!-- 使用zk为注册中心暴露服务地址 --> <!-- 用dubbo协议在20880端口暴露服务 --> </beans>
Spring5的核心容器
Leon_Jinhai_Sun的博客
11-11 256
由spring-beans、spring-core、spring-context 和spring-expression（Spring Expression Language,SpEL） 4 个模块组成。 spring-core 和spring-beans 模块是Spring 框架的核心模块，包含了控制反转（Inversion of Control, IOC）和依赖注入（Dependency Injection, DI）。BeanFactory 接口是Spring 框架中的核心接口，它是工厂模式的具体实现。
Spring中的依赖关系(DI)
Keep learing, and stay fast
10-11 816
Spring 以“依赖注入”的方式实现了“控制反转"的效果，以便符合软件工程中“依赖倒置”原则。
第二节_了解spring的配置文件与依赖注入
最新发布
LANCAN_KUANGLAN的博客
03-19 834
第二节
【Spring】基础依赖
daohangtaiqian的博客
11-05 9786
1）spring核心依赖 spring-core、spring-beans、spring-context 2）spring dao依赖（提供JDBCTemplate） spring-jdbc、spring-tx 3）spring web依赖 spring-web、spring-webmvc 4）spring test依赖 spring-test &amp;amp;amp;lt;!-- 1.Spring核心依赖 --&amp;amp;amp;g......
Spring：Spring依赖管理
weixin_44843569的博客
12-12 1800
Spring依赖管理
Spring基础篇：依赖注入
七叔的博客
12-01 2万+
Spring基础篇：注入
Spring Boot中slf4j日志依赖关系示例详解
08-26
在项目开发中，记录日志是必做的一件事情。而当我们使用Springboot框架时，记录日志就变得极其简单了。下面这篇文章主要给大家介绍了关于Spring Boot中slf4j日志依赖关系的相关资料，需要的朋友可以参考下
springframework体系结构及内部各模块jar之间的maven依赖关系
01-27
很多人都在用spring开发java项目，但是配置maven依赖的时候并不能明确要配置哪些spring的jar，经常是胡乱添加一堆，编译或运行报错就继续配置jar依赖，导致spring依赖混乱，甚至下一次创建相同类型的工程时也不知道...
详解Spring的核心机制依赖注入
01-08
Spring把这种互相协作的关系称为依赖关系。如A组件调用B组件的方法，可称A组件依赖于B组件，依赖注入让Spring的Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起 一、理解依赖注入 依赖注入(Dependency ...
在pom.xml中添加Spring依赖
陈铁锋的博客
06-26 1万+
4.12 4.3.9.RELEASE 1.2 junit junit ${junit.version} test org.springframework spring-aop ${spri
Spring框架jar包之间的依赖关系(详细图解)
06-27
Spring框架jar包依赖关系图解, PowerDesigner源文件, 图片 以及 对应的各个模块关系
Spring 依赖注入详解
swadian2008的博客
10-25 4577
/ 依赖关系，指的就是对象之间的相互协作关系依赖注入（DI）是一个过程，在这个过程中，对象仅通过构造函数参数、工厂方法的参数或在对象被实例化后通过属性设置来定义它们的依赖项（即与该对象一起工作的其他对象）。然后，容器在创建 bean 时注入这些依赖项。这个过程基本上是与对象直接通过构造类或等机制来控制其依赖项的实例化或位置是相反的，因此得名控制反转。// 对象不直接创建自己，而是通过 Spring 容器创建，那么 Spring 容器是如何创建对象的？
一.spring中的各个依赖,及分类
大屎片的博客
11-02 1373
一.spring中的各个依赖,及分类(1)spring基础包 (1)spring基础包 spring
spring-jar包详解整理（大合集）
热门推荐
每天进步一点点
03-14 3万+
Spring各jar包详解
Spring基础——XML配置Bean的依赖注入
NoBugNoLife的博客
03-05 775
Spring基于XML的依赖注入详解。
Spring学习第4篇：Spring 的依赖注入
怪咖@的博客
11-12 3461
依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。我们的程序在编写时，通过控制反转，把`对象的创建`交给了 `spring`，但是代码中不可能出现没有依赖的情况。例如：我们的`controller`层仍会调用`service`层的方法。那这种`controller`和`service`层的依赖关系，在使用 `spring` 之后，就让 `spring` 来维护了。简单的说，就是坐等框架把`service`层对象传入`controller`层。
spring framework体系结构及内部各模块jar之间的maven依赖关系
weixin_30701575的博客
12-06 681
　　很多人都在用spring开发java项目，但是配置maven依赖的时候并不能明确要配置哪些spring的jar，经常是胡乱添加一堆，编译或运行报错就继续配置jar依赖，导致spring依赖混乱，甚至下一次创建相同类型的工程时也不知道要配置哪些spring的依赖，只有拷贝，其实，当初我就是这么干的！ 　　spring的jar包只有20个左右，每个都有相应的功能，一个jar还可能依赖了若干其他j...
springcloud依赖文件对应关系
03-06
Spring Cloud 的依赖文件对应关系如下： - spring-cloud-starter-netflix-eureka-server 对应 Eureka 服务端 - spring-cloud-starter-netflix-eureka-client 对应 Eureka 客户端 - spring-cloud-starter-netflix-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值