Spring简介及xml配置

Java Web发展史

• 第一阶段:JavaBean+Servlet+Jsp逐步发展
• 第二阶段:面对EJB重量级框架带来的种种麻烦
• 第三阶段:SpringMVC/Struts+Spring+Hibernate/myBatis
• 第四阶段:享受SpringBoot"约定大于配置"的种种乐趣，不少繁琐的配置都变成了约定
• 第五阶段:以Dubbo为表明的SOA为服务架构体系(Dubbo是阿里建立的)
• 第六阶段:比较前沿的技术，SpringCloud 微服务架构技术生态圈(基于SpringBoot,保证了开箱即用，须要什么SpringCloud都有)

IoC 控制反转

不仅是Spring的IoC，其余的框架也具备相同的IoC思想及应用:

• 控制： 控制对象的建立及销毁（生命周期）
• 反转：将对象的控制权交给IoC容器

IoC容器约定

①全部Bean的生命周期交由IoC容器管理

②全部被依赖的Bean经过构造方法执行注入

③被依赖的Bean须要优先建立

Spring IoC容器使用方法

概述

经过Spring.xml文件实例化Bean.只要Spring.xml中配置了bean标签，则就会根据class建立这个bean的实例.
把一个java bean交给Spring管理步骤：

一、建立一个xml格式的配置文件

二、在xml文件中定义一个bean，给每一个bean设定一个id

三、经过ApplicationContext获取Spring上下文

ApplicationContext context = new ClassPathXmlApplicatioinContext("文件名.xml");

四、获取bean

`Bean bean = context.getBeal("第一步中给bean的id"，Bean.class);

一、经过构造方法实例化Bean

步骤1：建立要实例化的类，并提供无参构造方法。

public class Bean {
    public Bean(){
        System.out.println("Bean被建立了");
    }

步骤2：spring.xml中配置

<bean id="bean的惟一标识" class="要实例化bean的路径"></bean>

测试:

ApplicationContext context=new ClassPathXmlApplicationContext(spring.xml的路径);
Bean bean=context.getBean("bean",Bean.class);
System.out.println(bean);

二、经过静态工厂方法实例化Bean

经过Bean2的工厂的静态方法实例化Bean.

步骤1：建立Bean2的工厂Bean2Factory类以及Bean2类，而且提供一个静态、返回值类型为Bean2的方法,返回new Bean2()。

public class Bean2Factory {
    public static Bean2 getBean2(){
        return new Bean2();
    }
}

public class Bean2 {
    public Bean2(){
        System.out.println("Bean2被建立了。");
    }

步骤2：配置Spring.xml

<bean class="Bean2工厂的路径" factory-method="Bean2工厂的静态方法名" id="Bean2工厂的惟一标识"></bean>

测试:

ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc2.xml");
Bean2 bean=context.getBean("bean2factoryId",Bean2.class);
System.out.println(bean);

三、经过实例工厂方法实例化Bean

经过Bean3的工厂的实例方法实例化Bean.

步骤1：建立Bean3的工厂Bean3Factory类以及Bean3类，而且提供一个返回值类型为Bean3的方法，方法返回new Bean3()。

public class Bean3Factory {
    public  Bean3 getBean3(){
        return new Bean3();
    }
}

public class Bean3 {
    public Bean3(){
        System.out.println("Bean3被建立了。");
    }
}

步骤2：配置Spring.xml

<bean class="main.java.com.imooc2.Bean3Factory" id="bean3Factory"></bean>
<bean class="main.java.com.imooc2.Bean3" factory-bean="bean3Factory" factory-method="getBean3" id="bean3"></bean>

给bean取别名

有类Bean1，而且经过bean标签实例化Bean1，能够给Bean1的实例取多个名字。

方式一: bean标签里添加name属性

<bean id="bean" class="main.java.com.imooc1.Bean" name="bean1_1,bean1_2"></bean>

方式二: 添加<alias>标签

<bean id="bean" class="main.java.com.imooc2.Bean1" name="bean1_1,bean1_2"></bean>
<alias name="bean" alias="bean1_3"/><!-- alias只支持一个别名 -->

依赖注入的方式

1.经过构造方法注入Bean

简化写法:

2.经过Set()方法注入Bean

3.集合类型注入Bean

4.注入null空值

5.注入内部bean

Spring中Bean的做用域

一、Singleton做用域(单例模式)

经过Spring容器实现单例模式，具备局限性：保证在一个Spring上下文(ApplicationContext）是单例模式，多个AppliactionContext单例模式就失效了。

二、prototype做用域(多例模式)

若是一个<bean>的做用域为prototype，则该<bean>会被实例化屡次，有多个Bean会被建立（每次向Spring上下文请求该Bean都会new一个新的实例）。

Bean1依赖Bean2,总结起来:

对于蓝框中的状况,有时候咱们须要单个Bean1,多个Bean2,就要用到方法注入.

方法注入

Bean2代码修改:

Spring.xml修改:

这样即便Bean1是单例模式,每次拿到Bean1都会是不一样的Bean2实例.

三、Web环境做用域

request做用域、session做用域、application做用域、websocket做用域(使用较少).....
request：每次浏览器刷新都会实例化一个新的bean；

session：浏览器刷新不会实例化新的bean，更换浏览器则会实例化新的bean；

application：bean实例化以后就不会改变，更换浏览器也不会。

SpringWeb上下文环境

在web.xml中定义:

不使用DispatcherServlet:


以RequestController为例:

在spring.xml中添加:

• request：每次浏览器刷新都会实例化一个新的bean；
• session：浏览器刷新不会实例化新的bean，更换浏览器则会实例化新的bean；
• application：bean实例化以后就不会改变，更换浏览器也不会。

四、自定义做用域

Spring内置的自定义SimpleThreadScope做用域
以自定义双例模式为例:

步骤1：实现Scope接口

(org.springframework.beans.factory.config.Scope)主要关注实现的get方法和remove方法。

get()方法：按照name参数，按照咱们本身定义的规则，去返回一个Bean，若是咱们定义的规则里，Bean不存在，那么将经过objectFactory去建立一个Bean。

双例模式：一个bean的Id对应两个实例，实现双例模式，须要两个Map集合，Map<String,Object> map1=new HashMap<String,Object>();Map<String,Object> map2=new HashMap<String,Object>();。

get()方法：

public Object get(String name, ObjectFactory<?> objectFactory) {
        if(!map1.containsKey(name)){   //判断map1是否包含名为name的Bean实例
            Object o=objectFactory.getObject();//若是不存在则建立一个ObjectFactory规则Bean
            map1.put(name, o);   //并把这个Bean放入集合,并命名为name
            return o;
        }
        if(!map2.containsKey(name)){   //map2同map1操做
            Object o=objectFactory.getObject(); 
            map2.put(name, o);  
            return o;
        }

//若是map1和map2都包含这个Bean,也就是说Spring上下文经过Id获取有两个实例,则返回一个0或1
        int i=new Random().nextInt(2);
        if(i==0){
            return map1.get(name);//若是是0,则返回对象1
        }else{
            return map2.get(name);//若是是0,则返回对象2
        }
    }

remove()方法：和get方法相反，按照name参数，去移除一个Bean。

public Object remove(String name) {
        if(map1.containsKey(name)){
            Object o=map1.get(name);
            map1.remove(name);
            return o;
        }
        if(map2.containsKey(name)){
            Object o=map2.get(name);
            map2.remove(name);
            return o;
        }
        return null;    //说明没拿到任何实例
    }

步骤2: spring.xml配置

<bean id="myScope" class="main.java.com.自定义做用域.MyScope"></bean>

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
    <property name="scopes">
        <map>
            <entry key="myscope" value-ref="myScope"></entry>
        </map>
    </property>
</bean>

测试

@Test
public void testBean(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring-zidingyi.xml");
        for(int i=0;i<10;i++){
            Bean bean=ac.getBean(“myScope”", Bean.class);
            System.out.println(bean);
        }
    }

补充:SimpleThreadScope

Spring提供的线程内单例做用域:

• 同一线程中Spring上下文会分配同一实例
• 不一样线程(Thread)中，则得到不一样实例。

srping配置：

<bean id="myScope" class="main.java.com.自定义做用域.MyScope" ></bean>
<bean id="simpleThreadScope" class="org.springframework.context.support.SimpleThreadScope"></bean>

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
    <property name="scopes">
        <map>
        <entry key="myscope" value-ref="myScope"></entry>
        <entry key="simpleThreadScope" value-ref="simpleThreadScope"></entry>
        </map>
    </property>
</bean>

<bean id="bean11" class="main.java.com.自定义做用域.Bean" scope="simpleThreadScope"></bean>

测试代码：

public void testBean(){
        final ApplicationContext ac=new ClassPathXmlApplicationContext("spring-zidingyi.xml");

        for(int i=0;i<10;i++){
        new Thread(new Runnable(){
            @Override
            public void run() {
                    Bean bean=ac.getBean("bean11", Bean.class);
                    System.out.println(bean);
            }
        }).start();
    }
    }
}

默认Scope(单例)Bean的懒加载

Spring容器会在建立容器时提早初始化Singleton做用域的bean，可是若是Bean被标注了lazy-init=“true”,则该Bean只有在其被须要的时候才会被初始化。（只对singleton做用域的bean有效）
如

<bean id="bean" class="main.java.com.Bean懒加载.Bean" scope="singleton" lazy-init="true"></bean>

多个bean使用懒加载:

<beans default-lazy-init=“true”></beans>

表示spring配置文件里全部bean都是懒加载模式。
使用场景：
若是某个Bean在程序整个运行周期均可能不会被使用，那么可考虑设定该Bean为懒加载。

• 优势：尽量的节省了资源。
• 缺点：可能会致使某个操做相应操做时间增长。

Bean初始化及销毁

以singleton做用域为例,假设有一个javaBean，该Bean的做用是链接数据库，该Bean被建立以后，执行数据库链接操做.

Bean初始化

若是须要在Bean实例化时执行一些逻辑，Spring提供了两种方法：

• 方法1：bean标签里的init-method属性，该值为Bean的某一方法，Spring实例化时，会调用Bean的该方法。
• 方法2：让Bean实现InitializingBean接口，Spring在实例化该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

Bean销毁

若是须要在Bean销毁以前执行一些逻辑，有两种方法。

• 方法1：bean标签里的destory-method属性，该值为Bean的某一方法，Spring销毁该Bean时，会调用Bean的该方法。
• 方法2：让Bean实现DisposableBean接口，Spring在销毁该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

案例1：

经过bean标签的init-method和destory-method属性来指定Bean初始化逻辑和销毁逻辑。
代码：

public class Bean {
    public void onInit(){
        System.out.println("Bean的初始化逻辑方法被执行了");
    }
    public void onDestory(){
        System.out.println("Bean的销毁逻辑方法被执行了");
    }
}

spring.xml配置：

<bean class="main.java.com.Bean初始化及销毁.Bean" 
      id="bean" 
      init-method="onInit" 
      destroy-method="onDestory"/>

测试代码：

@Test
public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");
        Bean bean=ac.getBean("bean", Bean.class);
        System.out.println(bean);
    }

结果：bean的销毁方法没执行，由于当前是单例模式，因此Bean的初始化是在Spring上下文实例化完成的，Bean的销毁是在Spring上下文的销毁过程当中执行Bean的销毁。（Spring上下文的销毁定义到AbstractApplicationContext中）

改进：

@Test
public void test(){
        AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");
        Bean bean=ac.getBean("bean", Bean.class);
        System.out.println(bean);
        ac.close();
}

注意：若是全部的Bean都有相同名称的初始化方法和相同名称的销毁方法，能够在spring.xml中定义:

<beans default-init-method="onInit"   
       default-destory-method="onDestory"/>

案例2：

实现相应接口，并实现相应方法
代码：

public class Bean implements InitializingBean,DisposableBean{
    @Override
    public void destroy() throws Exception {
        System.out.println("Bean的销毁逻辑方法被执行了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean的初始化逻辑方法被执行了");
    }
}

spring.xml配置：

<bean class="main.java.com.Bean初始化及销毁.Bean" id="bean"></bean>

Bean属性继承

应用场景

场景1：

ParentClass（属性1,属性2，属性3，get和set方法）
子类1（属性4，属性5） 
子类2（属性6，属性7）

场景2：
子类1和子类2没有父类，而是有一些相同的属性。

类1：（属性1，属性2，属性3，属性4，属性5）
类2：（属性1，属性2，属性3，属性6，属性7）

这两个场景下，经过Spring注入类1和类2的全部属性，通常以下：

• abstract="true"：设置<bean>标签只是定义性的，不会对它进行实例化操做。
• parent属性：在Bean的子类bean标签添加，值为父类的Id。

场景1：
spring.xml配置:

<bean id="bean" class="main.java.com.Bean继承属性.ParentClass" abstract="true">
<property name="attribute1" value="attribute1"></property>
<property name="attribute2" value="attribute2"></property> 
<property name="attribute3" value="attribute3"></property>
</bean>

<bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">
<property name="attribute4" value="attribute4"></property>
<property name="attribute5" value="attribute5"></property>
</bean>   

<bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">
<property name="attribute6" value="attribute6"></property>
<property name="attribute7" value="attribute7"></property>
</bean>

场景2：
类1和类2不继承某一父类，只是存在相同属性。

spring.xml配置：

<bean id="bean" abstract="true">
<property name="attribute1" value="attribute1"></property>
<property name="attribute2" value="attribute2"></property> 
<property name="attribute3" value="attribute3"></property>
</bean>

<bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">
<property name="attribute4" value="attribute4"></property>
<property name="attribute5" value="attribute5"></property>
</bean>   

<bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">
<property name="attribute6" value="attribute6"></property>
<property name="attribute7" value="attribute7"></property>
</bean>