IOC Bean管理

最新推荐文章于 2022-12-02 16:45:15 发布

今天你学习了ma

最新推荐文章于 2022-12-02 16:45:15 发布

阅读量382

点赞数 3

分类专栏： Spring5 IOC 文章标签： spring java ioc bean

本文链接：https://blog.csdn.net/weixin_52875557/article/details/120614307

版权

Spring5 同时被 2 个专栏收录

6 篇文章 1 订阅

订阅专栏

IOC

4 篇文章 0 订阅

订阅专栏

2.7、IOC 操作 Bean 管理（FactoryBean）

1、什么是Bean管理

Bean管理指的是俩个操作：

1、Spring创建对象

2、Sping注入属性

Spring创建对象的方式在IOC概念和原理文章中有讲，下面讲讲Spring注入属性的方式。

Spring注入属性：假如有一个User类，里面有一个私有的成员变量 private String userName；按照以往的方式，我们要给userName设置属性值，需要用到set方法，而现在这个过程是交给Spring做到。这里属性的值可以是基本数据类型，也可以是对象。

2、Bean管理实现方式

1、基于xml配置文件方式实现

2、基于注解方式实现

这里讲基于xml配置文件方式实现

1.基于xml方式创建对象

<bean id="名字" class="路径"></bean>

1.1在bean标签有很多属性，介绍常用属性：

id：唯一标识（用来传递给之后获取配置参数的对象里面参数）
class：类的全路径（包+类名）
name：和id类似，但是name标签里面可以加特殊符号

1.2.xml创建对象时候，默认执行是无参构造方法

若在类中加一个有参构造方法

package com.company;

public class User {
    private String userName;

    public User(String userName) {         //这里加一个有参构造
        this.userName = userName;
    }

    public void add(){
        System.out.println("dddd");
    }

}

运行结果或报错找不到方法。因为加了有参构造方法，会默认执行有参构造，覆盖无参构造

2.基于xml配置文件方式注入属性

DI：是ioc一种具体实现，表示依赖注入，就是注入属性 //面试可能会问

2.1、使用set方式注入属性

1.创建类，定义属性和set方法（以book类为例子）

package com.company;

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 void show(){    
        System.out.println(bname+"--"+bauthor);
    }
}

2.在Spring配置文件配置对象的创建，配置属性的注入

    //set方法注入属性
<bean id="book" class="com.company.Book">
        <property name="bname" value="Spring5"></property>
        <property name="bauthor" value="zwz"></property>
    </bean>

name: 类属性的名称

value：向属性注入的值

3.写测试类测试数据

package com.company;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Spring5Test {
    @Test
    public  void testBook1(){

        //加载spring配置文件
        ApplicationContext context =new ClassPathXmlApplicationContext("bean1.xml");

        //获取配置创建的对象
        Book book=context.getBean("book",Book.class);

        book.show();
    }

}

结果

2.2、通过有参构造注入属性

1.创建一个有参构造类（以Orders类为例）

package com.company;

public class Orders {
    private String oname;
    private  String adders;
    //创建有参构造
    public Orders(String oname, String adders) {
        this.oname = oname;
        this.adders = adders;
    }

}

2.在Spring配置文件配置对象的创建，配置属性的注入

正确做法如下：

//有参构造配置对象和注入属性
    <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="air娃娃"></constructor-arg>
        <constructor-arg name="adders" value="China"></constructor-arg>
    </bean>

3.测试类

package com.company;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Spring5Test {
    @Test
    public  void testBook1(){

        //加载spring配置文件
        ApplicationContext context =new ClassPathXmlApplicationContext("bean1.xml");

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

        orders.show();
    }

}

结果

2.3、xml注入其它类型数据

1.null值

在标签里面再套一个null标签

    <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="air娃娃"></constructor-arg>
        <constructor-arg name="adders" >
            <null></null>  //将地址的值设置为null
        </constructor-arg>
    </bean>

2.属性包含特殊符号

假如标签里面含有<>尖括号，编译时会被系统认定为标签的尖括号，报错。而我们需要将特殊符号转译处理。处理方式。用到xml CDATA结构

通用方式将value标签单独写出来，并且内容写在 <![CDATA[“内容”]]>

    <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="air娃娃"></constructor-arg>
        <constructor-arg name="adders">
            <value>
                <![CDATA[<<China>>]]>
            </value>
        </constructor-arg>
    </bean>

运行结果

2.4、注入属性-外部bean

1.创建一个service类和一个dao接口，并且写一个接口的实现类。

按照以往的方式，如果我们想在service内中调用service中update方法，我们需要现在service中new service的实现类，再调用对象。

现在我们把这个过程通过spring配置文件配置实现

具体做法：

1.在service中将userDao作为属性（上文有说道，属性值可以为常数据类型，也可以是对象），后生成set方法

2.在xml创建对象，和注入属性

注意：如果属性是对象，则应该要用ref注入外部bean、不能用value

3.测试代码

结果：调用输出成功！

2.5、注入属性-内部bean和级联复制

数据库表与表之间的关系有一对多，一对一，多对多

下面以一对多为例：

部门是一，员工是多。我们用这个关系在实体内之间中表示一对多的关系

package com.company;
//部门类
public class dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}




package com.company;
//员工类
public class Emp {
    private String ename;
    private String gender;
    private Dept dept;

    public Emp(Dept dept) {
        this.dept = dept;
    }

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

2.在 spring 配置文件中进行配置

<bean id="emp" class="bean.Emp">
 <!--设置两个普通属性-->
 <property name="ename" value="lucy"></property>
 <property name="gender" value="女"></property>
 <!--设置对象类型属性-->
 <property name="dept">
 <bean id="dept" class="bean.Dept">
 <property name="dname" value="安保部"></property>
 </bean>
 </property>
</bean>

另外一种方法。级联赋值

<!--级联赋值-->
<bean id="emp" class="spring5.bean.Emp">
 <!--设置两个普通属性-->
 <property name="ename" value="lucy"></property>
 <property name="gender" value="女"></property>
 <!--级联赋值-->
 <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="spring5.bean.Dept">
 <property name="dname" value="财务部"></property>
</bean>

2.6、xml注入集合类型属性

1、注入数组类型属性

2、注入 List 集合类型属性

3、注入 Map 集合类型属性

（1）创建类，定义数组、list、map、set 类型属性，并且生成对应 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 配置文件进行配置

<!--1 集合类型属性注入-->
<bean id="stu" class="spring5.collectiontype.Stu">
 <!--数组类型属性注入-->
 <property name="courses">
 <array>
 <value>java 课程</value>
 <value>数据库课程</value>
 </array>
 </property>
 <!--list 类型属性注入-->
 <property name="list">
 <list>
 <value>张三</value>
 <value>小三</value>
 </list>
 </property>
 <!--map 类型属性注入-->
 <property name="maps">
 <map>
 <entry key="JAVA" value="java"></entry>
 <entry key="PHP" value="php"></entry>
 </map>
 </property>
 <!--set 类型属性注入-->
 <property name="sets">
 <set>
 <value>MySQL</value>
 <value>Redis</value>
 </set>
 </property>
</bean>

要注入数组类型的值，肯定是多个值，不能用value。此时应该加的是数组类型的标签，list、array都是可以的。里面再加多个value标签，设置它的值。其它什么类型的集合就用什么标签。里面也还是加的value。除了map里面是key、value结构。用这个结构：<entry key="键" value="值"></entry>

4、在集合里面设置对象类型值

上面，集合里面放的都是String类型数据，下面我们把集合里面放对象

建立课程类

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

再stu中加入以Course对象属性和相应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;
//学生所学多门课程
 private List<Course> 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;
 }
}

先创建多个course对象，并且注入对象里面的属性。再把对象理解成value，不过这里不是用的value标签，而是用的是<ref bean="对象值"></ref>。最后再把这俩对象，注入到courseList中。

<!--创建多个 course 对象-->
<bean id="course1" class="spring5.collectiontype.Course">
 <property name="cname" value="Spring5 框架"></property>
</bean>
<bean id="course2" class="spring5.collectiontype.Course">
 <property name="cname" value="MyBatis 框架"></property>
</bean>
<!--注入 list 集合类型，值是对象-->
<property name="courseList">
 <list>
 <ref bean="course1"></ref>
 <ref bean="course2"></ref>
 </list>
</property>

5、把集合注入部分提取出来

（1）在 spring 配置文件中引入名称空间 util

把这句话复制一份xmlns:p="http://www.springframework.org/schema/p"

改成 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

再把这句话的bean全部改成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:p="http://www.springframework.org/schema/p"
 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">

（2）使用 util 标签完成 list 集合注入提取

<!--1 提取 list 集合类型属性注入-->
<util:list id="bookList">
 <value>math</value>
 <value>陆羽</value>
 <value>技术</value>
</util:list>
<!--2 提取 list 集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
 <property name="list" ref="bookList"></property>
</bean>

2.7、IOC 操作 Bean 管理（FactoryBean）

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

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

3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

普通bean比如：

 <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="air娃娃"></constructor-arg>
        <constructor-arg name="adders">
            <value>
                <![CDATA[<<China>>]]>
            </value>
        </constructor-arg>
    </bean>

我这里定义的bean类型是Orders类型，则返回bean实例就是Orders类型。上面例子创建的都是普通bean。

工厂bean：工厂配置文件定义bean类型可以和返回的类型可以是不一样的，这是和普通bean的区别。

工厂bean做法：

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

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

1.创建类，实现FactoryBean接口，里面三个方法都实现

第一个方法就是返回值类型，方法后面接泛型，里面的泛型以Course对象为例，则它返回的就是course对象

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;
 }
}

2.xml配置文件

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

3.测试代码

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

4.运行结果

由此可见，在配置文件中配置的返回类型是MyBean和得到的类型不一样，这个类型就在FactoryBean的getObject()方法中定义。

今天你学习了ma

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
IOC Bean管理

1、什么是Bean管理，Bean管理指的是俩个操作：1、Spring创建对象2、Sping注入属性Spring创建对象的方式在IOC概念和原理文章中有讲，下面讲讲Spring注入属性的方式。Spring注入属性：假如有一个User类，里面有一个私有的成员变量 private String userName；按照以往的方式，我们要给userName设置属性值，需要用到set方法，而现在这个过程是交给Spring做到。这里属性的值可以是基本数据类型，也可以是对象。2.Bean管理...
复制链接

扫一扫