2.Spring依赖注入(Dependency Injection)

依赖:

  在A类中引用了B类,说明A依赖于B。

注入:

  使用Spring框架给A类中的B对象的属性赋值。

直接上代码:

1.只使用IOC

public class Person {

    private String name;
    private int age;
    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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}
<bean id="person" class="com.spring.demo1.Person"/>
    /**
     * 只使用IOC
     */
    @Test
    public void m01(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = (Person) ac.getBean("person");
        p.setAge(10);
        p.setName("10岁的boy");
        System.out.println(p);
    }

2.使用IOC+DI

    <bean id="person" class="com.spring.demo1.Person">
        <property name="name" value="30岁的man"/>
        <property name="age" value="30"/>
    </bean>
    /**
     * 使用IOC+DI
     */
    @Test
    public void m02(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = (Person) ac.getBean("person");
        System.out.println(p);
    }

两种注入方式

1.通过setter方法注入------开发常用

  上述的依赖注入方法↑↑↑↑↑↑↑↑↑

  在编写的JAVA类中加入属性的set方法

  配置文件:(property)

    <bean id="person" class="com.spring.demo1.Person">
        <property name="name" value="30岁的man"/>
        <property name="age" value="30"/>
    </bean>

2.通过构造方法注入

  在编写的JAVA类中加入有参构造方法

  配置文件:(constructor-arg)

    <bean id="person" class="com.spring.demo1.Person">
        <constructor-arg name="name" value="40岁的person"/>
        <constructor-arg name="age" value="40"/>
    </bean>

注意:

  如果属性是另一个JAVA类,应该将 value属性 改为 ref

<bean id="car" class="com.spring.Car"/>
<bean id="person" class="com.spring.Person">
    <property name="name" value="man"/>
    <property name="car" ref="car"/>
</bean>

数组,集合(List,Set,Map),Properties等的注入

1. 如果是数组或者List集合,注入配置文件的方式是一样的
    <bean id="collectionBean" class="com.spring.CollectionBean">
        <property name="arrs">
            <list>
                <value>呵呵</value>
                <value>哈哈</value>
            </list>
        </property>
    </bean>

2. 如果是Set集合,注入的配置文件方式如下:
    <property name="sets">
        <set>
            <value>哈哈</value>
            <value>呵呵</value>
        </set>
    </property>

3. 如果是Map集合,注入的配置方式如下:
    <property name="map">
        <map>
            <entry key="老王1" value="38"/>
            <entry key="老王2" value="38"/>
            <entry key="老王3" value="29"/>
        </map>
    </property>

4. 如果是properties属性文件的方式,注入的配置如下:
    <property name="pro">
        <props>
            <prop key="username">root</prop>
            <prop key="password">root</prop>
        </props>
    </property>
时间: 2024-10-24 00:02:44

2.Spring依赖注入(Dependency Injection)的相关文章

控制反转(Inversion of Control)与依赖注入(Dependency Injection)

——摘自Rocky Ren的笔记 1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理.所谓的“控制反转”概念就是对组件对象控制权的转移,从程序代码本身转移到了外部容器. IoC是一个很大的概念,可以用不同的方式来实现.其主要实现方式有两种:<1>依赖查找(Dependency Look

Spring点滴七:Spring中依赖注入(Dependency Injection:DI)

Spring机制中主要有两种依赖注入:Constructor-based Dependency Injection(基于构造方法依赖注入) 和 Setter-based Dependency Injection(基于Setter方法依赖注入) 一.Contructor-based Dependency Injection(基于构造方法注入) 在bean标签中通过使用<constructor-arg />标签来实现 spring.xml <?xml version="1.0&qu

Spring之对象依赖关系(依赖注入Dependency Injection)

承接上篇: Spring中,如何给对象的属性赋值: 1:通过构造函数,如下所示: <!-- 1:构造函数赋初始值 --><bean id="user1" class="com.bie.po.User"><constructor-arg value="10010" type="int"></constructor-arg>      <constructor-arg valu

理解依赖注入(Dependency Injection)

理解依赖注入 Yii2.0 使用了依赖注入的思想.正是使用这种模式,使得Yii2异常灵活和强大.千万不要以为这是很玄乎的东西,看完下面的两个例子就懂了. class SessionStorage { function __construct($cookieName = 'PHP_SESS_ID') { session_name($cookieName); session_start(); } function set($key, $value) { $_SESSION[$key] = $valu

Spring学习3—控制反转(IOC)Spring依赖注入(DI)和控制反转(IOC)

一.思想理解 Spring 能有效地组织J2EE应用各层的对象.不管是控制层的Action对象,还是业务层的Service对象,还是持久层的DAO对象,都可在Spring的 管理下有机地协调.运行.Spring将各层的对象以松耦合的方式组织在一起,Action对象无须关心Service对象的具体实现,Service对 象无须关心持久层对象的具体实现,各层对象的调用完全面向接口.当系统需要重构时,代码的改写量将大大减少. 上面所说的一切都得宜于Spring的核心机制,依赖注入.依赖注入让bean与

【SSH三大框架】Spring基础第二篇:Spring依赖注入的三种方式

控制反转(Inversion of Control)和依赖注入(Dependency Injection): 应用控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它.也可以说,依赖被注入到对象中.所以,控制反转是,关于一个对象如何获取他所依赖的对象的引用,这个责任的反转. 对于依赖注入,有三种方式: 1.使用属性的setter方法注入 2.使用构造器注入 3.使用注解注入 下面我们介绍下这三种方式: 一.使用属性的setter方法注入 首先,我们写一个

Spring依赖注入和NEW的差别

Sping为什么使用依赖注入而不使用实例化对象的方式? 首先说明一下概 依赖注入(Dependency of Injection)和控制反转(Inversion of Control 简称:ioc)是一个概念. 具体含义: ? ?当某个角色(Java实例class A,调用者)需要另一个角色(另一个Java实例class B,被调用者)的协助时,在传统的程序设计过程中通常由调用者来创建被调用者的实例(在class A里面 初始化class B). 但在Spring里,创建被调用者实例的工作不再由

Helloworld之Spring依赖注入/控制反转(DI/IoC)版

Helloworld之Spring依赖注入/控制反转(DI/IoC)版 作者:雨水, 日期:2014-10-29 摘要:本文主要用于培训初学者理解Spring中的依赖注入的基本概念. 先介绍依赖注入的基本概念,然后以构造器注入为例实现了Helloworld实例. Spring依赖注入/控制反转 在我们通常的编程中,如果类A要依赖类B,通常是由A来创建一个B的实例.而Spring将创建B的实例的工作交给Spring容器来完成,然后注入A,因此称为依赖注入(DI, Dependency Inject

项目构建之maven篇:4.坐标与依赖及spring依赖注入demo

源代码下载 坐标 <groupId>com.demo.animal</groupId> <artifactId>animal-core</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> groupId:定义当前maven项目隶属的实际项目 artifactId:定义实际项目中的一个maven项目(模块),推荐实际项

腾讯分分彩源码带龙虎和玩法自言自语Spring依赖注入(XML配置)

至于基于XML依赖注入的过程,首先要找一个比较合适的入口,那就是getBean.那么具体是怎么实现的呢?首先写个测试方法: ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("application-common.xml","application-beans.xml","application_jdbc.xml");Object obj = app.g