【Spring】IOC操作bean管理（一）——bean管理实例详解（XML、FactoryBean）

最新推荐文章于 2022-07-31 08:00:00 发布
最新推荐文章于 2022-07-31 08:00:00 发布
阅读量491 收藏 1
点赞数 5
分类专栏： ▶后端 ▶框架 # 【Spring】 文章标签： spring xml bean 注解 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42835409/article/details/119878298
版权
▶后端 同时被 3 个专栏收录
99 篇文章 2 订阅
订阅专栏
▶框架
31 篇文章 0 订阅
订阅专栏
【Spring】
12 篇文章 0 订阅
订阅专栏

【Spring系列】IOC控制反转

【Spring系列】IOC操作bean管理（一）——bean管理实例详解

【Spring系列】IOC操作bean管理（二）——bean的生命周期、作用域

【Spring系列】IOC操作bean管理（三）——xml自动装配

【Spring系列】IOC操作bean管理（四）——引入外部属性文件

【Spring系列】IOC操作bean管理（五）——bean管理注解

【Spring系列】AOP详解

【Spring系列】JdbcTemplate操作数据库详解

【Spring系列】spring事务配置详解

【Spring系列】spring5框架新特性

文章目录

一、Bean管理是什么

（1）Spring创建对象

（2）Spirng注入属性

二、Bean管理操作方式

（一）Bean管理xml

（1）基于xml创建对象

	<!--例如：创建dao对象-->
    <bean id="userDaoImpl" class="com.springlearn.dao.UserDaoImpl"></bean>

（2）基于xml注入属性

1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建；

2）bean标签常用属性：

  • id属性：唯一标识
  • class属性：类全路径（包类路径）
  • scope属性：单例 singleton 多例 pototype （默认是单例）

3）创建对象时候，默认调用无参数构造方法完成对象创建；

① 使用set方法：

实体类：

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 class Main {

    @Resource
    public static void main(String[] args) {
        Book book = new Book();
        book.setBname("");
        book.setBauthor("");
    }
}

使用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">
       
	<!--使用set方法注入属性-->
    <bean id="book" class="com.springlearn.entity.Book">
       <!--使用property完成属性注入
        name：类里面属性名称
        value：向属性注入的值
       -->
     	<property name="bname" value="Spring学习"></property>
        <property name="bauthor" value="肥宅快乐鼠"></property>
    </bean>

</beans>
②使用有参构造：

实体类：

public class Order {

    private String oid;
    private String oname;

    //生成有参构造
    public Order(String oid, String oname) {
        this.oid = oid;
        this.oname = oname;
    }
}

原始方法：

public class Main {

    public static void main(String[] args) {
        Order order = new Order("", "");
    }
}

使用有参构造：
无需原始方法

<?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>
    <!--使用有参构造方法注入属性-->
    <bean id="order" class="com.springlearn.entity.Order">
        <constructor-arg name="oid" value="123"></constructor-arg>
        <constructor-arg name="oname" value="书本"></constructor-arg>
    </bean>

</beans>
③ 使用p名称空间：

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.xsd">
    
    <bean id="book" class="com.springlearn.entity.Book" p:bname="课本" p:bauthor="肥宅快乐鼠"></bean>
    
</beans>

（3）基于xml注入其他类型属性

1）注入null或特殊符号
1：如果有null值

<null/>

    <bean id="book" class="com.springlearn.entity.Book">
        <property name="bname" value="Spring学习"></property>
        <property name="bauthor">
            <null/>
        </property>
    </bean>
2：如果包含特殊符号

<value><![CDATA[特殊符号属性]]></value>
或
转义 &lt; &gt;

<property name="address">
    <value><![CDATA[<<spring学习>>]]></value>
</property>
2）注入外部bean（注入对象类型属性）
  • 创建对象

（1）创建两个类 service类和dao接口和实现类
在这里插入图片描述

UserDao:

public interface UserDao {
    public void addUser();
}

UserDaoImpl:

public class UserDaoImpl implements UserDao{
    @Override
    public void addUser() {
        System.out.println("UserDao类的addUser方法……");
    }
}

（2）在spring配置文件中进行配置
其实底层也是使用了set方法

UserService:

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUserService(){

    }
}


<?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">
    
    <!--创建service对象-->
    <bean id="userService" class="com.springlearn.service.UserService">
		<property name="userDao" ref="userDaoImpl"></property>
	</bean>

    <!--创建dao对象-->
    <bean id="userDaoImpl" class="com.springlearn.dao.UserDaoImpl"></bean>

</beans>

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

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUserService(){
        userDao.addUser();

    }
}
3）注入内部bean
第一种：普通写法
  • 管理对象之间关系

（1）创建实体类

public class Emp {
    private String eno;
    private String ename;

    //表示所属部门
    private Dept dept;

    public String getEno() {
        return eno;
    }

    public void setEno(String eno) {
        this.eno = eno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "eno='" + eno + '\'' +
                ", ename='" + ename + '\'' +
                ", dept=" + dept +
                '}';
    }

    public void prints(){
        System.out.println(eno +"——"+ename+"——"+dept);
    }
}


public class Dept {
    private String dname;

    public String getDname() {
        return dname;
    }

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

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

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

name属性：实体类中属性的名称
ref属性：bean标签的id值

<?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="emp" class="com.springlearn.entity.Emp">
        <!--设置普通属性-->
        <property name="eno" value="123"></property>
        <property name="ename" value="jack"></property>

		<!--级联赋值-->
        <!--设置员工所属部门-->
        <property name="dept" ref="dept"></property>
    </bean>
    
    <bean id="dept" class="com.springlearn.entity.Dept">
		<property name="dname" value="技术部"></property>
	</bean>
</beans>

（3）测试类

public class TestSpring {

    @Test
    public void testEmp(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Emp emp = context.getBean("emp", Emp.class);
        emp.prints();
    }
}

结果：

在这里插入图片描述

第二种：将对象写在属性标签里面

只是xml文件不同，这种是将bean标签写在property标签里面，来设置对象的属性。

<?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="emp" class="com.springlearn.entity.Emp">
        <!--设置两个普通属性-->
        <property name="eno" value="rose"></property>
        <property name="ename" value="456"></property>
        
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.springlearn.entity.Dept">
                <property name="dname" value="设计部"></property>
            </bean>
        </property>
        
    </bean>
</beans>

结果：
在这里插入图片描述

第三种：级联赋值

注意： 需要生成级联赋值对象的get方法，因为要先得到对象之后才能赋值。

<?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="emp" class="com.springlearn.entity.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="eno" value="789"></property>
        <!--级联赋值-->
        <!--先创建对象-->
        <property name="dept" ref="dept"></property>
        <!--再注入属性-->
        <property name="dept.dname" value="宣传部"></property>
    </bean>
    <bean id="dept" class="com.springlearn.entity.Dept"></bean>
</beans>

结果：
在这里插入图片描述

4）注入集合

实体类：

  • 创建类，定义数组、list、map、set类型属性，生成对应set方法；
package com.springlearn.entity;

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

public class CollectionEntity {

    //数组类型
    private String[] arrs;

    //list
    private List<String> lists;

    //map
    private Map<String,String> maps;

    //set
    private Set<String> sets;

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public void setLists(List<String> lists) {
        this.lists = lists;
    }

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

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

    public void prints(){
        System.out.println(Arrays.toString(arrs));
        System.out.println(lists);
        System.out.println(maps);
        System.out.println(sets);
    }
}

xml文件：

  • 在spring配置文件进行配置；
<?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="collection" class="com.springlearn.entity.CollectionEntity">
        <!--注入数组-->
        <property name="arrs">
            <array>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </array>
        </property>

        <!--注入list-->
        <!--也可以使用array标签-->
        <property name="lists">
            <list>
                <value>好好</value>
                <value>学习</value>
            </list>
        </property>

        <!--注入set-->
        <property name="sets">
            <set>
                <value>天天</value>
                <value>向上</value>
            </set>
        </property>

        <!--注入map-->
        <!--使用key-ref属性 可以引入其他对象-->
        <property name="maps">
            <map>
                <entry key="yy" value="永远"></entry>
                <entry key="ds" value="的神"></entry>
            </map>
        </property>
    </bean>


</beans>

测试类：

package com.springlearn.test;

import com.springlearn.entity.CollectionEntity;
import com.springlearn.entity.Emp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    @Test
    public void testCollection(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        CollectionEntity collection = context.getBean("collection", CollectionEntity.class);
        collection.prints();
    }
}

结果：

在这里插入图片描述

三、FactoryBean

  • Spring有两种类型bean
  • 1：普通bean
  • 2：工厂bean（FactoryBean）

（1）区别：

1、普通bean：在配置文件中定义bean类型就是返回类型；

3、工厂bean：在配置文件定义bean类型可以和返回类型不同（也可以相同）；

（2）实现步骤

第一步：创建类，让这个类作为工厂bean，实现接口 FactoryBean

public class MyBean implements FactoryBean<Course> {

}

第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    @Override
    public boolean isSingleton() {
        return false;
    }
}

第三步：配置xml文件

<bean id="myBean" class="com.springlearn.factorybean.MyBean">
</bean>

第四步：编写测试类

@Test
public void test3() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("applicationContext.xml");
    Course course = context.getBean("myBean", Course.class);
    System.out.println(course);
}

感谢阅读哇~

cakeAndAle
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
Spring中BeanFactory与FactoryBean接口的区别详解
08-26
通过`ClassPathResource`加载XML配置文件，创建`XmlBeanFactory`实例，然后可以通过调用`getBean`方法获取Bean实例。 ```java BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml...
Spring注解驱动开发.pdf
08-22
- **`BeanPostProcessor`**：在bean实例化前后可以执行自定义操作，例如实现`@Autowired`注解的功能。 - **`BeanFactoryPostProcessor`**：在Spring IoC容器初始化过程中执行，可以修改bean定义。 ##### 2. `...
Spring管理实例bean
悦分享
08-21 240
Spring默认以单例形式管理bean 让spring管理管理HelloWorld的实例 Spring的配置文件 beans.xml 相当于new了一个类的对象，通过id来取类的对象 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/be...
六.Spring的Bean管理-实例化的方式详解
YvesHe的专栏
09-13 557
写在前面,Bean的实例化,也就产生Bean的对象.1.Spring 的 Bean 的管理 XML 的方式(三种)无参数的构造方法的方式 (主要使用) 注意，如果Bean没有无参构造方法,使用该方法会报错. User.javapackage cn.com.yves.spring; public class User { private String name; // 注意: 不写
IOC操作Bean管理(基于xml方式)
mogbox的博客
03-24 162
看尚硅谷老师视频记录的笔记 1.什么是IOC * 控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理 * 使用IOC的目的,为了降低耦合度 * 入门案列就是IOC 2.IOC底层原理 * xml机械 * 工厂模式 * 反射 3.目的:耦合度降低 1).原始方法让一个类调用一个类方法的时候是new对象调用其方法 2).工厂模式 :中间加个工厂类,作为中间人 3).IOC过程: 第一步:xml配置文件,配置创建的对象 第二步:有service类和dao类,创建工厂类 public User
xml文件对bean的管理操作，FactoryBean，Bean的生命周期，xml 自动装配，外部文件的引入,spring API（二）
qq_46199553的博客
07-23 219
IOC 操作 Bean 管理（xml 注入集合属性） 1、注入数组类型属性 2、注入 List 集合类型属性 3、注入 Map 集合类型属性 （1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法 package collection; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Set; public class Stu { public
IOC Bean管理
weixin_52875557的博客
10-06 389
1、什么是Bean管理，Bean管理指的是俩个操作： 1、Spring创建对象 2、Sping注入属性 Spring创建对象的方式在IOC概念和原理文章中有讲，下面讲讲Spring注入属性的方式。 Spring注入属性：假如有一个User类，里面有一个私有的成员变量 private String userName；按照以往的方式，我们要给userName设置属性值，需要用到set方法，而现在这个过程是交给Spring做到。这里属性的值可以是基本数据类型，也可以是对象。 2.Bean管理...
Spring5.x之XmlBeanFactory源码解析-XmlBeanFactory整体概览(一)
lemon
04-17 463
1、XmlBeanFactory继承类图 2、XmlBeanFactory继承树接口和类说明 AliasRegistrγ ： 定义对alias的简单增删改查等操作 SimpleAliasRegistry ： 使用map作为alias的缓存，并对接口AliasRegistry进行实现 BeanDefinitionRegistry ： 定义对 BeanDefinition 的各种增删改操作 ...
Spring --- IOC 容器 之 Bean管理XML方式（工厂bean ：FactoryBean）
yuanchenglong的博客
07-31 195
获取的类即是声明的类，但是当声明的类实现FactoryBean接口，即可使得调用方法获取不同的类。
xml配置文件中factory-bean与factory-method
IUNIQUE技术册
12-18 477
http://www.cnblogs.com/vickylinj/p/9474597.html
Spring学习（3）—— IOC容器-Bean管理（xml方式）FactoryBean
Archer__13的博客
04-17 250
普通的Bean：在配置文件中定义bean类型就是返回类型 FactoryBean：在配置文件中定义bean类型可以和返回类型不一样 package factory; import org.springframework.beans.factory.FactoryBean; import pojo.User; public class Person implements FactoryBean<User> { //定义返回的Bean @Override publ
最简单的Spring5入门教程（5）IOC 基于xml操作 Bean 管理（FactoryBean）
weixin_40965577的博客
06-17 208
Spring 有两种类型 bean 普通 bean：在配置文件中定义 bean 类型就是返回类型 工厂 bean（FactoryBean）：在配置文件定义 bean 类型可以和返回类型不一样 FactoryBean的作用主要是当不想把对象的实例交给Spring管理 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型 ...
FactoryBean在XML中的依赖注入方法
weixin_30561425的博客
04-01 212
最近在探索Quartz的定时任务以数据库方式进行存储获取，其中用到了Spring的MethodInvokingJobDetailFactoryBean。在注入MethodInvokingJobDetailFactoryBean的时候，发现总是出现异常参数的错误。 Caused by: java.lang.IllegalArgumentException: Cannot...
工厂方法与 FactoryBean（Spring对工厂模式的XML支持）
weixin_34090643的博客
12-21 179
工厂方法与 FactoryBean 引子 直接依赖接口实现类的类Foo： public class Foo { private BarInterface barInstance; public Foo() { // 我们应该避免这样做 // instance = new BarInterfaceImpl(); } // ... 复制代码使用了工厂方法模式的Foo类可...
Spring_IOC_day06(FactoryBean、xml自动装配)
weixin_51474578的博客
04-06 193
目录 FactoryBean bean-单和多实例 1-- ==在Spring里面，默认情况下，bean是单实例对象== 2--如何设置单实例和多实例 3-- singleton和prototype的区别 bean生命周期 1--生命周期的概念：从对象到对象销毁的过程。 2--bean生命周期：因为bean的后置处理器，bean生命周期有七步，3,4部可以忽略 演示添加后置处理器 xml自动装配 FactoryBean 1--Spring有两种类型bean，一...
Spring5总述（四）—— IOC操作Bean管理（FactoryBean，Bean的作用域，Bean的生命周期，Xml的自动装配）
mydesss的博客
03-31 1542
Spring5总述（四）—— IOC操作Bean管理 FactoryBean：不同的返回类型 Bean的作用域：五种 Bean的生命周期：有无后置处理器两种情况 Xml的自动装配方法
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cakeAndAle

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值