基于 xml 方式的bean管理

最新推荐文章于 2023-03-22 21:11:09 发布
最新推荐文章于 2023-03-22 21:11:09 发布
阅读量207 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729148/article/details/113262978
版权

1、基于 xml 方式创建对象

（1）在 spring 配置文件，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
（2）在 bean 标签有很多属性，介绍常用的属性

  • id 属性：唯一标识
  • class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

2、基于 xml 方式注入属性

（1）DI：依赖注入，就是注入属性

3、第一种注入方式：使用 set 方法进行注入

（1）创建类，定义属性和对应的 set 方法

public class Book {
    //创建属性
    private String bname;
    private String bauthor;

    //创建属性对应的 set 方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
    public String toString() {
        return "Book{" +
                "bname='" + bname + '\'' +
                ", bauthor='" + bauthor + '\'' +
                '}';
    }
}

（2）在 spring 配置文件配置对象创建，配置属性注入

    <!--2set方法注入属性-->
    <bean id="book" class="com.atguigu.spring5.Book">
        <!--使用property属性完成属性注入
            name：类里面的属性名称
            value：向属性中注入的值
        -->
        <property name="bname" value="java学习指南"></property>
        <property name="bauthor" value="大佬"></property>
    </bean>

（3）测试

 @Test
    public void testBook(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean1.xml");
        //2获取配置创建的对象
        Book book = context.getBean ("book", Book.class);
        System.out.println (book);
    }

（4）结果
在这里插入图片描述

4、第二种注入方式：使用有参数构造进行注入

（1）创建类，定义属性和有参数的构造方法

public class Orders {
    //属性
    private String oname;
    private String address;

    //有参数构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
     public String toString() {
        return "Orders{" +
                "oname='" + oname + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

（2）在 spring 配置文件中进行配置

  <!--3使用构造方法进行熟属性注入-->
    <bean id="orders" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="china"></constructor-arg>
    </bean>

（3）测试

 @Test
    public void testOrders(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean1.xml");

        //2获取配置创建的对象
        Orders orders = context.getBean ("orders", Orders.class);
        System.out.println (orders);
    }

（4）结果
在这里插入图片描述

第三种注入方式： p 名称空间注入

（1）添加 p 名称空间在配置文件中

在约束中增加：xmlns:p="http://www.springframework.org/schema/p"

（2）进行属性注入，在 bean 标签里面进行操作

    <!--4p名称空间注入-->
<bean id="book1" class="com.atguigu.spring5.Book" p:bauthor="绝世神功" p:bname="带佬"></bean>

（3）测试

   @Test
    public void testp(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean1.xml");

        //2获取配置创建的对象
        Book book1 = context.getBean ("book1", Book.class);
        System.out.println (book1);
    }

(4)结果
在这里插入图片描述

xml 注入其他类型属性

1、字面量null 值

（1）null 值在xml中配置

 <!--5字面量-->
    <bean id="book1" class="com.atguigu.spring5.Book">
        <property name="bname" value="字面量null"></property>
        <property name="bauthor">
            <null></null>
        </property>
    </bean>

（2）测试

 @Test
    public void testnull(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean2.xml");

        //2获取配置创建的对象
        Book book1 = context.getBean ("book1",Book.class);
        System.out.println (book1);
    }

（3）结果
在这里插入图片描述
2、字面量，属性值包含特殊符号

    <!--5字面量,属性值包含特殊属性-->
    <bean id="book2" class="com.atguigu.spring5.Book">
        <property name="bname" value="字面量包含特殊值"></property>
        <property name="bauthor">
            <value><![CDATA[<<哈哈哈>>]]></value>
        </property>
    </bean>

（2）测试

    @Test
    public void testteshu(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean2.xml");

        //2获取配置创建的对象
        Book book2 = context.getBean ("book2",Book.class);
        System.out.println (book2);
    }

（3）结果
在这里插入图片描述

2、注入属性-外部 bean

（1）创建两个类 service 类和 dao 类

package com.atguigu.spring5.dao;
public interface UserDao {
    public void update();
}

package com.atguigu.spring5.dao;
public class UserDaoImp implements UserDao {
    @Override
    public void update() {
        System.out.println ("update...");
    }
}

（2）在 service 调用 dao 里面的方法

package com.atguigu.spring5.service;
import com.atguigu.spring5.dao.UserDao;
public class UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        //1创建UserDao属性，生成set方法
        System.out.println ("add...");
        userDao.update ();
    }
}

（3）在 spring 配置文件中进行配置

<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <property name="userDao" ref="userDaoImp"></property>
</bean>
    <bean id="userDaoImp" class="com.atguigu.spring5.dao.UserDaoImp"></bean>

（4）测试

 @Test
    public void test1(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean3.xml");
        //2获取配置创建的对象
        UserService bean = context.getBean ("userService", UserService.class);
        System.out.println (bean);
        bean.add ();
    }

（5）结果
在这里插入图片描述

3、注入属性-内部 bean

（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多

package com.atguigu.spring5;

public class Emp {
 private String ename;
 private String gender;
 //员工属于某一个部门，使用对象形式表示
 private Dept dept;
 public void setDept(Dept dept) {
 this.dept = dept;
 }
 public void setEname(String ename) {
 this.ename = ename;
 }
 public void setGender(String gender) {
 this.gender = gender;
 } }

package com.atguigu.spring5;

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
（3）在 spring 配置文件中进行配置

<bean id="userDaoImp" class="com.atguigu.spring5.dao.UserDaoImp"></bean>
    <bean id="emp" class="com.atguigu.spring5.Emp">
        <property name="ename" value="dd"></property>
        <property name="gender" value="男"></property>
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring5.Dept">
                <property name="dname" value="保安部门"></property>
            </bean>
        </property>
    </bean>

（4）测试

  @Test
    public void test2(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean3.xml");

        //2获取配置创建的对象
        Emp emp = context.getBean ("emp", Emp.class);
        System.out.println (emp);
    }

（5）结果
在这里插入图片描述

4、xml 注入集合属性

1、注入数组类型属性
2、注入 List 集合类型属性
3、注入 Map 集合类型属性
（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

package com.atguigu.spring5;

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

public class Stu {
    //1 数组类型属性
    private String[] courses;
    //2 list 集合类型属性
    private List<String> list;
    //3 map 集合类型属性
    private Map<String, String> maps;
    //4 set 集合类型属性
    private Set<String> sets;

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
}

（2）在 spring 配置文件进行配置

    <!--注入集合类型-->
    <bean id="stu" class="com.atguigu.spring5.Stu">
        <property name="courses">
            <array>
                <value>java</value>
                <value>php</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>王五</value>
            </list>
        </property>
        <property name="maps">
            <map>
                <entry key="java" value="JAVA"></entry>
                <entry key="K1" value="V1"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>1</value>
                <value>2</value>
            </set>
        </property>
    </bean>

（3）测试

@Test
    public void test3(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean3.xml");

        //2获取配置创建的对象
        Stu stu = context.getBean ("stu", Stu.class);
        System.out.println (stu);
    }

（4）结果
在这里插入图片描述
4、在集合里面设置对象类型值
(1)创建课程和课程List

package com.atguigu.spring5;

public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

package com.atguigu.spring5;

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

public class Stu {

    //1 数组类型属性
    private String[] courses;
    //2 list 集合类型属性
    private List<String> list;
    //3 map 集合类型属性
    private Map<String, String> maps;
    //4 set 集合类型属性
    private Set<String> sets;

    //5学生学的多门课程
    private List<Course> courseList;

    @Override
    public String toString() {
        return "Stu{" +
                "courses=" + Arrays.toString (courses) +
                ", list=" + list +
                ", maps=" + maps +
                ", sets=" + sets +
                ", courseList=" + courseList +
                '}';
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
}

(2)配置xml文件

  <!--注入集合类型-->
    <bean id="stu" class="com.atguigu.spring5.Stu">
        <property name="courses">
            <array>
                <value>java</value>
                <value>php</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>王五</value>
            </list>
        </property>
        <property name="maps">
            <map>
                <entry key="java" value="JAVA"></entry>
                <entry key="K1" value="V1"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>1</value>
                <value>2</value>
            </set>
        </property>
        <!--集合中的对象注入-->
        <property name="courseList">
            <list>
               <ref bean="c1"></ref>
                <ref bean="c2"></ref>
            </list>
        </property>
    </bean>
    <bean id="c1" class="com.atguigu.spring5.Course">
        <property name="cname" value="数据库课程"></property>
    </bean>
    <bean id="c2" class="com.atguigu.spring5.Course">
        <property name="cname" value="java课程"></property>
    </bean>

（3）测试

@Test
    public void test3(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean3.xml");

        //2获取配置创建的对象
        Stu stu = context.getBean ("stu", Stu.class);
        System.out.println (stu);
    }

（4）结果
在这里插入图片描述
5、把集合注入部分提取出来
（1）在 spring 配置文件中引入名称空间 util

<?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">
<!--util标签抽取list集合类型的注入-->
    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>
    <!--2 提取 list 集合类型属性注入使用-->
    <bean id="b" class="com.atguigu.spring5.util.Books">
    <property name="list" ref="bookList"></property>
</bean>

(2) Books类，与前面的book不一样。

package com.atguigu.spring5.util;

import java.util.List;

public class Books {
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }
}

（3）测试

  @Test
    public void test4(){
        //1加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext ("bean3.xml");

        //2获取配置创建的对象
         Books b = context.getBean ("b", Books.class);
         System.out.println (b);
    }

（4）结果
在这里插入图片描述

_ady
关注
专栏目录
【Spring】-基于XML管理bean
Javaer000的博客
08-20 209
【Spring】-基于XML管理bean
Spring基于Xml注入bean的几种方式
热门推荐
java_fight的博客
08-16 1万+
spring中的依赖注入 依赖注入： Dependency Injection IOC的作用： 降低程序间的耦合（依赖关系） 依赖关系的管理： 以后都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供， 我们只需要在配置文 件中说明 依赖关系的维护： 就称之为依赖注入。 能注入的数据：有三类 基本类型和String 其他bean类型（在配置文件...
利用XMLBean轻轻松松读写XML
KolShon的专栏
01-13 1347
一、关于XML解析　　　　XML在Java应用程序里变得越来越重要, 广泛应用于数据存储和交换. 比如我们常见的配置文件,都是以XML方式存储的. XML还应用于Java Message Service和Web Services等技术作为数据交换.　　　　因此,正确读写XML文档是XML应用的基础.　　　　Java提供了SAX和DOM两种方式用于解析XML,但即便如此,要读写一个稍微复杂的XML,
IOC操作Bean管理(基于xml方式)
weixin_42262495的博客
06-08 127
IOC管理(基于XML)
Spring Ioc容器，基于xml的bean管理
m0_46481563的博客
03-30 508
IOC容器 IOC思想基于IOC容器，IOC容器底层就是对象工厂 IOC底层 通过控制反转，使用xml配置文件和反射机制实现对对象的创建
JAVA-4-[Spring框架]基于XML方式的Bean管理
qq_20466211的博客
03-22 482
Spring框架
Spring基于xml文件配置Bean过程详解
08-25
Spring基于xml文件配置Bean过程详解 Spring 框架是一个功能强大且...Spring框架基于xml文件配置Bean是一个功能强大且灵活的配置方式，它可以让我们轻松地管理Bean的生命周期，并提供了许多高级特性来满足我们的需求。
基于XML配置Bean
ouyang2018的博客
10-14 3007
IOC：其思想是反转资源获取的方向，传统的资源查找方式要求组件向容器发起请求查找资源，作为回应，容器适时的返回资源。而应用了IOC之后，则是容器主动的将资源推送给它所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源，这种行为也被称为查找的被动形式。 DI：IOC的另外一种表述方式，即组件以一些预先定义好的方式（例如：setter方法）接受来自容器的资源注入，相对于IOC而言，这种表述更直接...
【基于xml方式】spring-kafka.zip
09-09
当我们谈论"基于xml方式的Spring整合Kafka"时，意味着我们将使用XML配置文件来设置Spring与Kafka的集成。 Spring框架允许开发者通过XML配置来声明式地配置bean，包括数据源、事务管理器、以及与Kafka相关的消费者和...
IOC操作Bean管理（基于注解方式）
m0_57448314的博客
12-02 1097
注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）使用注解，注解作用于类上面，方法上面，属性上面使用注解目的，简化xml配置。
bean.xml的内容
12-11
bean.xmlbean.xml
Spring中Bean管理操作基于XML配置文件方法实现
jerrygaoling的博客
09-16 290
Bean管理操作 （1）基于XML配置文件方式实现 1、基于xml方式创建对象 <bean id="user" class="com.action.spring.User"></bean> 使用标签中添加对应属性 id属性：对象别名，唯一标识。 class属性：类全路径（包加类名）。 创建对象默认执行无参构造函数。 2、基于xml方式注入属性 DI：依赖注入 使用set方法注入 1、创建类，定义属性和对应的set方法 public class Book{
2.2 IOC之基于XML管理bean
qq_44774198的博客
07-31 272
**1.实例化*2.依赖注入*3.后置处理器的postProcessBeforeInitialization方法*4.初始化，需要通过bean的init-method属性来制定初始化的方法*5.后置处理器的postProcessAfterInitialization方法*6.使用*7.IOC容器关闭时销毁，需要通过beean的destory-method属性指定销毁的方法**FactoryBean是Spring提供的一种整合第三方框架的常用机制。......
基于XML管理Bean
LeGuan_Ha的博客
10-05 284
由于id属性指定了bean的唯一标识，所以根据bean标签的id属性可以精确获取到一个组件对象。如果一个接口有多个实现类，这些实现类都配置了bean，根据接口类型可以获取bean吗？注意：constructor-arg标签还有两个属性可以进一步描述构造器参数。当根据类型获取bean时，要求IOC容器中指定类型的bean有且只有一个。如果组件类实现了接口，根据接口类型可以获取bean吗？配置Clazz类型的bean。可以，前提是bean唯一。不行，因为bean不唯一。
spring的bean管理（xml方式）
GUYIIT的博客
08-17 200
Bean实例化的方式 1.在spring里面通过配置文件创建对象 2.bean实例化三种方式实现 第一种 使用类的无参数构造创建（重点） <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xs...
Spring Bean管理（XML方式）
Tsama的博客
03-30 183
说明：本文展示的代码和例子是承接我的上一个 关于IoC的介绍的文章。所以在阅读本文的时候，如果遇到的例子您无法理解，请移步预读上文。 引言 为了更好的加强代码的独立性，方便程序员分工合作和代码维护，所以在面向对象编程时采用IoC方式； 而IoC方式简单来说就是，在一个方法中，我需要的类不用我自己去创建（也称new出来），我们通过一个外部的容器（spring框架）帮我们创建这个类并把它注入进来，这个过程也就是我们前面提到的依赖注入； 上文我们讲到如何去简单的使用IoC和配置使用环境，而使用IoC大概需要以下
Spring：bean管理（XML配置）
离开屏幕的光，哪盏灯照亮你的孤独？
06-26 253
Spring的bean管理（xml配置） bean实例化 第一种：使用类的无参数构造创建（重点） <bean id="user" class="com.feicui.pojo.User"></bean> 类里面必须有无参构造方法，如果没有出现异常 第二种：使用静态工厂创建 创建静态的方法，返回类对象 public class UserFactory {...
Spring 使用XML管理对象的方式
weixin_45863060的博客
12-02 187
Spring 使用XML管理对象的方式 XML文件配置 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
IOC操作——基于xml方式实现bean管理
希望和大家多多交流技术！
04-03 141
1、什么是bean管理 bean管理指的是两个操作：1、Spring创建对象 2、Spring注入属性 bean管理的两种实现方式：1、基于xml配置文件的方式 2、基于注解的方式 2、基于xml方式实现bean管理 2.1、创建对象 2.2、注入属性 DI：翻译过来是依赖注入，也就是属性注入。其实就是给属性赋值的过程。 在一个类中创建一个private属性且没有赋予初始值。如果我们想给属性赋值，之前学习的java，我们有两种办法： 创建set（）{} 方法...
spring基于xml注入bean的几种方式
最新发布
04-30
Spring框架是一种轻量级的Java开发框架，主要使用依赖注入和面向切面编程等技术来完成应用程序的开发和管理。在Spring框架中，注入Bean是非常重要的一个概念。在XML配置文件中，可以使用以下几种方式来注入Bean： 1. Constructor注入 使用Constructor注入是指在Bean实例化时，通过构造函数（Constructor）注入需要的依赖。在配置文件中使用 <constructor-arg> 标签来配置参数，例如： <bean id="foo" class="com.example.Foo"> <constructor-arg index="0" value="fooValue"/> <constructor-arg index="1" value="barValue"/> </bean> 2. Setter注入 使用Setter注入是指在Bean实例化后，通过Setter方法注入需要的依赖。在配置文件中使用 <property> 标签来配置参数，例如： <bean id="foo" class="com.example.Foo"> <property name="foo" value="fooValue" /> <property name="bar" value="barValue" /> </bean> 3. 静态工厂方法注入 使用静态工厂方法注入是指通过静态工厂方法（static factory method）来实例化Bean，并注入需要的依赖。在配置文件中使用 <bean> 标签的 factory-method 属性来指定工厂方法名称，例如： <bean id="foo" class="com.example.Foo" factory-method="createFoo"> <constructor-arg index="0" value="fooValue"/> <constructor-arg index="1" value="barValue"/> </bean> 4. 实例化工厂方法注入 使用实例化工厂方法注入是指在Bean实例化前，通过实例化工厂方法（factory method）来实例化Bean，并注入需要的依赖。在配置文件中使用 <bean> 标签的 factory-bean 和 factory-method 属性来指定工厂Bean和工厂方法名称，例如： <bean id="fooFactory" class="com.example.FooFactory"/> <bean id="foo" factory-bean="fooFactory" factory-method="createFoo"> <constructor-arg index="0" value="fooValue"/> <constructor-arg index="1" value="barValue"/> </bean>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值