Spring5框架基础详解(二) IOC容器Bean管理XML方式(XML注入集合属性、工厂Bean、Bean作用域、Bean的生命周期、xml自动装配、外部属

大黄烽
126 阅读5分钟

本人已参与[新人创作礼]活动，一起开启掘金创作之路。

一、 IOC操作 Bean管理（XML注入集合属性）

	1.注入数组类型属性：
	2.注入List集合属性：
	3.注入Map集合属性：
	4.注入set集合属性： 
			*步骤1：  创建类，定义数组，list，map，set类型属性，生成对应set方法

package cn.hncj.collectiontype;

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

/**
 * Created on 2022/3/19.
 *
 * @author Hou chaof
 */
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 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;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}

//测试类
public class Demo {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        var stu = ctx.getBean("stu", Stu.class);
        stu.test();
    }
}

			*步骤2：在spring配置文件中进行配置
			

  <!--集合类型属性注入 -->
    <bean id="stu" class="cn.hncj.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>

在这里插入图片描述

二、 IOC操作 Bean管理（工厂Bean）

两种Bean(普通Bean和工厂Bean)

普通Bean：在spring的配置文件中，定义的bean类型就是返回类型。 工厂Bean：在配置文件中定义bean类型可以和返回的类型不一样。（工厂bean是spring中内置的bean类型）

步骤1.创建类，让这个类作为工厂bean，实现接口FactoryBean
步骤2.实现接口里的方法，在实现的方法中定义返回的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 FactoryBean.super.isSingleton();
    }
}




public class Course {
    private String  Cname;

    public void setCname(String cname) {
        Cname = cname;
    }

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



//测试类
public class Demo {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Course course = ctx.getBean("mybean", Course.class);
        System.out.println(course);
    }
}

<!-- applicationContext配置文件-->
  </bean>
    <bean id="mybean" class="cn.hncj.factorybean.MyBean">
    </bean>

在这里插入图片描述

三、 IOC操作 Bean管理（Bean的作用域）//面试重点//

bean作用域：在spring里，可以设置bean实例的单例模式还是多例模式，在默认情况下，bean是单实例对象。

bean标签里面有属性（scope）用于设置单实例还是多实例。
		*singleton 表示单实例：设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象。
		*prototype 表示多实例：设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，是在调用getBean方法时创建多例对象。
		*request：表示一次请求。
		*session：表示一次会话。

四.IOC操作Bean管理（Bean的生命周期）

4.1不加后置处理器：五步的Bean生命周期

生命周期:
		*1.从对象创建到对象销毁的过程
bean生命周期：
		*1.通过构造器创建bean实例（无参数构造）		
		*2. 为bean的属性设置值和对其他bean引用（调用set方法）
		*3.调用bean的初始化方法（需要进行配置初始化方法）
		*4.bean可以使用（对象获取到了）
		*5.当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）
		 

public class Orders {
    public Orders(){
        System.out.println("第一步：执行无参数构造创建bean实例");
    }
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步:调用set方法设置属性值");
    }
    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步： 执行初始化的方法");
    }
    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步：执行销毁的方法");
    }
}


//测试类
public class Demo {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Orders orders = ctx.getBean("orders", Orders.class);
        System.out.println("第四步:获取创建bean实例对象");
        //手动让bean实例销毁
        ((ClassPathXmlApplicationContext)ctx).close();
    }
}

  <bean id="orders" class="cn.hncj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>

在这里插入图片描述

4.2加后置处理器：bean生命周期有七步

		*1.通过构造器创建bean实例（无参数构造）		
		*2. 为bean的属性设置值和对其他bean引用（调用set方法）
		*3.把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
		*4.调用bean的初始化方法（需要进行配置初始化方法）
		*5.把bean实例传递bean后置处理器的方法postProcessAfterInitialization
		*6.bean可以使用（对象获取到了）
		*7.当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）
				*演示添加后置处理器效果
				(1) 创建类，实现接口BeanPostProcessor,创建后置处理器。
				


public class MyBeanPost 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;
    }
}






public class Orders {
    public Orders(){
        System.out.println("第一步：执行无参数构造创建bean实例");
    }
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步:调用set方法设置属性值");
    }
    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步： 执行初始化的方法");
    }
    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步：执行销毁的方法");
    }
}


//测试类
public class Demo {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Orders orders = ctx.getBean("orders", Orders.class);
        System.out.println("第四步:获取创建bean实例对象");
        //手动让bean实例销毁
        ((ClassPathXmlApplicationContext)ctx).close();
    }
}

<bean id="orders" class="cn.hncj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>
    <!--配置后置处理器-->
    <bean id="myBeanPost" class="cn.hncj.bean.MyBeanPost"></bean>

五.IOC操作Bean管理（xml自动装配）

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

public class Dept {
}




public class Emp {
    private Dept dept;

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

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

    public void test(){
        System.out.println(dept);
    }
}



public class Demo {
    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Emp emp = ctx.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

 <!--实现自动装配
        bean标签属性autowrire,配置自动装配
        autowire属性常用两个值:
            byName根据属性名称注入,注入值bean的id值和类属性名称一样
            byType根据属性类型注入
    -->
    <bean id="emp" class="cn.hncj.autowirte.Emp" autowire="byType">
    </bean>
    <bean id="dept" class="cn.hncj.autowirte.Dept">
    </bean>

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

第一种：直接配置数据库信息（不常用）
			*1.配置druid连接池
			
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property><!--驱动名称-->
    <property name="url" value="jdbc.mysql://localhost:3306/db"></property><!--数据库地址-->
    <property name="username" value="root"></property><!--连接数据库用户名-->
    <property name="password" value=""></property><!--连接数据库用户密码-->
</bean>
			*2.引入druid连接池maven依赖
		 <dependency>
        	<groupId>com.alibaba</groupId>
        	<artifactId>druid</artifactId>
        	<version>1.2.8</version>
    	</dependency>
第二种：引入外部属性文件配置数据库连接池（常用）
		*1.创建外部属性文件，jdbc.properties格式文件，写数据库信息
					jdbc.driverClass=com.mysql.jdbc.Driver
					jdbc.url=jdbc:mysql://localhost:3306/db
					jdbc.username=root
					jdbc.password=
		
		*2.把外部properties属性文件引入到spring配置文件中 
			*引入context名称空间

*引入context名称空间之前的xml头信息：

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

引入context名称空间之后的xml头信息：

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

	*3.在spring配置文件使用标签引入外部属性文件

 <!--引入外部属性文件 -->
 <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
 <!-- 配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}"></property><!--驱动名称-->
        <property name="url" value="${jdbc.url}"></property><!--数据库地址-->
        <property name="username" value="${jdbc.root}"></property><!--连接数据库用户名-->
        <property name="password" value="${jdbc.password}"></property><!--连接数据库用户密码-->
        </bean>

总结

Spring如同一个工厂，用于生产和管理Spring容器中的Bean。要使用这和工厂，需要开发者对Spring的配置文件进行配置。 IOC容器Bean管理XML方式：XML注入集合属性、工厂Bean、Bean的作用域、Bean的生命周期、xml自动装配、外部属性文件

avatar
文章
阅读
粉丝