Spring(六)属性依赖注入（构造方法，setter方法，p命名空间,spel表达式，集合注入）

最新推荐文章于 2024-08-08 09:02:04 发布
最新推荐文章于 2024-08-08 09:02:04 发布
阅读量3.1k 收藏 9
点赞数 2
分类专栏： 【框架】 Spring框架 java 文章标签： spring 属性依赖注入方式 集合注入方式 spel表达式 setter方法注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su20145104009/article/details/53510376
版权
java 同时被 3 个专栏收录
147 篇文章 35 订阅
订阅专栏
【框架】
36 篇文章 1 订阅
订阅专栏
Spring框架
16 篇文章 6 订阅
订阅专栏

属性依赖注入方式有手动装配和自动装配
一般进行的配置信息都采用手动装配，自动装配主要用在structs和spring整合。在这里只说明手动装配。

手动装配方式

手动装配方式有：

  • 构造方法方式
  • setter方法方式
  • p命名空间方式
  • spel表达式方式
  • 集合注入方式

构造方法方式

说明

构造方法方式注入即把字段放在构造方法中。然后在xml文件中为构造方法中的参数赋值。

xml配置

<bean id="" class="" >                                                                  <constructor-arg index="" type="" value="">
</constructor-arg>
</bean>

在bean标签中配置constructor-arg标签，其中index表示构造方法的第几个参数，（从0开始），type表示参数的数据类型，value表示参数的值。
constructor-arg还有另外一种方式

    <constructor-arg name="" value=""></constructor-arg>

其中构造方法中的name表示参数名，value表示参数值。一般采用第一种方式。

例子

Users类 重写了toString方法，方便下面的测试
重写了两个构造方法，注意两个构造方法参数的数据类型的区别
下面的测试我们要为uid和username赋值。即第一个构造方法。



public class Users {
    private Integer uid;
    private String username;
    private Integer age;


    public Users(Integer uid, String username) {
        super();
        this.uid = uid;
        this.username = username;
    }

    public Users(String username, Integer age) {
        super();
        this.username = username;
        this.age = age;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Users [uid=" + uid + ", username=" + username + ", age=" + age
                + "]";
    }

}

XML配置
其中在constructor-arg 标签中，我们为构造方法的第一个参数数据类型为java.lang.Integer，第二个参数的数据类型为java.lang.String

<?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="UsersId" class="com.scx.inject.test.Users" >
        <constructor-arg index="0" type="java.lang.Integer" value="5"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="TOM"></constructor-arg>
    </bean>
</beans>

测试：

public class Test {
    @org.junit.Test
    public void testScope() {
        String xmlPath = "com/scx/inject/test/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                xmlPath);
        Users user = applicationContext.getBean("UsersId", Users.class);
        System.out.println(user);
    }
}

运行结果：
这里写图片描述
成功为第一个构造方法赋值。

setter方法方式

说明

要使用setter方法注入 类中一定要有这个字段的setter方法 而且一定要把默认的构造方法重写。因为getBean会调用默认的构造方法。
所以相比前面的Users类 加上

public Users(){

    }

xml配置

<bean id="" class="" >
        <property name="" value=""></property>
    </bean>

使用property 标签即可 ，name表示字段名，value表示字段值

例子

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="UsersId" class="com.scx.inject.test.Users" >
        <property name="age" value="5"></property>
        <property name="uid" value="1"></property>
        <property name="username" value="TOM"></property>
    </bean>
</beans>

测试代码不变 ，直接输出
这里写图片描述
成功为字段赋值。

p命名空间方式

说明

P命名空间方式是对上面的setter方法的简化，替换

    <property name="" value=""></property>

。
若想使用p命名空间，必须添加命名空间

xmlns:p="http://www.springframework.org/schema/p"

xml配置

不要忘记添加命名空间啊

<bean id="" class="" p:字段名="字段值">

例子

在上面说了 p命名空间是对Setter方法的简化，所以只修改xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="UsersId" class="com.scx.inject.test.Users" p:age="10" p:uid="1" p:username="Tom">
    </bean>
</beans>

运行结果
这里写图片描述

spel表达式方式

说明

spel即Spring expression的简写 。
spel是对<property name="" value=""></property>
的简化。

xml配置

在property 标签的value里面赋值使用#{}
常用的有：

#{123}、#{‘jack’} ： 数字、字符串
#{beanId} ：另一个bean引用
#{beanId.propName} ：操作数据
#{beanId.toString()} ：执行方法
#{T(类).字段|方法} ：静态方法或字段

例子

Users类，我们希望：
uid使用以前的方式注入
username使用#{beanId.propName}注入
age使用#{123}注入
address使用#{‘jack’} 注入
pi使用#{T(类).字段|方法} 注入


public class Users {
    private Integer uid;
    private String username="tom";
    private Integer age;
    private String address;
    private double pi;
    public Integer getUid() {
        return uid;
    }
    public void setUid(Integer uid) {
        this.uid = uid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public double getPi() {
        return pi;
    }
    public void setPi(double pi) {
        this.pi = pi;
    }
    @Override
    public String toString() {
        return "Users [uid=" + uid + ", username=" + username + ", age=" + age
                + ", address=" + address + ", pi=" + pi + "]";
    }   
}

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="UsersId" class="com.scx.inject.test.Users" >
        <property name="uid" value="1"></property>
        <property name="age" value="#{10}"></property>
        <property name="username" value="#{UsersId.username?.toUpperCase()}"></property>
        <property name="pi" value="#{T(java.lang.Math).PI}"></property>
        <property name="address" value="#{'CHINA'}"></property>
    </bean>
</beans>

测试代码和前面一样。
运行结果
这里写图片描述

集合注入方式

说明

集合的注入都是给property添加子标签。

xml配置

      数组：<array>
        List：<list>
        Set：<set>
        Map：<map> ，map存放k/v 键值对，使用<entry>描述
        Properties：<props>  <prop key=""></prop>  

    普通数据：<value>
    引用数据：<ref>

例子

一个集合类CollData ，里面包含多种我们常用的集合

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class CollData {
    private String [] arrayData;
    private List listData;
    private Map mapData;
    private Set setData;
    private Properties propsData;
    public String[] getArrayData() {
        return arrayData;
    }
    public void setArrayData(String[] arrayData) {
        this.arrayData = arrayData;
    }
    public List getListData() {
        return listData;
    }
    public void setListData(List listData) {
        this.listData = listData;
    }
    public Map getMapData() {
        return mapData;
    }
    public void setMapData(Map mapData) {
        this.mapData = mapData;
    }
    public Set getSetData() {
        return setData;
    }
    public void setSetData(Set setData) {
        this.setData = setData;
    }
    public Properties getPropsData() {
        return propsData;
    }
    public void setPropsData(Properties propsData) {
        this.propsData = propsData;
    }
    @Override
    public String toString() {
        return "CollData [\narrayData=" + Arrays.toString(arrayData)
                + ", \nlistData=" + listData + ", \nmapData=" + mapData
                + ", \nsetData=" + setData + ", \npropsData=" + propsData + "]";
    }


}

xml代码
需要特别注意的是map集合使用entry key="" value=""></entry>
键值对赋值。Properties使用

            <props>
                <prop key=""></prop>
            </props>

赋值。

<?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="CollDataId" class="com.scx.inject.test.CollData" >
        <!-- 为数组赋值 -->
        <property name="arrayData">
            <array>
                <value>array1</value>
                <value>array2</value>
                <value>array3</value>
            </array>
        </property>
        <!-- 为list赋值 -->
        <property name="listData">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>
        <!-- 为map赋值 -->
        <property name="mapData">
            <map>
                <entry key="key1" value="value1"></entry>
                <entry key="key2" value="value2"></entry>
            </map>
        </property>
        <!-- 为set赋值 -->
        <property name="setData">
            <set>
                <value>set1</value>
                <value>set2</value>
                <value>set3</value>
            </set>
        </property>
        <!-- 为Properties赋值 -->
        <property name="propsData">
            <props>
                <prop key="一">1</prop>
                <prop key="二">2</prop>
                <prop key="三">3</prop>
            </props>
        </property>
    </bean>
</beans>

测试类

public class Test {
    @org.junit.Test
    public void testScope() {
        String xmlPath = "com/scx/inject/test/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                xmlPath);
        CollData collData = applicationContext.getBean("CollDataId", CollData.class);
        System.out.println(collData);
    }
}

运行结果：
这里写图片描述

scx_white
关注
专栏目录
Spring依赖注入bean属性、手动装配使用xml配置、SpEL表达式、集合List、Set、Map、Properties注入、数组注入、注解注入-day02
ShuYY的博客
09-11 682
目录第一节 Spring依赖注入Bean属性(xml)1.1 手动装配，使用xml配置1. 通过构造方法注入2. 通过属性的setter方法注入3. 通过p命名空间注入【了解】1.2 SpEL表达式【了解】演示1.3 集合注入List、Set、Map、Properties、数组1.4 注解注入@Component使用案例@Component("id")使用案例未使用注解的web-service-dao配置使用注解的web-service-dao配置 第一节 Spring依赖注入Bean属性(xml) 1.1
SpringFramework核心技术四：Spring表达式语言知识点（SpEL）
向小凯同学学习
06-27 2913
Spring表达式 Sprng表达式，可以适用于几乎所有的Spring产品中，是一种非常重要的表达式语言，下面我们一起来看看。 一、介绍 Spring Expression Language（简称SpEL）是一种强大的表达式语言，支持在运行时查询和操作对象图。语言语法类似于Unified EL，但提供了额外的功能，特别是方法调用和基本的字符串模板功能。 虽然还有其他几种Java表达式语言可...
Spring 依赖注入
二饭的博客
11-27 200
依赖注入 依赖注入属于IoC。 五种关系：继承、依赖、关联、聚合、组合 当创建User对象时，（dept对象不能为空），如何自动的创建Dept并将其赋给dept。 *依赖注入需要IoC的环境，依赖的双方必须全部交给Spring管理。 1 基于xml的依赖注入 1.1简单类型的属性的依赖注入 1.1.1 构造方法注入 ① 需要重载构造方法，一般开发中需要保留默认构造 <bean id="user" class="com.pojo.User"> <!-- 为构造方法指定参数的值
Java 新手入门：依赖注入的 N 种姿势，总有一款适合你！
最新发布
qq_36807888的博客
08-08 495
OrderService 强依赖于 ProductService 和 UserService 的具体实现，如果要替换成其他实现，就需要修改 OrderService 的代码。在 CoffeeMaker 类的字段上使用 @Autowired 注解，告诉 Spring 容器在创建 CoffeeMaker 对象后，自动为这些字段注入依赖的对象。简单来说，依赖注入就是将一个对象所依赖的其他对象，通过外部的方式传递进来，而不是由对象本身来创建。这样做的好处是可以降低代码耦合度，提高代码的可重用性和可测试性。
Spring命名空间p的属性注入的方式
huanglianggu的专栏
11-14 1229
Spring命名空间p的属性注入的方式 第一步： 第二步： 第三步：
Spring四大注入方式，set注入、构造函数注入、p名称空间注入、spel注入
小道仙的后宫
07-05 1057
简单解释一下注入：就是给对象赋值（直接给出代码，解释全部在代码里面 ）前提是你已经配置好了spring的环境，如果还不会配置可以去看我的入门spring配置https://blog.csdn.net/tomwildboar/article/details/809136811、所用到的实体类    1-1 car类package spring.bean; public class Car { p...
Spring依赖注入之Spel 2019.11.02
weixin_42673117的博客
11-04 366
SPEL:Spring Expression Language 1、通过${}可以对对象进行注入 2、格式：#{名称} 3、使用Spel表达式可以用value的方式进行注入 4、property对类中某个属性赋值 当利用到另外一个对象中的某个属性可以使用：#{id.属性名/方法名 5、依赖注入—自动装配 语法： 装配值:内部的属性是什么类型在Context中自己寻找类型 例： <bean n...
Java 19：Spring 2（Bean运行时值注入：占位符和SpEL表达式 ）
siqinzgx的专栏
08-09 1799
前面一节讲Bean的配置，篇幅太长，其实还有不少东西没有加进去，比如Bean冲突，Bean作用域，Bean在不同环境下的加载，不过那些高级特性用的机会不多，就不写了。前面学习的时候，就提到，我们初始化的Bean都是硬编码的，Bean的装配除了确定Bean之间的依赖关系，将一个Bean的引用注入到另一个Bean中的属性和构造器中，将值诸如属性或构造函数也是重要的一部分。 Spring提供两种运行时
Spring注入方式有哪些
09-01
- **@Value**：用于注入基本类型或字符串值，可以直接写常量值，也可以结合SpEL（Spring Expression Language）表达式从配置中获取值。 - **@Inject**：JSR-330标准的注入注解，Spring 3.0以上支持，与@Autowired...
Spring中你不知道的注入方式编程开发技术共6页.pdf
11-25
这是最常见的注入方式，通过`@Autowired`注解标记setter方法，Spring会在运行时自动调用这些方法注入依赖。如果存在多个相同类型的bean，可以通过`@Qualifier`指定特定bean。 3. **字段注入**： 除了setter方法，...
Spring-SPEL注入
wyyblog
03-19 598
&lt;bean id="person" class="top.wyyblog.DI7.Person"&gt; &lt;property name="pname" value="张三"&gt;&lt;/property&gt; &lt;property name="page" value="#{T(java.lang.Math).
Ioc和Aop扩展--多种方式实现依赖注入(构造注入,p命名空间注入,集合类型注入,注入null和注入空值)...
weixin_34163553的博客
10-10 120
构造注入 语法： <constructor-arg> <ref bean=“bean的id”/> </constructor-arg> 1.首先创建一个实体类，一定要有带参构造 public class UserEntity { private Integer id; private String name; ...
Spring依赖注入的方式自己整理的
weixin_43839323的博客
11-13 323
文章目录Spring依赖注入的方式1、setter方法注入2、构造器注入3、基于注解的注入4、静态工厂的方法注入5、实力工厂的方法注入总结 Spring依赖注入的方式 Spring依赖注入（DI）有三种方式： - 接口注入 - Setter方法注入 - 构造方法注入 1、setter方法注入 最简单的注入方式。 假设有一个SpringAction，类中需要实例化一个SpringDao对象，那么就可以定义一个private的SpringDao成员变量，然后创建SpringDao的set方法（这是IOC的注入入
Spring IOC概述—依赖注入，集合注入，SPEL，自动装配
S500783的博客
11-07 367
1.Spring IOC是什么 　Ioc—Inversion of Control，即“控制反转”，是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。简言之，就是使用对象的时候不再“随用随new”，也不用new一个对象然后给它赋值，这些通过IOC容器都能由系统自动生成。 2.Spring IOC优点 1. 轻量级 2. 依赖注入 3. ...
p名称空间的属性注入、集合属性的注入以及Spring分模块配置
Woo_home的博客
04-27 760
一、p名称空间的属性注入（版本：Spring2.5以后的） <beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"...
spring01-P命令空间[了解]+集合注入+装配Bean 基于注解
qq_35187942的博客
02-27 247
    P命令空间[了解] 对“setter方法注入”进行简化，替换&lt;property name="属性名"&gt;，而是在        &lt;bean p:属性名="普通值"  p:属性名-ref="引用值"&gt; p命名空间使用前提，必须添加命名空间              &lt;bean id="personId" class="com
spring之基于p命名c命名空间的注入
qq_42338744的博客
11-18 878
P命名空间注入：目的：简化set方法注入在XML头部信息中添加p命名空间的配置信息：xmlns:p=“http://www.springframeworl.org/schema/p”p命名空间注入是基于setter方法的，所以需要对应的属性提供set方法c命名空间注入：目的：简化构造方法在XML头部信息中添加p命名空间的配置信息：xmlns:c=“http://www.springframeworl.org/schema/c”c命名空间注入是基于构造方法的，所以需要提供构造方法。
Spring 基于构造函数注入依赖 基于setter的注入依赖
H_L_Y的博客
06-07 514
依赖注入DI依赖注入基于构造函数的依赖注入基于setter的依赖注入扩展注入spring 配置别名Bean配置import B站学习笔记 DI依赖注入 依赖：bean 的创建依赖容器 注入：bean 对象的所有属性由容器注入 使用DI原理，代码更加简洁，当为对象提供依赖项时，去耦会更有效。该对象不查找其依赖项，并且不知道依赖项的位置或类。结果，您的类变得更易于测试，尤其是当依赖项依赖于接口或抽象基类时，它们允许在单元测试中使用存根或模拟实现。 DI存在两个主要变体：基于构造函数的依赖注入和[基于Setter
Spring4.x(11)依赖注入-setter方法注入
zhangbijun1230的专栏
05-04 309
依赖注入-setter方法注入 通过无参构造函数+setter方法注入。 一、编写CustomerDao接口 package com.yiidian.dao; /** * * @author http://www.yiidian.com * */ public interface CustomerDao { public void save(); } 二、编写Cus...
Spring入门：Bean定义、作用域与依赖注入详解
- **p命名空间注入**：XML 配置中的 `<p>` 标签，用于属性值注入。 - **SPEL（Spring Expression Language）表达式注入**：允许动态地引用变量或表达式进行注入。 **复杂类型注入** Spring 对于复杂数据结构的支持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值