Spring——Bean管理-xml方式进行属性注入

简介: 目前的问题:只能当前类使用,其他类不能用,接下来就是把集合属性抽取成公共部分让所有实体类都能够引入

08cac2a13d314e688019bba3d738d439.png


一、xml方式创建对象


<!--    配置User对象创建-->
<!--    id是取得别名,通过id别名可以把类找到-->
<bean id="user" class="com.atguigu.spring5.User"></bean>


  • id:唯一标识,不能加特殊符号
  • class:类全路经(包类路径)
  • name:可以加特殊符号


二、xml方式注入属性


DI:依赖注入,就是注入属性


第①种方式注入:set方法注入


package com.atguigu.spring5.Book;
public class Book {
    private String bname;
    private String bauthor;
    public void setBname(String bname){
        this.bname=bname;
    }
    public void setBauthor(String bauthor){
        this.bauthor=bauthor;
    }
    public static void main(String[] args) {
        Book book = new Book();
        book.setBname("abc");
    }
    public void testDemo(){
        System.out.println(bname+"---"+bauthor);
    }
}


<?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">
<!--    2.set方法注入属性-->
    <bean id="book" class="com.atguigu.spring5.Book.Book">
<!--        使用propterty完成属性注入-->
<!--        name:类里面属性名称-->
<!--        value:向属性注入的值-->
        <property name="bname" value="追风筝的人"></property>
        <property name="bauthor" value="卡勒德·胡赛尼"></property>
    </bean>
</beans>


package com.atguigu.spring5.Book;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BoolTestMain {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Booktest.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
        book.testDemo();
    }
}


我们还可以通过另一种方式简化写法—p名称空间注入


第②种方式注入:有参构造函数注入


public class Orders {
    //    有参数构造注入属性
    private String oname;
    private String address;
    private double money;
    public Orders(String oname, String address, double money) {
        this.oname = oname;
        this.address = address;
        this.money = money;
    }
    public void show() {
        System.out.println(oname + "---" + address + "---" + money);
    }
}


constructor-arg:通过构造函数注入


使用value标签属性: 默认按照constructor-arg标签的顺序


<constructor-arg value="电脑"></constructor-arg>
<constructor-arg value="China"></constructor-arg>


用name标签属性: 不按照顺序也会自动匹配


<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>


使用index标签属性:index的值为参数的顺序,默认从0开始


 <!--index="0":有参构造的第一个属性-->
<constructor-arg index="0" value="电脑"></constructor-arg>
<constructor-arg index="1" value="China"></constructor-arg>


使用type标签属性:要和参数数据类型严格一致


(如果数据类型一致,按照constructor-arg标签的顺序匹配)


<constructor-arg type="double" value="23"></constructor-arg>
<constructor-arg type="java.lang.String" value="电脑"></constructor-arg>
<constructor-arg type="java.lang.String" value="China"></constructor-arg>


三、xml注入其他类型属性


1、字面量--null值


<constructor-arg name="oname" value="朝花夕拾"/>
<constructor-arg name="oauthor" value="鲁迅"/>
<constructor-arg name="address" >
            <null></null>
</constructor-arg>


e063fac9435e87d5eea5fd06db928932.png


2、含有特殊符号


  • &lt;&gt;
  • 把带特殊符号内容写到!CDATA


  <!--        1、使用&lt;&gt;先进行转义-->
<property name="bauthor" value="鲁迅"></property>
<property name="bname" value="&lt;&gt;朝花夕拾>>"></property>
<!--        2、使用!CDATA-->
<property name="bauthor">
    <value><![CDATA[<<南京>>]]></value>
</property>


3、注入属性-外部bean


通过ref属性将进行注入


public class School {
    //创建School类型属性,生成set方法
    private Teacher teacher;
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}


<!--    注入外部bean-->
<bean id="school" class="com.atguigu.spring5.propertyTest.School">
        <property name="teacher" ref="teachers"></property>
</bean>
<bean id="teachers" class="com.atguigu.spring5.propertyTest.Teacher"></bean>


4、注入属性-内部bean


什么是内部bean?


在某一个bean中定义另一个bean作为属性


什么时候使用内部bean?


如果School类中的某个属性的数据类型是另一个类Book,则可以把这个类Book定义在属性的内部


如何使用内部bean?


public class School {
    //创建School类型属性,生成set方法
    private Teacher teacher;
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    //部门
    private Book dept;
    public void setDept(Book dept) {
        this.dept = dept;
    }
}


public class Book {
    private String bname;
    private String bauthor;
    public void setBname(String bname) {
        this.bname = bname;
    }
}


 <!--    注入内部bean-->
<bean id="school" class="com.atguigu.spring5.propertyTest.School">
        <property name="teacher" ref="teachers"></property>
        <property name="dept" >
            <bean id="book" class="com.atguigu.spring5.Book.Book">
                <property name="bname" value="朝花夕拾"></property>
            </bean>
        </property>
</bean>


5、注入集合属性——数组List集合Map集合、Set集合


package com.atguigu.spring5.CollectionTypeTest;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * @BelongsProject: 02-Spring
 * @BelongsPackage: com.atguigu.spring5.CollectionTypeTest
 * @Author: dengLiMei
 * @CreateTime: 2023-02-09  09:46
 * @Description: TODO
 * @Version: 1.0
 */
public class Student {
    //数组
    private String[] courses;
    //    List集合
    private List<String> lists;
    //Map集合
    private Map<String, String> maps;
    //Set集合
    private Set<String> sets;
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public Student() {
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setLists(List<String> lists) {
        this.lists = lists;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
    public void show() {
        System.out.println(Arrays.toString(courses));
        System.out.println((lists));
        System.out.println((maps));
        System.out.println((sets));
    }
}


<?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="students" class="com.atguigu.spring5.CollectionTypeTest.Student">
        <!-- 数组-->
        <property name="courses">
            <array>
                <value>spring5</value>
                <value>springboot</value>
            </array>
        </property>
        <!--        List类型-->
        <property name="lists">
            <list>
                <value>springcloud</value>
                <value>springcloudAlibaba</value>
            </list>
        </property>
        <!--        Map集合-->
        <property name="maps">
            <map>
                <entry key="QQ" value="腾讯"></entry>
                <entry key="淘宝" value="阿里"></entry>
            </map>
        </property>
        <!--        Set集合-->
        <property name="sets">
            <set>
                <value>set-spring5</value>
                <value>set-springboot</value>
            </set>
        </property>
    </bean>
</beans>


输出结果:


a6e013da2a252770f3a4a19384c9409d.png

如果一个类中包含了另一个类的实体对象,可以这样写


public class Course {
    //    课程名称
    private String cname;
    public void setCname(String cname) {
        this.cname = cname;
    }
}


package com.atguigu.spring5.CollectionTypeTest;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Student2 {
    //实体对象-学生有多门课程
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
    @Override
    public String toString() {
        return "Student2{" +
                "courseList=" + courseList +
                '}';
    }
}


<bean id="student2" class="com.atguigu.spring5.CollectionTypeTest.Student2">
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
<!--    创建多个course对象-->
<bean id="course1" class="com.atguigu.spring5.CollectionTypeTest.Course">
        <property name="cname" value="spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.CollectionTypeTest.Course">
        <property name="cname" value="MyBatis框架"></property>
</bean>


public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("CollectionTypeBeans.xml");
        Student2 students1 = context.getBean("student2", Student2.class);
        students1.show();
}


输出结果:



目前的问题:只能当前类使用,其他类不能用,接下来就是把集合属性抽取成公共部分让所有实体类都能够引入


抽取公共部分


public class Book {
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
    public void show(){
        System.out.println(list);
    }
}


<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!--    1、提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>spring5</value>
        <value>springboot</value>
        <value>springcloud</value>
    </util:list>
    <!--    2、提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.CollectionTypeTest.Book">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>


public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("CollectionTypeBeans.xml");
        Book book = context.getBean("book", Book.class);
        book.show();
}


输出结果:


df20722cf864867a6b7e4a47872e2872.png


Spring系列文章:


Spring——是什么?作用?内容?用到的设计模式?


Spring——Bean管理-xml方式进行属性注入


Spring——Bean管理-注解方式进行属性注入


Spring——什么是IOC?


Spring——AOP是什么?如何使用?


Spring——什么是事务?传播行为?事务隔离级别有哪些?


Spring——整合junit4、junit5使用方法


如果有想要交流的内容欢迎在评论区进行留言,如果这篇文档受到了您的喜欢那就留下你点赞+收藏脚印支持一下博主~

相关文章
|
3月前
|
XML Java 数据格式
Spring从入门到入土(xml配置文件的基础使用方式)
本文详细介绍了Spring框架中XML配置文件的使用方法,包括读取配置文件、创建带参数的构造对象、使用工厂方法和静态方法创建对象、对象生命周期管理以及单例和多例模式的测试。
129 7
Spring从入门到入土(xml配置文件的基础使用方式)
|
3月前
|
Java Spring
在使用Spring的`@Value`注解注入属性值时,有一些特殊字符需要注意
【10月更文挑战第9天】在使用Spring的`@Value`注解注入属性值时,需注意一些特殊字符的正确处理方法,包括空格、引号、反斜杠、新行、制表符、逗号、大括号、$、百分号及其他特殊字符。通过适当包裹或转义,确保这些字符能被正确解析和注入。
183 3
|
3月前
|
Java 测试技术 程序员
为什么Spring不推荐@Autowired用于字段注入?
作为Java程序员,Spring框架在日常开发中使用频繁,其依赖注入机制带来了极大的便利。然而,尽管@Autowired注解简化了依赖注入,Spring官方却不推荐在字段上使用它。本文将探讨字段注入的现状及其存在的问题,如难以进行单元测试、违反单一职责原则及易引发NPE等,并介绍为何Spring推荐构造器注入,包括增强代码可读性和维护性、方便单元测试以及避免NPE等问题。通过示例代码展示如何将字段注入重构为构造器注入,提高代码质量。
119 1
|
12天前
|
XML Java 数据格式
使用idea中的Live Templates自定义自动生成Spring所需的XML配置文件格式
本文介绍了在使用Spring框架时,如何通过创建`applicationContext.xml`配置文件来管理对象。首先,在resources目录下新建XML配置文件,并通过IDEA自动生成部分配置。为完善配置,特别是添加AOP支持,可以通过IDEA的Live Templates功能自定义XML模板。具体步骤包括:连续按两次Shift搜索Live Templates,配置模板内容,输入特定前缀(如spring)并按Tab键即可快速生成完整的Spring配置文件。这样可以大大提高开发效率,减少重复工作。
使用idea中的Live Templates自定义自动生成Spring所需的XML配置文件格式
|
26天前
|
Java Spring
一键注入 Spring 成员变量,顺序编程
介绍了一款针对Spring框架开发的插件,旨在解决开发中频繁滚动查找成员变量注入位置的问题。通过一键操作(如Ctrl+1),该插件可自动在类顶部添加`@Autowired`注解及其成员变量声明,同时保持光标位置不变,有效提升开发效率和代码编写流畅度。适用于IntelliJ IDEA 2023及以上版本。
一键注入 Spring 成员变量,顺序编程
|
17天前
|
XML Java 数据格式
Spring容器Bean之XML配置方式
通过对以上内容的掌握,开发人员可以灵活地使用Spring的XML配置方式来管理应用程序的Bean,提高代码的模块化和可维护性。
53 6
|
4月前
|
XML Java 数据格式
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
Spring 第二节内容补充 关于Bean配置的更多内容和细节 万字详解!
288 18
|
4月前
|
XML Java 数据格式
spring复习02,xml配置管理bean
详细讲解了Spring框架中基于XML配置文件管理bean的各种方式,包括获取bean、依赖注入、特殊值处理、属性赋值、集合类型处理、p命名空间、bean作用域及生命周期和自动装配。
spring复习02,xml配置管理bean
|
3月前
|
缓存 Java Spring
源码解读:Spring如何解决构造器注入的循环依赖?
本文详细探讨了Spring框架中的循环依赖问题,包括构造器注入和字段注入两种情况,并重点分析了构造器注入循环依赖的解决方案。文章通过具体示例展示了循环依赖的错误信息及常见场景,提出了三种解决方法:重构代码、使用字段依赖注入以及使用`@Lazy`注解。其中,`@Lazy`注解通过延迟初始化和动态代理机制有效解决了循环依赖问题。作者建议优先使用`@Lazy`注解,并提供了详细的源码解析和调试截图,帮助读者深入理解其实现机制。
77 1
|
3月前
|
XML 存储 数据格式