Spring属性注入的四种方式（XML）

最新推荐文章于 2024-03-19 18:29:00 发布
最新推荐文章于 2024-03-19 18:29:00 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Spring 文章标签： java Spring框架 属性注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaron357/article/details/80215544
版权

  • set方式注入

    给User对象的name属性注入值

    值类型注入：

    User.java
package cn.jjs.bean;

public class User {
    public User() {
        System.out.println("User空参构造器");
    }

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

    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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <!--set方法注入-->
    <bean name="user" class="cn.jjs.bean.User">
        <!--为User对象中名为name的属性注入tom做为值-->
        <property name="name" value="Tom"></property>
        <property name="age" value="18"></property>
    </bean>

</beans>
    Demo.java
package cn.jjs.c_injection;

import cn.jjs.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    @Test
    public void Test() {
        //1. 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/jjs/c_injection/applicationContext.xml");
        //2. 向容器"要"user对象
        User u = (User) ac.getBean("user");
        //3. 打印对象
        System.out.println(u);

    }
}

    引用类型注入:

    Car.java
package cn.jjs.bean;

public class Car {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}
    User.java
package cn.jjs.bean;

public class User {
    public User() {
        System.out.println("User空参构造器");
    }

    private String name;
    private Integer age;
    private Car car;

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
    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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <!--set方法注入-->
    <bean name="user" class="cn.jjs.bean.User">
        <!-- 2 为car属性注入下方配置的carRef对象-->
        <property name="name" value="Tom"></property>
        <property name="age" value="18"></property>
        <property name="car" ref="carRef"></property>
    </bean>

    <!-- 1 将Car对象配置到容器中-->
    <bean name="carRef" class="cn.jjs.bean.Car">
        <property name="name" value="Toyota"></property>
        <property name="color" value="white"></property>
    </bean>

</beans>

    结果

    User空参构造器
User{name='Tom', age=18, car=Car{name='Toyota', color='white'}}

  • 构造器注入（name, index, type）

    • name属性：构造器的参数名
    • index属性：构造器的参数索引
    • type属性：构造器的参数类型

    生成User(String name, Car car)有参构造器。

    User.java
package cn.jjs.bean;

public class User {
    public User() {
        System.out.println("User空参构造器");
    }

    private String name;
    private Integer age;
    private Car car;

    public User(String name, Car car) {
        System.out.println("(String name, Car car)");
        this.name = name;
        this.car = car;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

    <?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-3.0.xsd">
    <!--1 将Car对象配置到容器中-->
    <bean name="carRef" class="cn.jjs.bean.Car">
        <property name="name" value="Toyota"></property>
        <property name="color" value="white"></property>
    </bean>

    <!--构造器注入-->
    <!--2 为car属性注入carRef的值-->
    <bean name="user1" class="cn.jjs.bean.User">
        <constructor-arg name="name" value="Tom"></constructor-arg>
        <constructor-arg name="car" ref="carRef"></constructor-arg>
    </bean>
</beans>

    结果

    User空参构造器
(String name, Car car)
User{name='Tom', age=null, car=Car{name='Toyota', color='white'}}

    ⚠️

    如果遇到构造器的形参列表相同，顺序不同，比如：

    User.java
package cn.jjs.bean;

public class User {
    public User() {
        System.out.println("User空参构造器");
    }

    private String name;
    private Integer age;
    private Car car;

    public User(Car car, String name) {
        this.car = car;
        this.name = name;
    }
    public User(String name, Car car) {
        System.out.println("(String name, Car car)");
        this.name = name;
        this.car = car;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

    可以通过index

    <bean name="user1" class="cn.jjs.bean.User">
    <constructor-arg name="name" value="Tom" index="0"></constructor-arg>
    <constructor-arg name="car" ref="carRef" index="1"></constructor-arg>
</bean>

    则选择：

        public User(String name, Car car) {
        System.out.println("(String name, Car car)");
        this.name = name;
        this.car = car;
    }

    这条构造器。

    ⚠️

    如果遇到形参名相同，则：

    User.java
package cn.jjs.bean;

public class User {
    public User() {
        System.out.println("User空参构造器");
    }

    private String name;
    private Integer age;
    private Car car;
    public User(Integer name, Car car) {
        System.out.println("(Integer name, Car car)");
        this.name = name + "";
        this.car = car;
    }

    public User(String name, Car car) {
        System.out.println("(String name, Car car)");
        this.name = name;
        this.car = car;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

    需要通过给出完整类名type属性，定位构造器。

    <bean name="user1" class="cn.jjs.bean.User">
       <constructor-arg name="name" value="Tom" index="0" type="java.lang.Integer">     </constructor-arg>
       <constructor-arg name="car" ref="carRef" index="1"></constructor-arg>
</bean>

  • p名称空间注入

    导入p名称空间

    <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-3.0.xsd">

    使用 p: 完成注入：

    • 值类型： p:属性名=“值”;
    • 引用类型：p:属性名-ref=”bean名称”;
    <?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-3.0.xsd">

    <!--将Car对象配置到容器中-->
    <bean name="carRef" class="cn.jjs.bean.Car">
        <property name="name" value="Toyota"></property>
        <property name="color" value="white"></property>
    </bean>

    <bean name="user2" class="cn.jjs.bean.User" p:name="jack" p:age="30" p:car-ref="carRef"></bean>
</beans>

    本质是set注入。

    • #### SPEL表达式注入（Spring Expression Language ） #{bean名称 . property名称}
    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.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean name="user" class="cn.jjs.bean.User">
        <!--2 为car属性注入下方配置的car对象-->
        <property name="name" value="Tom"></property>
        <property name="age" value="18"></property>
        <property name="car" ref="carRef"></property>
    </bean>

    <!--1 将Car对象配置到容器中-->
    <bean name="carRef" class="cn.jjs.bean.Car">
        <property name="name" value="Toyota"></property>
        <property name="color" value="white"></property>
    </bean>

    <bean name="user2" class="cn.jjs.bean.User" p:name="jack" p:age="30" p:car-ref="carRef"></bean>

    <bean name="user3" class="cn.jjs.bean.User">
        <property name="name" value="#{user.name}"></property>
        <property name="age" value="#{user2.age}"></property>
        <property name="car" ref="carRef"></property>
    </bean>
</beans>
Aaron++++
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Spring中bean的几种注入方式
08-27
主要介绍了详解Spring中bean的几种注入方式，主要介绍了4种注入，主要有属性注入、构造函数注入、工厂方法注入，非常具有实用价值，需要的朋友可以参考下
Spring框架基础-01
weixin_45750762的博客
11-07 557
Spring框架 优点 是一个开源的免费框架 是一个轻量级的，非入侵的框架 控制反转（IOC），面向切面编程（AOP） 支持事务的处理 想学springboor和springcloud就必须学会spring和springMVC作为基础 IOC （对象由spring来创建，管理，支配） 个人理解 控制反转：就是依赖对象的方式变了，原来是程序员来控制服务的实现，现在是由用户来实现，整体结构没有变！ 不用再new对象了，全都交给spring去创建 要实现不同的操作，只需要在xml配置文件中改动即可 无参构
2_xml方式实现属性注入
weixin_44353972的博客
11-14 303
spring（自理解）
Spring属性注入的三种方式（超详细
最新发布
m0_61549984的博客
03-19 946
">(img-yDNXoSDm-1710844129415)](img-TiEwbqhA-1710844129415)]//2、获取配置文件中创建的对象 默认是执行无参的构造方法创建。//2、获取配置文件中创建的对象 默认是执行无参的构造方法创建。第二步：进行属性注入，在bean标签里。[CDATA[]]>//1、载Spring的配置文件。//1、载Spring的配置文件。书名 作者
Spring——Bean管理-xml方式进行属性注入
一起加油吧~
03-04 1984
Spring中bean管理使用xml方式进行属性注入的7种方式
Spring属性注入的几种方式详解
小鲁班-JAVA开发
09-15 479
给各种类型的对象赋值 Student类和MathTeacher类 package com.xqc; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Set; public class Student { //学号 private Integer stuNo; //姓名 private String stuName; //爱好 p
基于 xml 方式注入属性
qq_39527532的博客
09-09 232
第一种注入方式：使用 set 方法进行注入 （1）创建类，定义属性和对应的 set 方法 /** * 演示使用 set 方法进行注入属性 */ public class Book { //创建属性 private String bname; private String bauthor; //创建属性对应的 set 方法 public void setBname(String bname) { this.bname = bname; } public void setBauthor(Stri
Spring根据XML配置文件注入属性的方法
08-28
下面小编就为大家带来一篇Spring根据XML配置文件注入属性的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring框架配置实体类复杂属性注入xml文件过程详解
08-25
主要介绍了spring框架配置实体类复杂属性注入xml文件过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring根据XML配置文件 p名称空间注入属性的实例
08-28
下面小编就为大家分享一篇Spring根据XML配置文件 p名称空间注入属性的实例，具有很好的参考价值。希望对大家有所帮助
Spring属性注入
04-12
Spring属性注入:关于Spring的属性注入一共有两种方式，分别为XML方式与注解方式，其中XML方式又分为Set注入与构造方法注入，注解方式分为java注解与Spring注解
XML文件修改节点属性值(多种方法)
10-27
有关XML文件的节点属性值修改在使用过程中经常会遇到过，感兴趣的朋友可以参考下本文，希望对你有所帮助
Spring中属性注入的几种方式以及复杂属性的注入详解
08-30
主要介绍了Spring中属性注入的几种方式以及复杂属性的注入详解，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring常用的三种注入方式
qq_39232813的博客
04-12 3972
一、用set方法属性注入 1、首先创建User类，声明属性与set方法，提供show方法用于输出name，age public class User { private String name; private int age; public void setBook(String name) { this.name = name; } public void setAge(int age) { this.age = age;
扯一把 Spring 的三种注入方式，到底哪种注入方式最佳？
被基金支配的打工人
10-22 3994
循环依赖这个问题，按理说我们在日常的程序设计中应该避免，其实这个本来也是能够避免的。不过由于总总原因，我们可能还是会遇到一些循环依赖的问题，特别是在面试的过程中，面试考察循环依赖，主要是想考察候选人对 Spring 源码的熟悉程度，因为要把循环依赖这个问题解释清楚，涉及到不少 Spring 源码。 今天松哥抽空和大家简单聊聊这个话题，问题比较庞大，我可能花几篇文章来和大家分享下，今天先来聊聊实例的注入方式。 1. 实例的注入方式 首先来看看 Spring 中的实例该如何注入，总结起来，无非三种：
Spring框架中XML配置特殊属性注入
jerrygaoling的博客
09-17 452
前言 Spring框架中，在通过set方式进行属性注入时，可能会遇到某些特殊字符的注入，例如：null和某些标签字符“<>”等。此时需要用到与普通属性注入不同的方式。 创建测试类 package com.action.spring; public class Book { private String bname; private String bauthor; private String address; public void setBname(S
【Spring学习05】四种xml配置注入方式
热门推荐
程序老兵的博客
03-30 1万+
平常应用Spring开发中，用得最多的是容器。spring容器帮我们实例化对象并且注入到需要该对象的类中。 spring有多种依赖注入的形式，下面仅介绍spring通过xml进行IOC配置的方式：一、Setter注入set注入是最简单常用的注入方式，《【Spring学习03】Spring简单入门实例 》中就是用的set注入。 Order类中需要用到NotifyService对象,于是定义了一个p
在xml中使用bean进行属性注入
qq_47455973的博客
02-22 1376
1.外部bean注入属性 在xml配置文档中，对service类进行类属性的注入，可以先在xml配置文档中配置dao类，然后在配置service类的时候，在标签中，将value属性换成ref属性，属性值为dao的bean标签的id值。这样就可以通过service类的对象去调用dao类的方法。 2、内部bean属性注入 同样是在service类中，创建dao类的私有属性，然后再通过xml文档对service进行实例化，不同于外部bean注入的是，内部bean注入是将dao的bean实例化放在了servic
IOC系列【XML装配Bean】：XML中属性注入
笨拙的先森
03-20 207
文章目录1. Bean注入1.1 Bean定义1.2 Bean注入2. 数组注入2.1 Bean定义2.2 数组注入3. Map注入3.1 Bean定义3.2 Map注入4. List注入4.1 Bean定义4.2 List注入5. Set注入5.1 Bean定义5.2 Set注入6. Properties注入6.1 Bean定义6.2 Properties注入 属性注入是通过bean标签中的property标签来实现的。 1. Bean注入   通过property标签中的ref属性来实现。 1.1
Spring基于xml注入bean的几种方式
06-07
在 Spring 中，可以通过以下几种方式实现基于 XML 注入 bean： 1. 构造器注入：使用 <constructor-arg> 标签注入 bean 的构造函数参数。 2. 属性注入：使用 <property> 标签注入 bean 的属性。 3. 工厂方法注入：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值