Spring框架中的容器以及两大特性

作者: 嗷老板 | 来源:发表于2018-05-05 16:51 被阅读0次

一、Spring框架的容器

Spring容器提供了一种管理方法，致力于解决我们各个层级之间的对象的调用关系。

Spring容器

我们通常调用各层级对象的时候，需要不断创建对象，一次访问就需要创建两个对象；如果我们使用Spring容器，将不同层级的对象放入容器中，每次使用的时候调用容器中的对象，就不用创建那么多对象，达到节约内存空间的目的。简单来讲，Spring容器就是存储JavaBean对象的容器。

创建BeanFactory的三种方式

BeanFactory是一个接口，需要创建继承的子类对象。下图是其继承结构图：

BeanFactory接口的实现结构
方式一：使用XmlBeanFactory获取BeanFactory工厂类对象
XmlBeanFactory需要传入一个配置文件的路径，这个配置文件就是我们spring的配置文件，默认是applicationContext.xml。这个方法已经过时，所以我们不再使用。

@Test
public void getUser() throws Exception{
    BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    Class<? extends BeanFactory> class1 = factory.getClass();
    System.out.println(class1);
}

方式二：使用ClassPathApplicationContext获取容器类
这个方法替代了方式一，是我们创建容器类对象主要使用的方法。

@Test
public void getUser() throws Exception{
    BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println(factory.getClass());
}

方式三：使用FileSystemXmlApplicationContext来获取容器对象
这种方式在创建对象的时候需要传入配置文件的绝对路径，这个方法可以使用项目外部的配置文件

@Test
public void getUser() throws Exception{
    BeanFactory factory = new FileSystemXmlApplicationContext("E:\\applicationContext.xml");
    System.out.println(factory.getClass());
}

二、Spring框架的第一大特性——IOC

IOC（inversion of controller）指的是控制反转，简单来书，就是讲创建对象的过程或者创建对象的权限交给了spring框架来帮我们处理，我们不用再通过new的方式来创建JavaBean对象，这个过程就叫做IOC。

创建JavaBean对象的三种方法

首先创建一个JavaBean对象

package com.itheima.main;

public class User {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}

方法一：使用默认构造创建JavaBean对象

首先在applicationContext中配置我们的对象

    <bean id="user" class="com.itheima.main.User">

    </bean>

然后从容器中获取我们的JavaBean对象

    @Test
    public void getBean() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User bean = (User) context.getBean("user");
        bean.eat();
    
    }

方法二：使用静态工厂创建JavaBean对象

创建bean的工厂类

package com.itheima.main;

public class BeanFactory {

    public static User getBean(){
        
        return new User();
        
    }
}

在配置文件中进行配置

<bean id="user2" class="com.itheima.main.BeanFactory" factory-method="getBean">
    </bean>

获取JavaBean对象

    @Test
    public void getBean2() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User bean = (User) context.getBean("user2");
        bean.eat();
    }

方式三：使用动态工厂创建JavaBean对象

创建工厂类的方式与上面相同
在配置文件中进行配置

    <bean id="createFactory" class="com.itheima.main.BeanFactory"></bean>
    <bean id="user3" factory-bean="createFactory" factory-method="getBean"></bean>

获取JavaBean对象

@Test
    public void getBean3() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User bean = (User) context.getBean("user3");
        bean.eat();
    }

Bean的作用域和作用范围

Bean属性scope可以声明bean的作用域范围，Bean的作用域范围有四种：

Prototype：多例，每次调用都会创建一个新的实例
Singleton：单例，创建一个对象，每次调用都是用这个对象
Request：适用于web开发中，将我们的对象存储在request域对象中
Session：适用于web开发中，将我们的对象存储在session域对象中

JavaBean的生命周期

我们可以在JavaBean类中添加init-method与destroy-method两个方法，实现bean在初始化和关闭的时候调用的方法，然后在配置文件中进行配置。
JavaBean类

package com.itheima.main;

public class User {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    // 初始化方法
    public void initMethod() {
        System.out.println(this.name + "出生了");
    }

    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    // 关闭方法
    public void destroyMethod() {
        System.out.println(this.name + "死亡了");
    }
}

配置文件

    <bean id="user" class="com.itheima.main.User" init-method="initmethod" destroy-method="destroymethod">

    </bean>

三、Spring框架的第二大特性——DI

DI（dependency injection）指的是依赖注入，简单来说就是使用spring框架对我们的JavaBean对象赋值的过程。

1、使用setter方法进行赋值

使用上文中创建的JavaBean类
注意：一定要给属性生成对应的setter方法
配置JavaBean类的属性

    <bean id="user" class="com.itheima.main.User" init-method="initmethod" destroy-method="destroymethod">
        <property name="name" value="张三"></property>        
        <property name="age" value="20"></property>
    </bean>

从容器中获取我们的JavaBean对象

    @Test
    public void getBean() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User bean = (User) context.getBean("user");
        bean.eat();
    
    }

2、使用构造器来申明JavaBean

在JavaBean中生成带所有属性的构造方法

public User() {
    super();
}

public User(String name,Integer age) {
    super();
    this.name = name;
    this.age = age;
}

在配置文件中申明JavaBean对象

    <bean id="user" class="com.itheima.main.User">
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
    </bean>

申明的另一种方法：

<bean id="user" class="com.itheima.main.User">
    <constructor-arg index="0" type="java.lang.String" value="张三"></constructor-arg>
        <constructor-arg index="1" type="java.lang.Integer" value="20"></constructor-arg>
</bean>

调用JavaBean的属性

    @Test
    public void getBean() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User bean = (User) context.getBean("user");
        bean.eat();
    
    }

3、P名称空间和C名称空间

P名称空间与C名称空间其实都是不存在的虚拟空间，主要是用于简化我们的spring为JavaBean属性赋值时的配置。
添加P名称空间与C名称空间到schema

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

声明P名称空间和C名称空间
使用P名称空间和C名称空间简化我们的开发
我们上面为属性赋值的时候可以通过setter方法或者构造方法进行赋值，下面可以对其进行简化

通过setter方法进行赋值：

    <bean id="user" class="com.itheima.main.User" >
        <property name="name" value="张三"></property>
        <property name="age" value="20"></property>
    </bean>

等价于：

    <bean id="user" class="com.itheima.main.User" p:name="张三" p:age="20">
    </bean>

通过构造方法进行赋值

    <bean id="user" class="com.itheima.main.User">
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
    </bean>

等价于：

    <bean id="user" class="com.itheima.main.User" c:name="张三" c:age="20">
    </bean>

4、SPEL表达式

Spel表达式，类似于jstl与el表达式的语言，spring可以支持我们在为属性赋值的时候，通过spel表达式来进行更改我们的属性值。

SPEL表达式

5、为集合属性赋值

创建一个含有集合属性的JavaBean类

package com.itheima.main;

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

public class CollectProperty {
    private List list;
    private Set set;
    private Map map;
    private Properties properties;
    public List getList() {
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
    public Set getSet() {
        return set;
    }
    public void setSet(Set set) {
        this.set = set;
    }
    public Map getMap() {
        return map;
    }
    public void setMap(Map map) {
        this.map = map;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    
}

为集合属性注入值

    <bean id="collectionProperty" class="com.itheima.main.CollectProperty">
        <property name="list">
            <list>
                <value>abc</value>
                <value>123</value>
                <value>张三</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>成龙</value>
                <value>刘德华</value>
                <value>甄子丹</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="name" value="张三"></entry>           
                <entry key="age" value="20"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="name">张三</prop>
                <prop key="age">20</prop>
            </props>
        </property>
    </bean>