Spring——IoC核心(基于XML)、DI核心(基于XML)、FactoryBean、Bean的生命周期

阳光穿透心脏的1/2处 2023-07-09 06:30 32阅读 0赞

## 目录 ##

*  一、IoC容器
    
     *  1、BeanFactory和ApplicationContext两者的区别 (`重点`)
     *  2、Bean实例化的四种方式
        
         *  2.1、使用构造器实例化(无参构造器)
         *  2.2、静态工厂方法实例化(了解)
         *  2.3、实例工厂方法实例化(了解))
         *  2.4、实现FactoryBean接口实例化 (`重点`)
     *  3、Bean作用域
     *  4、Bean的初始化和销毁
     *  5、Bean的实例化过程
 *  二、DI操作
    
     *  1、什么是注入操作?
     *  2、XML自动装配(不推荐)
     *  3、Setter方法注入(重点)
        
         *  3.1、注入常量
         *  3.2、注入对象
         *  3.3、注入集合
     *  4、构造器注入
     *  5、Bean元素继承
     *  6、属性占位符

![在这里插入图片描述][20200228110227367.png]

> Spring系列
> 
> 1.  [Spring — Spring简介、入门、配置 , IoC和DI思想][Spring _ Spring_ _ IoC_DI]
> 2.  [Spring — IoC核心(基于XML)、DI核心(基于XML)][Spring _ IoC_XML_DI_XML]
> 3.  [Spring — 使用IoC和DI模拟注册案例、注解配置IoC和DI][Spring _ _IoC_DI_IoC_DI]
> 4.  [Spring — 静态代理、动态代理、拦截器思想][Spring _]
> 5.  [Spring — AOP思想、AOP开发、Pointcut语法、注解配置AOP][Spring _ AOP_AOP_Pointcut_AOP]
> 6.  [Spring — DAO层、Spring JDBC、Spring事务控制][Spring _ DAO_Spring JDBC_Spring]
> 7.  [Spring — XML配置事务、注解+XML、纯注解的配置方式][Spring _ XML_XML]
> 8.  [Spring整合MyBatis][Spring_MyBatis]
> 9.  [Spring Java Config — 组件注册相关注解][Spring Java Config _]
> 10. [Spring Java Config — 常用注解][Spring Java Config _ 1]

--------------------

# 一、IoC容器 #

跳转到目录  
在上一篇文章中已经介绍过了IoC的思想,这里不再赘述!

**Spring IoC容器 (Container):**

*  **BeanFactory**: Spring最底层的接口, 只提供了IoC的功能, 负责创建、组装、管理bean,所以一般不适用BeanFactory, 推荐使用ApplicationContext(应用上下文)
 *  **ApplicationContext** : `ApplicationContext接口继承了BeanFactory`, 还提供了AOP继承、国际化处理、事件传播、统一资源价值等功能; 可以查看该接口的继承体系;

### 1、BeanFactory和ApplicationContext两者的区别 ###

跳转到目录  
**bean的创建时机不同:**

*  BeanFactory有`延迟初始化(懒加载)`的特点,在创建Spring容器的时候,**不会立刻去创建容器,管理Bean对象,而是要等到从容器中获取对象的时候,才去创建对象.**
 *  ApplicationContext在创建Spring容器的时候,**会把容器中管理的Bean立刻初始化**,而不会等到获取Bean的时候才初始化.

// Person
    @Data
    public class Person { 
        private String name;
        private int age;
    
        public Person(){ 
            System.out.println("Person对象创建啦!");
        }
    }
    
    // person.xml
    
    <bean id="person" class="com.sunny.domain.Person">
        <property name="name" value="CoderZYGui"/>
        <property name="age" value="23"/>
    </bean>
    
    // PersonTest(非Spring Test)
    public class PersonTest { 
    
        // 使用BeanFactory创建Spring IoC容器
        /** * -------------------------------- * Person对象创建啦! * Person(name=CoderZYGui, age=23) * * 结论: BeanFactory有延迟初始化(懒加载)的特点,在创建Spring容器的时候,不会立刻去创建容器, * 管理Bean对象,而是要等到从容器中获取对象的时候,才去创建对象. */
        @Test
        public void test1(){ 
            Resource resource = new ClassPathResource("xmls/person.xml");
            BeanFactory factory = new XmlBeanFactory(resource);
            System.out.println("--------------------------------");
            Person person = factory.getBean("person", Person.class);
            System.out.println(person);
        }
    
        // 使用ApplicationContext创建Spring IoC容器
        /** * Person对象创建啦! * -------------------------------- * Person(name=CoderZYGui, age=23) * * 结论: 在创建Spring容器的时候,会把容器中管理的Bean立刻初始化,而不会等到获取Bean的时候才初始化. */
        @Test
        public void test2(){ 
            ApplicationContext ctx = new ClassPathXmlApplicationContext("xmls/person.xml");
            System.out.println("--------------------------------");
            Person person = ctx.getBean("person", Person.class);
            System.out.println(person);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]

### 2、Bean实例化的四种方式 ###

跳转到目录

*  构造器实例化(无参构造器),使用最多
 *  静态工厂方法实例化(了解)
 *  实例工厂方法实例化(了解)
 *  **实现FactoryBean接口实例化:实例工厂的变种**

##### 2.1、使用构造器实例化(无参构造器) #####

跳转到目录

// 类
    public class Cat1 { 
        public Cat1(){ 
            System.out.println("构建Cat1");
        }
    }
    
    // createBean.xml
    
    <bean id="cat1" class="com.sunny.createbean._01_constructor.Cat1"/>

##### 2.2、静态工厂方法实例化(了解) #####

跳转到目录

// 类
    public class Cat2 { 
    }
    // Cat2工厂
    public class Cat2Factory { 
        public static Cat2 createInstance(){ 
            Cat2 cat2 = new Cat2();
            return cat2;
        }
    }
    
    // createBean.xml
    
    <bean id="cat2" class="com.sunny.createbean._02_static_factory.Cat2Factory"
            factory-method="createInstance"/>

##### 2.3、实例工厂方法实例化(了解) #####

跳转到目录

// 类
    public class Cat3 { 
    }
    // Cat3工厂
    public class Cat3Factory { 
    
        public Cat3 createInstance(){ 
            Cat3 cat3 = new Cat3();
            return cat3;
        }
    }
    
    // createBean.xml
    
    <bean id="cat3Factory" class="com.sunny.createbean._03_instance_factory.Cat3Factory"/>
    <bean id="cat3" factory-bean="cat3Factory" factory-method="createInstance"/>

##### 2.4、实现FactoryBean接口实例化 #####

跳转到目录

// 类
    public class Cat4 { 
    }
    // Cat4工厂
    public class Cat4Factory implements FactoryBean<Cat4> { 
        private String name;
        
        public void setName(String name) { 
            this.name = name;
        }
    
        // 实例工厂的方法(对比方式三,这种方式固定了工厂实例方法)
        public Cat4 getObject() throws Exception { 
            System.out.println("name=:" + name);
            Cat4 cat4 = new Cat4();
            return cat4;
        }
    
        public Class<?> getObjectType() { 
            return Cat4.class;
        }
    }
    
    // createBean.xml
    
    <bean id="cat4" class="com.sunny.createbean._04_factory_bean.Cat4Factory">
        <property name="name" value="猫猫4"/>
    </bean>

#### 测试 ####

Spring Test(基于Junit4)

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringJunit4 { 
    
        // @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
        // ------- 4种Bean实例化的方式---------
        @Autowired
        private Cat1 cat1;
        @Autowired
        private Cat2 cat2;
        @Autowired
        private Cat3 cat3;
        @Autowired
        private Cat4 cat4;
    
        // 不使用Spring容器的时候,使用这4种方式的实例化步骤
        @Test
        public void testOld() throws Exception { 
            // 使用构造器_实例化bean
            Cat1 cat1 = new Cat1();
            // 使用静态工厂方法_实例化bean
            Cat2 cat2 = Cat2Factory.createInstance();
            // 使用实例工厂方法_实例化bean
            Cat3 cat3 = new Cat3Factory().createInstance();
            // 实现FactoryBean接口实例化_实例化bean
            Cat4 cat4 = new Cat4Factory().getObject();
        }
        @Test
        public void test2(){ 
            System.out.println(cat1);
            System.out.println(cat2);
            System.out.println(cat3);
            System.out.println(cat4);
        }
    }

### 3、Bean作用域 ###

跳转到目录  
在Spring容器中是指其创建的`Bean对象`相对于其他Bean对象的请求可见范围,语法格式:

*  `singleton`: 单例, 在Spring IoC容器中仅存在一个Bean实例(默认缺省就是singleton)
 *  `prototype`: 多例, 每次从容器中调用Bean时,都返回一个新的实例,每次调用getBean()时,相当于执行 new XxxBean(), 不会在容器启动时创建对象.

单例: 缺省是singleton,从容器中拿到的对象都是同一个对象
    多例: prototype, 从容器拿到的对象不是同一个对象

![在这里插入图片描述][2021042321023032.png]

其他的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]

// 类
    public class Dog { 
    }
    
    // Dog.xml
    
    <bean id="dog" class="com.sunny.scope.Dog" scope="singleton"/>
    
    // Spring Test
    // ----------bean的scope范围-----------------
    // 表示从容器中拿到实例化的dog对象
    @Autowired
    private Dog dog1;
    @Autowired
    private Dog dog2;
    
    @Test
    public void test3(){ 
        // 因为bean的scope默认就是singleton,所以容器生成的Dog对象就是同一个
        System.out.println(dog1);
        System.out.println(dog2);
    }

![在这里插入图片描述][20200228124520498.png]

### 4、Bean的初始化和销毁 ###

跳转到目录

*  **比如DataSource、SqlSessionFactory 最终都需要关闭资源; 在Bean销毁之前都要调用close方法**, 而在Spring IoC容器中可以帮我们管理对象的创建, 如何帮我们管理对象在创建之后的初始化操作和回收资源的操作呢,语法如下:

*  **init-method**: 调用对象的初始化方法,在对象初始化执行之前,立刻执行
 *  **destroy-method**: 调用对象的销毁方法,在对象销毁执行之前,调用

#### **使用Spring IoC容器时的操作** ####

**测试使用的是Spring Test**

MyDataSource类

/** * 模拟数据库连接池 * 当使用连接池的时候,都需要初始化和销毁,使用Spring IoC容器后,如何 * 让容器帮助我们进行初始化和销毁呢? */
    public class MyDataSource { 
    
        public MyDataSource(){ 
            System.out.println("创建对象...");
        }
    
        public void open(){ 
            System.out.println("开启资源...");
        }
    
        public void close(){ 
            System.out.println("销毁资源...");
        }
    
        public void doWork(){ 
            System.out.println("工作...");
        }
    }
    
    // mydatasource.xml
    
    <bean id="ds" class="com.sunny.lifecycle.MyDataSource" init-method="open"
        destroy-method="close"/>
    
    //Spring Test测试
    // ------bean的初始化和销毁--------
    // 没有使用Spring容器的操作
    @Test
    public void testOld1(){ 
        // 创建对象
        MyDataSource ds = new MyDataSource();
        System.out.println("-------");
        // 初始化操作
        ds.open();
        // 工作
        ds.doWork();
        // 销毁
        ds.close();
    }
    
    // 使用Spring容器的方式
    @Autowired
    private MyDataSource ds;
    
    @Test
    public void test4(){ 
        ds.doWork();
    }

**使用普通的测试方法**  
在这里没有打印出销毁资源,这就是 **普通测试和Spring测试的区别;**

*  Spring的测试会正常释放资源
 *  普通的单元测试不会正常释放资源,这时就需要手动来释放资源了

xml文件和类同上.

public class MyDataSourceTest { 
        /** * 在这里没有打印出销毁资源,这就是普通测试和Spring测试的区别; * Spring测试会正常释放资源 * 普通的单元测试不会正常释放资源,这时就需要手动来释放资源了 */
        @Test
        public void test(){ 
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("xmls/mydatasource.xml");
            MyDataSource ds = ctx.getBean("ds", MyDataSource.class);
            ds.doWork();
            ds.close(); // 手动释放资源
        }
    
        @Test
        public void test1(){ 
            @Cleanup //使用第三方框架lombok中的Clearup注解来释放.
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("xmls/mydatasource.xml");
            MyDataSource ds = ctx.getBean("ds", MyDataSource.class);
            ds.doWork();
        }
    
        @Test
        public void test2(){ 
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("xmls/mydatasource.xml");
            MyDataSource ds = ctx.getBean("ds", MyDataSource.class);
            ds.doWork();
            // 这种方式是将Spring线程作为JVM的子线程,当JVM关闭后,该Spring线程也会被关闭
            ctx.registerShutdownHook();
        }
    }

### 5、Bean的实例化过程 ###

跳转到目录  
bean的声明周期: bean从出生–>销毁的整个过程

1、启动Spring容器  
2、创建Bean对象 ----> 实际是在调用Bean对象的构造器  
3、给Bean添加属性  
4、调用Bean对象的初始化init-method  
5、getBean获取某个bean对象,调用bean对象的某一个方法  
6、调用Bean对象的销毁方法destory-method  
7、Spring容器销毁

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]

--------------------

### 后置处理 Bean : BeanPostProcessor ###

*  BeanPostProcessor 作用：对 Spring 工厂所创建的对象，进行再加工。（AOP 的底层实现）
 *  后置处理 Bean 原理分析
 *  程序员实现 BeanPostProcessor 接口中规定的两个方法：

public Object postProcessBeforeInitialization(Object bean, String beanName) { 
        return bean;
    }

作用：**Spring 创建完对象，并进行注入后，可以运行 Before ⽅法进行加工；**

通过方法的参数获得 Spring 创建好的对象，最终通过返回值交给 Spring 框架。

public Object postProcessAfterInitialization(Object bean, String beanName) { 
        return bean;
    }

作⽤：Spring 执行完对象的初始化操作后，可以运行 After ⽅法进行加工；

通过方法的参数获得 Spring 创建好的对象，最终通过返回值交给 Spring 框架。  
实战中：很少处理 Spring 的初始化操作，没有必要区分 Before，After。只需要实现其中一个，建议是 After 方法即可。

BeanPostProcessor 开发步骤  
类实现 BeanPostProcessor 接口

// 在初始化方法之前和之后执行下面两个方法
    public class MyBeanPostProcessor implements BeanPostProcessor { 
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
            return null;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
            Category category = (Category) bean;
            category.setName("yusael");
            return category;
        }
    
    }

Spring 配置文件中进行配置

*  `<bean id="myBeanPostProcessor" class="com.yusael.beanpost.MyBeanPostProcessor"/>`
 *  细节：BeanPostProcessor 会对 Spring 工厂创建的所有对象进行加工。如果工厂创建了多个不同的对象，要注意区别传入的对象：

@Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
        if (bean instanceof  Category) { 
            Category category = (Category) bean;
            category.setName("yusael");
            return category;
        }
        return bean;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]

# 二、DI操作 #

跳转到目录

### 1、 什么是注入操作? ###

跳转到目录  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]  
**注入的方式:**

*  **setter方法注入** (实际调用的对象的Setter方法)
 *  构造器注入

**注入值类型:**

*  常量值(简单类型) ----- `value 元素`
 *  对象 ----- `ref元素`
 *  集合 ----- `对象集合类型元素`

### 2、XML自动装配(不推荐) ###

跳转到目录

*  设置`<bean/>`元素的: `autowire`属性
    
        <bean id="person2" class="Person的全限定名" autowire="byName"/>
 *  autowire属性: 让Spring按照一定的规则方式自己去找合适的对象,并完成DI注入操作.  
    ![在这里插入图片描述][2020022822054941.png]  
    **注意:**
    
     *  如果按照`byName`自动注入,要求所有的属性名字和id的名字必须保证一种规范的命名
     *  如果按照`byType`注入,如果Spring容器中同一个类型有多个实例,报 bean不是唯一类型错误;

// 需求: 让Spring帮我们创建Person对象,而Person对象还需要依赖Dog对象;所以需要创建两个Bean
    public class Person { 
        private Dog dog;
    
        public void setDog(Dog dog){ 
            this.dog = dog;
        }
        @Override
        public String toString() { 
            return "Person{" + "dog=" + dog + '}';
        }
    }
    
    // .xml
    <bean id="dog1" class="com.sunny._01_xml_autowired.Dog"/>
    <bean id="person2" class="com.sunny._01_xml_autowired.Person" autowire="byName"/>
    
    // Spring Test测试
    // @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
    @Autowired
    private Person person;
    
    @Test
    public void test(){ 
        System.out.println(person);
    }

### 3、Setter方法注入(重点) ###

跳转到目录  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][20200228221620480.png]

#### 3.1、注入常量 ####

跳转到目录  
注入常量值,也称之为`注入简单类型` :

// 类
    @Setter
    @ToString
    public class Employee { 
        private String name;
        private Integer age;
        private BigDecimal salary;
    }

#### 3.2、注入对象 ####

跳转到目录  
注入对象,就是把一个对象,通过setter方法设置给另一个对象:

// 类
    public class Cat { 
    }
    public class Person { 
        private Cat c1;
        public void setC1(Cat c1) { 
            this.c1 = c1;
        }
        @Override
        public String toString() { 
            return "Person1{" +
                    "c1=" + c1 +
                    '}';
        }
    }

#### 3.3、注入集合 ####

跳转到目录  
注入集合,就是把一个集合类型的数据,通过setter方法设置给另一个对象:

// 类
    @Setter
    public class CollectionBean { 
        private Set<String> set;
        private List<String> list;
        private String[] array;
        private Map<String, String> map;
        private Properties prop;
    
        @Override
        public String toString() { 
            return "CollectionBean{" +
                    "\nset=" + set +
                    ", \nlist=" + list +
                    ", \narray=" + Arrays.toString(array) +
                    ", \nmap=" + map +
                    ", \nprop=" + prop +
                    '}';
        }
    }

--------------------

**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">
    
        
        <bean id="employee" class="com.sunny._02_di_setter.Employee">
            <property name="name" value="coder"/>
            <property name="age" value="23"/>
            <property name="salary" value="188.00"/>
        </bean>
    
        
        <bean id="cat" class="com.sunny._02_di_setter.Cat"/>
        <bean id="person" class="com.sunny._02_di_setter.Person">
            <property name="c1" ref="cat"/>
        </bean>
    
        
        <bean id="collectionBean" class="com.sunny._02_di_setter.CollectionBean">
            
            <property name="set">
                <set>
                    <value>set1</value>
                    <value>set2</value>
                </set>
            </property>
            
            <property name="list">
                <list>
                    <value>list1</value>
                    <value>list2</value>
                </list>
            </property>
            
            <property name="array">
                <array>
                    <value>array1</value>
                    <value>array2</value>
                </array>
            </property>
            
            <property name="map">
                <map>
                    <entry key="key1" value="value1"/>
                    <entry key="key2" value="value2"/>
                </map>
            </property>
            
            
            <property name="prop">
                <value>
                    k1=v1
                    k2=v2
                    k3=v3
                </value>
            </property>
        </bean>
    </beans>

![在这里插入图片描述][2020022822325943.png]  
**测试类**

@RunWith(SpringJUnit4ClassRunner.class)
    // 相当于将加载了applicationContext.xml文件, 所以可以使用@Autowired自动注入成功
    @ContextConfiguration("classpath:applicationContext.xml")
    public class DiSetterTest { 
        // @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
        @Autowired
        private Employee employee;
        @Autowired
        private Person person;
        @Autowired
        private CollectionBean cb;
    
        @Test
        public void test1(){ 
            System.out.println(employee);
            System.out.println(person);
            System.out.println(cb);
        }
    }

**输出**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]

### 4、构造器注入 ###

跳转到目录

*  setter方式注入使用 `<property /> 元素`
 *  构造器方式注入使用 `<constructor-arg/>元素`  
    ![在这里插入图片描述][20200228223604729.png]  
    Java类

// 注入常量的类
    @ToString
    @AllArgsConstructor
    public class Employee1 { 
        private String name;
        private Integer age;
        private BigDecimal salary;
    }
    // 注入对象的类
    public class Cat1 { 
    }
    public class Person1 { 
        private Cat1 c1;
            public Person1(Cat1 c1) { 
            this.c1 = c1;
        }
        @Override
        public String toString() { 
            return "Person1{" +
                    "c1=" + c1 +
                    '}';
        }
    }
    // 注入集合类型的类
    @AllArgsConstructor //生成全参数构造器
    @ToString
    public class CollectionBean1 { 
        private Set<String> set;
        private List<String> list;
        private String[] array;
        private Map<String, String> map;
        private Properties prop;
    }

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">
    
        
        <bean id="employee1" class="com.sunny._03_di_constructor.Employee1">
            <constructor-arg name="name" value="zygui"/>
            <constructor-arg name="age" value="23"/>
            
            <constructor-arg name="salary">
                <null/>
            </constructor-arg>
        </bean>
    
        
        <bean id="cat1" class="com.sunny._03_di_constructor.Cat1"/>
        <bean id="perosn1" class="com.sunny._03_di_constructor.Person1">
            <constructor-arg name="c1" ref="cat1"/>
        </bean>
    
        
        <bean id="collectionBean1" class="com.sunny._03_di_constructor.CollectionBean1">
            
            <constructor-arg name="set">
                <set>
                    <value>set1</value>
                    <value>set2</value>
                </set>
            </constructor-arg>
            
            <constructor-arg name="list">
                <list>
                    <value>list1</value>
                    <value>list2</value>
                </list>
            </constructor-arg>
            
            <constructor-arg name="array">
                <array>
                    <value>array1</value>
                    <value>array2</value>
                </array>
            </constructor-arg>
            
            <constructor-arg name="map">
                <map>
                    <entry key="key1" value="value1"/>
                    <entry key="key2" value="value2"/>
                </map>
            </constructor-arg>
            
            <constructor-arg name="prop">
                <value>
                    k1=v1
                    k2=v2
                    k3=v3
                </value>
            </constructor-arg>
        </bean>
    </beans>

测试类

// @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
        @Autowired
        private Employee1 emp;
        @Autowired
        private Person1 p1;
        @Autowired
        private CollectionBean1 cb1;
    
        @Test
        public void test1(){ 
            System.out.println(emp);
            System.out.println(p1);
            System.out.println(cb1);
        }

### 5、Bean元素继承 ###

跳转到目录  
多个bean元素共同配置的抽取,实则是bean配置的拷贝,和Java的继承不同

*  Java继承: 把多个类共同的代码抽取到父类中
 *  bean元素的继承: 把多个bean元素`共同的属性配置`抽取到另一个公用的bean元素中

Java类

@Setter
    @ToString
    public class SomeBean1 { 
        private String name;
        private Integer age;
        private Double weight;
    }
    
    @Setter
    @ToString
    public class SomeBean2 { 
        private String name;
        private Integer age;
        private Double height;
    }

xml配置

### 6、属性占位符 ###

跳转到目录  
举一个查询数据库的例子:

*  表结构

CREATE TABLE `student` (
      `id` bigint(20) NOT NULL,
      `name` varchar(40) NOT NULL,
      `age` int(11) NOT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

![在这里插入图片描述][20200228230251750.png]

###### 1、原始版本 ######

*  查询数据库信息的测试方法

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class PropertyPlaceholderTest { 
        private DruidDataSource ds;
    
        @Test
        public void test() throws Exception{ 
            ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring");
            ds.setUsername("root");
            ds.setPassword("1111");
            ds.setInitialSize(2);
    
            @Cleanup
            Connection conn = ds.getConnection();
            String sql = "SELECT id, name, age FROM student";
            @Cleanup
            PreparedStatement ps = conn.prepareStatement(sql);
            @Cleanup
            ResultSet rs = ps.executeQuery();
            while (rs.next()){ 
                System.out.print(rs.getLong("id")+",");
                System.out.print(rs.getString("name")+",");
                System.out.println(rs.getInt("age"));
            }
        }
    }

**注意:** @Cleanup是第三方框架lombok的注解,该注解的作用自动资源管理, 并处理一些异常.

成功查询到数据库中的信息  
![在这里插入图片描述][20200228231116261.png]  
但是从上面代码可以发现, 我们可以将这一坨代码,交给Spring IoC容器来处理,`让IoC来构建我们的dataSource对象`; `让DI来给这个对象注入属性值`;

###### 2、Spring IoC容器管理版本 ######

*  测试类

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class PropertyPlaceholderTest { 
    
        // @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
        @Autowired
        private DruidDataSource ds;
    
        @Test
        public void test() throws Exception{ 
            @Cleanup
            Connection conn = ds.getConnection();
            String sql = "SELECT id, name, age FROM student";
            @Cleanup
            PreparedStatement ps = conn.prepareStatement(sql);
            @Cleanup
            ResultSet rs = ps.executeQuery();
            while (rs.next()){ 
                System.out.print(rs.getLong("id")+",");
                System.out.print(rs.getString("name")+",");
                System.out.println(rs.getInt("age"));
            }
        }
    }

*  db.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/spring
    jdbc.username=root
    jdbc.password=1111
    jdbc.initialSize=2

*  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: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/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        
        
        <context:property-placeholder location="classpath:db.properties"/>
    
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
            <property name="driverClassName" value="${jdbc.driverClassName}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
            <property name="initialSize" value="${jdbc.initialSize}"/>
        </bean>
    
        
        
    
    </beans>

注意:  
`要在xml文件中增加context命名空间`  
![在这里插入图片描述][20200228232215727.png]

<context:property-placeholder location="classpath:db.properties"/>

[20200228110227367.png]: https://img-blog.csdnimg.cn/20200228110227367.png
[Spring _ Spring_ _ IoC_DI]: https://blog.csdn.net/m0_37989980/article/details/104541494
[Spring _ IoC_XML_DI_XML]: https://blog.csdn.net/m0_37989980/article/details/104552379
[Spring _ _IoC_DI_IoC_DI]: https://blog.csdn.net/m0_37989980/article/details/104566477
[Spring _]: https://blog.csdn.net/m0_37989980/article/details/104593905
[Spring _ AOP_AOP_Pointcut_AOP]: https://blog.csdn.net/m0_37989980/article/details/104599250
[Spring _ DAO_Spring JDBC_Spring]: https://blog.csdn.net/m0_37989980/article/details/104625263
[Spring _ XML_XML]: https://blog.csdn.net/m0_37989980/article/details/104632249
[Spring_MyBatis]: https://blog.csdn.net/m0_37989980/article/details/104758048
[Spring Java Config _]: https://blog.csdn.net/m0_37989980/article/details/105425235
[Spring Java Config _ 1]: https://blog.csdn.net/m0_37989980/article/details/105441748
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200228113328609.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[2021042321023032.png]: https://img-blog.csdnimg.cn/2021042321023032.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200228124256692.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[20200228124520498.png]: https://img-blog.csdnimg.cn/20200228124520498.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210423210656493.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210425172226615.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200228214621115.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[2020022822054941.png]: https://img-blog.csdnimg.cn/2020022822054941.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2021042320222984.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[20200228221620480.png]: https://img-blog.csdnimg.cn/20200228221620480.png
[2020022822325943.png]: https://img-blog.csdnimg.cn/2020022822325943.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200228223216601.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[20200228223604729.png]: https://img-blog.csdnimg.cn/20200228223604729.png
[20200228230251750.png]: https://img-blog.csdnimg.cn/20200228230251750.png
[20200228231116261.png]: https://img-blog.csdnimg.cn/20200228231116261.png
[20200228232215727.png]: https://img-blog.csdnimg.cn/20200228232215727.png