【Spring】DI 依赖注入传递参数的方式

DI依赖注入传入参数的方式，这里介绍了基本数据类型，集合，符合数据类型的传递（String类型比较特殊，其传递值和基本数据类型的方法一致）

注入基本数据类型和String类型

通过setter方法注入基本数据类型与String

案例：

<bean id="book" class="cn.xdl.bean.Book">
<!--
    对于基本数据类型 与 String的注入操作

    通过set方法 ,完成注入
    name: 属性的名称
    value: 属性要赋的值
    <null/>: 节点表示null。
 -->
    <property name="bookName" value="西游记"></property>
    <property name="bookId" value="10001"></property>
    <!-- null值 -->
    <property name="x">
        <null/>
    </property>

</bean>

通过构造方法 ,注入基本数据类型与String

方式1:

    <bean id="book" class="cn.xdl.bean.Book">
           <!-- 通过构造器 传入形参名称 与 value值, 进行参数的注入-->
        <constructor-arg name="bn" value="红楼梦"></constructor-arg>
        <constructor-arg name="bi" value="10002"></constructor-arg>
    </bean>
 方式2:
  <bean id="book" class="cn.xdl.bean.Book">
           <!-- 通过构造器 传入形参列表的索引 ,与value进行参数的注入-->
         <constructor-arg index="0">
            <null/>
         </constructor-arg>
         <constructor-arg index="1" value="10003"></constructor-arg>
    </bean>

注入集合类型的数据

注入List集合

            <property name="jiyoumen">
                <!--向List集合 注入值-->
                <list>
                     <!--每一个value节点, 表示集合中的一个元素-->
                    <value>帅帅</value>
                    <value>晋华</value>
                    <value>王鹏和杨海</value>
                    <value>昊天</value>
                    <value>超凡和超群</value>
                    <value>欢乐他自个儿</value>
                </list>
            </property>

注入Set集合

            <property name="jiyoumen">
               <!--向set集合 注入值-->
                <list>
                     <!--每一个value节点, 表示集合中的一个元素-->
                    <value>帅帅</value>
                    <value>晋华</value>
                    <value>王鹏和杨海</value>
                    <value>昊天</value>
                    <value>超凡和超群</value>
                    <value>欢乐他自个儿</value>
                </list>
            </property>

注入Map集合

            <property name="jiyoumen">
                <map>
                    <!--每一个enrty表示集合中的一个键值对-->
                    <entry key="jiyou1" value="欢乐他自个1"></entry>
                    <entry key="jiyou2" value="欢乐他自个2"></entry>
                </map>
            </property>

注入Properties集合

            <property name="jiyoumen">
                <!--对于properties的注入 ,value是编写在prop节点的文本内容区域的
                每一个prop都表示proerties存储的一个键值对的数据-->
                <props>
                    <prop key="1haojiyou">帅帅</prop>
                    <prop key="2haojiyou">昊天</prop>
                    <prop key="3haojiemei">杨海</prop>
                </props>
            </property>

通过引入的方式, 实现集合的重复利用

原理:

1.  配置一个集合对象到容器中, 并指定ID
    2.  在其他对象使用时, 直接通过对象注入的方式, 将其注入即可

案例:

向容器中添加集合对象:

        <util:set id="list">
            <value>张三</value>
            <value>李四</value>
            <value>王二</value>
            <value>麻子</value>
        </util:set>

将对象注入其他对象中:

        <bean id="person" class="cn.xdl.bean.Person">
            <property name="refriendship" ref="list"></property>
        </bean>

对象的注入

通过Setter方法设置属性

property节点:  通过set方法, 设置一个属性的值
    name属性: 表示的是 当前类中的属性的名称
    ref: 表示的是, 本次要注入的对象在当前容器中的id值

案例:

    <bean id="id" class="类">
    <property name="book" ref="book"></property>
    </bean>

通过构造器设置属性

constructor节点: 通过构造器  , 注入属性的值
    name属性:  这是一个容易混淆的地方 , 它指的其实是构造方法中形式参数列表中参数的名称
    ref: 表示的是, 本次要注入的对象在当前容器中的id值

案例:

    <bean id="id" class="类">
    <constructor-arg name="book" ref="book"></constructor-arg>
    </bean>

对象的自动装配

我们可以在bean节点中, 添加autowire属性来完成自动装配的操作

属性取值范围:

1,no : 默认设置 , 表示关闭自动装配
     2,byName : 通过名称完成自动装配:
            例如: 当前我们容器中存在一个对象, id为book;
                而刚好当前的这个person类中有一个名称为book的属性   
                那么这个时候, 我们的容器, 会自动完成两个对象的关联
                byName 不会判断传入的参数类型是否匹配, 只要名称相同, 就会强行建立依赖关系 , 导致报错!

3, byType : 通过类型完成自动装配

例如: 当前我们容器中存在一个Book类的对象
                而刚好我们当前的Person有一个Book类型的属性
                我们的容器, 就会自动完成两个对象的关联

4,constructor 与byType的方式类似，不同之处在于它应用于构造器参数
     5,autodetect  通过bean类来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式
案例：

Person类：

package cn.xdl.bean;

public class Person {

    private String name;
    private int age;
    private Book book;
    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 Book getBook() {
        return book;
    }
    public void setBook(Book book) {
        this.book = book;
    }
    @Override
    public String toString() {
        return "这个人叫做:" + name + ", 今年" + age + "岁了, 他有一本书:" + book ;
    }
    public Person(String name, int age, Book book) {
        super();
        this.name = name;
        this.age = age;
        this.book = book;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(Book book) {
        super();
        this.book = book;
    }

}

Person.java

applicationContext文件：

<?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"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">

    <bean id="book" class="cn.xdl.bean.Book">
        <property name="bookName" value="水浒传"></property>
        <property name="bookId" value="10001"></property>
    </bean>
    <!--
        <bean id="person" class="cn.xdl.bean.Person">
            通过ref  关联对象之间的关系
            <constructor-arg name="book">
                <null/>
            </constructor-arg>
            <constructor-arg name="name" value="张三"></constructor-arg>
            <constructor-arg name="age" value="18"></constructor-arg>
            <property name="book" ref="book"></property>
        </bean>
    -->
    <!-- 自动装配 byName 通过属性名称 与 容器中对象的id 匹配 -->
     <bean id="person" class="cn.xdl.bean.Person" autowire="byName">
         <property name="name" value="小李"></property>
         <property name="age" value="18"></property>
    </bean>
</beans>

applicationContext.xml

Test测试类：

package cn.xdl.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.xdl.bean.Person;
import cn.xdl.test.util.ContextUtil;

public class Test {

    @Test
    public void test() throws Exception {
        ClassPathXmlApplicationContext context = ContextUtil.getC("bean6.xml");
        Person p= context.getBean("person", Person.class);
        System.out.println(p);//这个人叫做:小李, 今年23岁了, 他有一本书:书名=水浒传, 编号=10001

    }
}

Test.java

时间： 2024-10-05 06:15:03

【Spring】DI 依赖注入传递参数的方式的相关文章

Spring的依赖注入的2种方式（1天时间）

今天花了一天的时间才调试出来 private      接口   实现类的那个bean; 最后面的那个名字不能随便的写,必须是配置文件中,实现类的那个bean 就是后面的那个名字写错了,花了整整一天 必须有这句注解扫描才能扫描到注解 进行注解的配置,不需要get方法和set方法,小龙儿说xml文件配置才需要set方法 package com.baobaotao1; import org.springframework.context.ApplicationContext; import org.

Spring DI - 依赖注入

1.IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和生命周期的管理,而是在需要时由Spring框架提供,这个由spring框架管理对象创建和生命周期的机制称之为控制反转.而在创建对象的过程中Spring可以依据配置对对象的属性进行设置,这个过称之为依赖注入,也即DI. 2.set方法注入 通常的javabean属性都会私有化,而对外暴露setXxx()

spring -di依赖注入，seter方法

[applicationContext.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" xmlns:p="http://www.sprin

spring中依赖注入方式总结

Spring中依赖注入的四种方式 在Spring容器中为一个bean配置依赖注入有三种方式: · 使用属性的setter方法注入  这是最常用的方式: · 使用构造器注入: · 使用Filed注入(用于注解方式). 使用属性的setter方法注入 首先要配置被注入的bean,在该bean对应的类中,应该有要注入的对象属性或者基本数据类型的属性.例如:为UserBiz类注入UserDAO,同时为UserBiz注入基本数据类型String,那么这时,就要为UserDAO对象和String类型设置se

Spring(五)依赖注入

Spring实现依赖注入有几种方式. 基本类型对象注入 package test.spring.dao; public interface PersonDao { public abstract void add(); } package test.spring.dao.impl; import test.spring.dao.PersonDao; public class PersonDaoBean implements PersonDao { @Override public void ad

Spring的依赖注入（DI）三种方式

Spring依赖注入(DI)的三种方式,分别为: 1．  接口注入 2．  Setter方法注入 3．  构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di; public interface Logic {

Spring：（二）DI依赖注入方式

DI 依赖注入 DI(Dependency Injection)依赖注入,说简单一点就将类里面的属性在创建类的过程中给属性赋值,即将对象依赖属性(简单值,集合,对象)通过配置设值给该对象. 属性注入的方式 构造方法的方式 set方法的方式 工厂方法注入 主要学习前两种方式 构造方法的方式 当是构造方法时注入Bean的属性值(简单值,集合,对象) 利用<constructor-arg>标签进行属性的注入 name:被设置属性的名 value:被设置属性的值 编写用构造方法的pojo 1 pack

SSH深度历险（八） 剖析SSH核心原理+Spring依赖注入的三种方式

在java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. Spring依赖注入(

初识Spring框架实现IOC和DI(依赖注入)

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的, IoC是什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想. 在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转