关闭

Spring 依赖注入(DI)

标签: Spring依赖注入DISpringDI
435人阅读 评论(0) 收藏 举报
分类:
依赖注入,可注入的类型有:
字符串/整数/小树/布尔值
数组
List集合
Map集合
Propert对象
JvaBean
List+JavaBean

首先创建实体类
package star.july.c_di;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class Student {
          private String name;
          private int age;
          public Student() {
                   System.out.println("执行了Student构造方法");
          }
          public Student(String name, int age) {
                   System.out.println("调用有参构造方法");
                   this.name = name;
                   this.age = age;
          }
          // 注入字符串类型
          private String stuname;
          public void setStuname(String stuname) {
                   this.stuname = stuname;
          }
          // 整型类型
          private int length;
          public void setLength(int length) {
                   this.length = length;
          }
          // 数组
          private String[] array;
          public void setArray(String[] array) {
                   System.out.println("数组注入");
                   this.array = array;
          }
          // 集合
          private List list;
          public void setList(List list) {
                   this.list = list;
          }
          // Map集合
          private Map<String, String> map;
          public void setMap(Map<String, String> map) {
                   System.out.println("Map注入");
                   this.map = map;
          }
          // Properties注入
          private Properties prop;
          public void setProp(Properties prop) {
                   this.prop = prop;
          }
          //List+JavaBean
          private List<Course> ljb;
          
          public void setLjb(List<Course> ljb) {
                   this.ljb = ljb;
          }
          @Override
          public String toString() {
                   return "Student [name=" + name + ", age=" + age + ", stuname="
                                      + stuname + ", length=" + length + ", array="
                                      + Arrays.toString(array) + ", list=" + list + ", map=" + map
                                      + ", prop=" + prop + ", ljb=" + ljb + "]";
          }
}




JavaBean:

package star.july.c_di;
public class Course {
          private String name;
          public String getName() {
                   return name;
          }
          public void setName(String name) {
                   this.name = name;
          }
          @Override
          public String toString() {
                   return "Course [name=" + name + "]";
          }
          
          
}


然后配置xml

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">
          <!-- 依赖注入 使用构造方法注入(不推荐) -->
          <bean id="student" class="star.july.c_di.Student">
                   <constructor-arg index="0" value="狗娃" type="String"></constructor-arg>
                   <constructor-arg index="1" value="22" type="int"></constructor-arg>
          </bean>
          <!-- 使用setter方法注入(推荐) -->
          <!-- 字符串类型注入 -->
          <bean id="s1" class="star.july.c_di.Student">
                   <property name="stuname" value="徐凤年"></property>
          </bean>
          <!-- 整型注入 -->
          <bean id="s2" class="star.july.c_di.Student">
                   <property name="length">
                             <value>22</value>
                   </property>
          </bean>
          <!-- 数组 -->
          <bean id="s3" class="star.july.c_di.Student">
                   <property name="array">
                             <array>
                                      <value>19</value>
                                      <value>20</value>
                             </array>
                   </property>
          </bean>
          <!-- 集合:List -->
          <bean id="s4" class="star.july.c_di.Student">
                   <property name="list">
                             <list>
                                      <value>小一</value>
                                      <value>小二</value>
                                      <value>小三</value>
                             </list>
                   </property>
          </bean>
          <!-- Map集合 -->
          <bean id="s5" class="star.july.c_di.Student">
                   <property name="map">
                             <map>
                                      <entry key="gd">
                                                <value>广东</value>
                                      </entry>
                                      <entry key="gx">
                                                <value>广西</value>
                                      </entry>
                             </map>
                   </property>
          </bean>
          <!-- Properties注入 -->
          <bean id="s6" class="star.july.c_di.Student">
                   <property name="prop">
                             <props>
                                      <prop key="hn">湖南</prop>
                                      <prop key="fh">凤凰</prop>
                             </props>
                   </property>
          </bean>
          
          <!-- List+JavaBean -->
          <bean id="s7" class="star.july.c_di.Student">
                   <property name="ljb">
                             <list>
                                      <ref bean="ljb1"></ref>
                                      <ref bean="ljb2"></ref>
                             </list>
                   </property>
          </bean>
          
          <bean id="ljb1" class="star.july.c_di.Course">
                   <property name="name"><value>Java开发</value></property>
          </bean>
          
          <bean id="ljb2" class="star.july.c_di.Course">
                   <property name="name"><value>UI设计</value></property>
          </bean>
</beans>

最后测试:
package star.july.c_di;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo {
          public static void main(String[] args) {
                   ApplicationContext ac = new ClassPathXmlApplicationContext("/star/july/c_di/applicationContext.xml");
//                Object s1 = ac.getBean("s1");
//                Object s2 = ac.getBean("s2");
//                Object s3 = ac.getBean("s3");
//                Object s4 = ac.getBean("s4");
//                Object s5 = ac.getBean("s5");
//                Object s6 = ac.getBean("s6");
                   Object s7 = ac.getBean("s7");
                   System.out.println(s7);
                   
          }
}



0
0
查看评论

关于Spring IOC (DI-依赖注入)你需要知道的一切

【版权申明】未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/54561302 出自【zejian的博客】 《Spring入门经典》这本无论对于初学者或者有经验的工程师还是很值一看的...
  • javazejian
  • javazejian
  • 2017-01-19 16:46
  • 22342

Spring讲解----------依赖注入(DI)

3.1.1  依赖和依赖注入        传统应用程序设计中所说的依赖一般指“类之间的关系”,那先让我们复习一下类之间的关系:      泛化:表示类与类之间的继承关系、接口与接口之间的继承关系...
  • u011225629
  • u011225629
  • 2015-07-30 07:38
  • 2380

Spring -Spring的 DI - 依赖注入的 使用学习

一 . spring的DI   依赖注入,一句话总结 :给属性赋值 ;           一个类中的属性都可以采用springDI的方式进行赋值,但是并不是所有的属性都适合赋值;   1. 利用se...
  • LABLENET
  • LABLENET
  • 2015-12-25 17:32
  • 708

spring四种依赖注入方式 ( 依赖注入DI+ 控制反转IOC的原理)

平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的...
  • baoendemao
  • baoendemao
  • 2014-04-28 13:06
  • 1738

【Spring】Spring的IOC(控制反转)/DI(依赖注入)原理(一):用到“反射”编程

1. IoC理论的背景 我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑。 图1:软件系统中耦合的对象 如果我们打开机械式手表的后盖,就会看到与上面类似的情形,各个齿轮分别带动时针、分针和秒针顺时针旋转,...
  • cangchen
  • cangchen
  • 2015-04-08 22:25
  • 1871

spring容器DI依赖注入对象<三>

问题?Spring的DI讲解、DI有几种注入方式、 一、spring的DI:依赖注入给属性赋值 DI定义:一个对象类的属性可以使用springDI(依赖注入)来进行赋值,但是并不是所有的类属性都适合springDI来赋值., 一共有两种方式进行属性赋值:set方法和带参构造方法 案例...
  • Mr_li13
  • Mr_li13
  • 2015-12-02 20:32
  • 754

Java面试-Spring IOC(控制反转)和DI(依赖注入)

IOCIoc(Inversion of Control)翻译成中文就是“控制反转”,一个比较晦涩的词语。如果要真正理解这个词语,必须要用过Spring框架才行,因为Spring开启了一种新的编程方式。传统的编程方式: 所有的对象和资源都是由开发人员来控制,由你来决定什么时候new一个对象,什么时候申...
  • u010902721
  • u010902721
  • 2016-10-04 23:18
  • 1424

Spring_mvc ioc/DI 控制反转与依赖注入

主要步骤: 1.   提交页面:一个查看商品的链接      结果页面:商品列表,显示三件商品的具体信息 2.   实体类:商品名称,价格 3.   后台控制类Servlet和配置 4.   添加spring开发包 5...
  • chou_out_man
  • chou_out_man
  • 2017-03-10 09:05
  • 155

Spring依赖注入(DI)的三种实现方式

Spring依赖注入(DI)的三种方式,分别为:1.  接口注入2.  Setter方法注入3.  构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的。 首先我们需要以下几个类:接口 Logic.java接口实现类 LogicIm...
  • chensugang
  • chensugang
  • 2008-11-09 11:02
  • 8970

利用反射简单模拟Spring的控制反转(Ioc)和依赖注入(DI)

利用反射简单模拟Spring的控制反转(Ioc)和依赖注入(DI) 1.配置文件(.properties)中配置要扫描的包: #扫描page对象的包 init.pageobj.Package = ec.qa.autotest.ui.admin.portal.pageobject,ec.qa.aut...
  • wangxin1982314
  • wangxin1982314
  • 2015-12-08 17:23
  • 1616
    个人资料
    • 访问:136352次
    • 积分:2630
    • 等级:
    • 排名:第16390名
    • 原创:123篇
    • 转载:0篇
    • 译文:0篇
    • 评论:45条
    文章分类
    最新评论