IOC操作Bean管理（基于xml方式）

时间：2020-10-16 23:22:49 阅读：34 评论：0 收藏：0 [点我收藏+]

1.1.5 IOC操作Bean管理

什么是Bean管理

Bean管理指的是俩个操作

1）Spring创建对象

2）Spring注入属性
Bean管理操作有俩种方式

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

2）基于注解方式实现

IOC操作Bean管理（基于xml方式）

基于xml方式创建对象
```
<bean id="user" class="com.spring.User"></bean>
```
1)在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建。

2）在bean标签有很多属性，介绍常用的属性

*id属性：唯一标识

*class属性：类全路径

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

基于xml方式注入属性

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

? *第一种注入方式：使用set方法就行注入

? ①创建类，定义属性和对应的set方法

public class Book(){
    private String name;
    private String author;

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name=‘" + name + ‘\‘‘ +
                ", author=‘" + author + ‘\‘‘ +
                ‘}‘;
    }
}

? ②在Spring配置文件配置对象创建，配置属性注入

<bean id="book" class="com.spring.Book">
	<property name = "name" value="zhangsan"/>
	<property name = "author" value="itcoder"/>
</bean>

? *第二种注入方式：使用有参构造进行注入

? ①创建类：定义属性，创建属性对应有参构造方法

public class Orders {
    private String order;
    private String address;

    public Orders(String order, String address) {
        this.order = order;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "order=‘" + order + ‘\‘‘ +
                ", address=‘" + address + ‘\‘‘ +
                ‘}‘;
    }
}

? ②在Spring配置文件中进行配置

<bean id="orders" class="com.spring.springboot.mapper.Orders">
    <constructor-arg name="order" value="computer"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

? ③测试：

@SpringBootTest
class ApplicationTests {

    @Test
    public void OrdersTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println(orders);
        orders.toString();
    }

}

技术分享图片

p名称空间注入

1）使用p名称空间注入，可以简化基于xml配置方式

? *第一步：添加p名称空间在配置文件中

<?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‘标签里面进行操作

<bean id="orders" class="com.spring.springboot.mapper.Orders" p:order="food" p:address="China">
</bean>

IOC操作Bean管理（xml注入其他类型属性）

字面量

1）null值
```
<property name="address">
	<null/>
</property>
```
2）属性值包含特殊符号

<!--属性值包含特殊符号：
	1.把<>进行转义
	2.把带特殊符号内容写到CDATA
-->
<property name="address">
	<value><![CDATA[<<南京>>]]></value>
</property>

注入属性-外部bean

1）创建两个类service和dao

public interface UserDao {
    void update();
}

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

public class UserService {
    private UserDao userDao;

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

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

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

<bean id="userDao" class="com.spring.springboot.dao.impl.UserDaoImpl"></bean>

<bean id="userService" class="com.spring.springboot.service.UserService">
    <property name="userDao" ref="userDao"></property>
</bean>

注入属性-内部bean和级联赋值

1)一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门

2）在实体类之间表示一对多关系

public class Dept {
    private String dname;

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

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

package com.spring.springboot.bean;

public class Empt {
    private String ename;
    private String gender;

    private Dept dept;

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

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

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

    public void add(){
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}

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

<bean id="empt" class="com.spring.springboot.bean.Empt">
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <property name="dept">
        <bean id="dept" class="com.spring.springboot.bean.Dept">
            <property name="dname" value="保安部"></property>
        </bean>
    </property>
</bean>

注入属性-级联赋值

1）第一种写法

<bean id="empt" class="com.spring.springboot.bean.Empt">
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <property name="dept" ref="dept"></property>
</bean>

<bean id="dept" class="com.spring.springboot.bean.Dept">
    <property name="dname" value="保安部"></property>
</bean>

2）第二种写法

? ①生成dept的getter方法

public class Empt {
    private String ename;
    private String gender;

    private Dept dept;

    public Dept getDept() {
        return dept;
    }

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

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

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

    public void add(){
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}

? ②配置文件

<bean id="empt" class="com.spring.springboot.bean.Empt">
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部"></property>
</bean>

<bean id="dept" class="com.spring.springboot.bean.Dept">
    <property name="dname" value="保安部"></property>
</bean>

IOC操作Bean管理（xml注入集合属性）

注入数组类型属性
注入List集合类型属性

注入Map集合类型属性

1）创建类、定义数组、List、map、set类型属性，生成对应set方法

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

public class Stu {
    private String[] array;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> sets;

    public void setArray(String[] array) {
        this.array = array;
    }

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

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

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

    public void test(){
        System.out.println(Arrays.toString(array));
        System.out.println(list);
        System.out.println(map);
        System.out.println(sets);
    }
}

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

<bean id="stu" class="com.spring.spring_boot.controller.Stu">
    <property name="array">
        <array>
            <value>Java</value>
            <value>Python</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>zhangsan</value>
            <value>fawaikuangtu</value>
        </list>
    </property>

    <property name="map">
        <map>
            <entry value="zhangsan" key="18"></entry>
            <entry value="lisi" key="19"></entry>
        </map>
    </property>

    <property name="sets">
        <set>
            <value>Hello</value>
            <value>World</value>
        </set>
    </property>
</bean>

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

public class Course {
    private String cname;

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

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

private List<Course> courseList;

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

<bean id="stu" class="com.spring.spring_boot.controller.Stu">
    <property name="array">
        <array>
            <value>Java</value>
            <value>Python</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>zhangsan</value>
            <value>fawaikuangtu</value>
        </list>
    </property>

    <property name="map">
        <map>
            <entry value="zhangsan" key="18"></entry>
            <entry value="lisi" key="19"></entry>
        </map>
    </property>

    <property name="sets">
        <set>
            <value>Hello</value>
            <value>World</value>
        </set>
    </property>

    <property name="courseList">
        <list>
            <ref bean="courseOne"></ref>
            <ref bean="courseTwo"></ref>
        </list>
    </property>
</bean>

<bean id="courseOne" class="com.spring.spring_boot.controller.Course">
    <property name="cname" value="Math"></property>
</bean>

<bean id="courseTwo" class="com.spring.spring_boot.controller.Course">
    <property name="cname" value="English"></property>
</bean>

把集合注入部分提取出来

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
">

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

<util:list id="bookList">
    <value>Java</value>
    <value>c++</value>
    <value>Python</value>
</util:list>

<bean id="book" class="com.spring.spring_boot.controller.Book">
    <property name="name" ref="bookList"></property>
</bean>

IOC操作bean管理（FactoryBean）

Spring有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean）
普通bean：在配置文件中定义bean类型就是返回类型。

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

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

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

import com.spring.spring_boot.controller.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("lucy");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="mybean" class="com.spring.spring_boot.factorybean.MyBean">
</bean>

@Test
public void MyBeanTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
    Course course = context.getBean("mybean", Course.class);
    course.show();
}

IOC操作Bean管理（bean作用域）

在Spring里面，设置创建bean实例是单实例还是多实例
在Spring里面，默认情况下是单实例对象
如何设置单实例还是多实例

1）在spring配置文件bean标签里面中就有一个属性（scope）用于设置单实例还是多实例

2）scope属性值

第一个值：singleton，表示是单实例对象
```
<bean id="book" class="com.spring.spring_boot.controller.Book" scope="singleton">
    <property name="name" ref="bookList"></property>
</bean>
```
第二个值：prototype,表示是多实例对象
```
<bean id="book" class="com.spring.spring_boot.controller.Book" scope="prototype">
    <property name="name" ref="bookList"></property>
</bean>
```
3）singleton和prototype区别

第一：singleton单实例，prototype多实例

第二：设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象

? 设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象

IOC操作Bean管理（bean生命周期）

生命周期

1）从对象创建到对象销毁的过程
bean生命周期

1）通过构造器创建bean实例（无参构造）

2）为bean的属性设置值和对其他bean引用（调用set方法）

3）调用bean的初始化的方法（需要进行配置）

4）bean可有使用了（对象获取到了）

5）当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）
演示bean生命周期
bean的后置处理器：bean生命周期有七步

1）通过构造器创建bean实例（无参构造）

2）为bean的属性设置值和对其他bean引用（调用set方法）

3）把bean实例传递bean后置处理器的方法

4）调用bean的初始化的方法（需要进行配置）

5）把bean实例传递bean后置处理器的方法

6）bean可有使用了（对象获取到了）

7）当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）

演示添加后置处理器效果

package com.spring.spring_boot.bean;

public class Orders {
    public Orders() {
        System.out.println("第一步执行无参构造创建bean实例");
    }

    private String name;

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步调用set方法设置属性值");
    }

    public void initMethod(){
        System.out.println("第三步执行初始化的方法");
    }

    public void lastMethod(){
        System.out.println("第五步执行销毁方法");
    }
}

package com.spring.spring_boot.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

public class MyBean implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

<bean id="orders" class="com.spring.spring_boot.bean.Orders" init-method="initMethod" destroy-method="lastMethod">
    <property name="name" value="zhangsan"></property>
</bean>

<!--配置后置处理器-->
<bean id="myBean" class="com.spring.spring_boot.bean.MyBean"></bean>

@Test
public void Test01(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步，获取创建bean实例化对象");
    context.close();

}

技术分享图片

IOC操作bean管理（xml自动装配）

什么是自动装配

1）根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值注入

演示自动装配过程

autowire属性常用两个值

? byName根据属性名称注入，注入值bean的id值和类属性名称一样。

? byType根据属性类型注入

1）根据属性名称自动注入

public class Dept {
    private String name;

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

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

package com.spring.spring_boot.autowire;

public class Emp {
    private Dept dept;

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

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                ‘}‘;
    }
    public void show(){
        System.out.println(dept);
    }
}

<bean id="emp" class="com.spring.spring_boot.autowire.Emp" autowire="byName"></bean>

<bean id="dept" class="com.spring.spring_boot.autowire.Dept"></bean>

@Test
public void Test01(){
   ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
   Emp emp = context.getBean("emp", Emp.class);
   emp.show();
}

2）根据属性类型自动注入

<bean id="emp" class="com.spring.spring_boot.autowire.Emp" autowire="byType"></bean>

<bean id="dept" class="com.spring.spring_boot.autowire.Dept"></bean>

IOC操作Bean管理（外部属性文件）

直接配置数据库信息

1）配置连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSourceFactory">
   <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
   <property name="url" value="jdbc:mysql://localhost:3306//test"></property>
   <property name="username" value="root"></property>
   <property name="password" value="root"></property>
</bean>

2）引入连接池依赖

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.32</version>
</dependency>
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.1.10</version>
</dependency>

引入外部属性文件配置数据库连接池

1）创建外部属性文件：properties格式文件，写数据库信息

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username = root
jdbc.password = root

2）把外部properties属性文件引入到spring配置文件中

? *引入context命名空间

<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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">

? *在Spring配置文件中使用标签引入外部属性文件

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSourceFactory">
   <property name="driverClassName" value="${jdbc.driver}}"></property>
   <property name="url" value="${jdbc.url}}"></property>
   <property name="username" value="root"></property>
   <property name="password" value="root"></property>
</bean>

IOC操作Bean管理（基于xml方式）

原文：https://www.cnblogs.com/coderD/p/13828569.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)