Spring(一.Spring IOC)

一.Spring框架概述

概念

Spring是一个Service层的框架,可以整合许多其他框架进行工作.

Spring的主要技术点:

IOC(DI)----控制反转(依赖注入)

AOP----面向切面编程

二.Spring IOC

2.1 IOC(DI) - 控制反转(依赖注入)

所谓的IOC称之为控制反转，简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不再需要关注对象的创建和生命周期的管理，而是在需要时由Spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转。而在 创建对象的过程中Spring可以依据配置对对象的属性进行设置，这个过称之为依赖注入,也即DI。

2.2 IOC的实现原理

在初始化一个Spring容器时，Spring会去解析指定的xml文件，当解析到其中的标签时，会根据该标签中的class属性指定的类的全路径名，通过反射创建该类的对象，并将该对象存入内置的Map中管理。其中键就是该标签的id值，值就是该对象。
之后，当通过getBean方法来从容器中获取对象时，其实就是根据传入的条件在内置的Map中寻找是否有匹配的键值，如果有则将该键值对中保存的对象返回，如果没有匹配到则抛出异常。

2.3 IOC获取对象的方式

通过context.getBean()方法获取bean时，可以通过如下两种方式获取：

• 传入id值
• 传入class类型

通过class方式获取bean时，如果同一个类配置过多个bean，则在获取时因为无法确定到底要获取哪个bean会抛出异常。
而id是唯一的，不存在这样的问题，所以建议大家尽量使用id获取bean。
SpringIOC在通过class获取bean时，如果找不到该类型的bean还会去检查是否存在该类型的子孙类型的bean，如果有则返回，如果找不到或找到多个则抛出异常。这符合java面向对象思想中的多态的特性。

2.4 别名标签

在 Spring中提供了别名标签可以为配置的起一个别名，要注意的是这仅仅是对指定的起的一个额外的名字，并不会额外的创建对象存入map。

2.5 Spring创建对象的方式

• 通过类的无法构造方法创建对象

//Person类
public class Person {
	//无参构造方法
    public Person(){
        System.out.println("Person被创建了..");
    }
}

/**
 * SpringIOC创建对象---- 反射创建对象
 *  bean必须有无参构造才可以
 */
@Test
public void test01() throws Exception {
	//初始化Spring容器
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean
    Person p = (Person) context.getBean("person");
    System.out.println(p);
    //关闭容器
    ((ClassPathXmlApplicationContext)context).close();
}

• 通过指定构造器创建对象

//Person类
public class Person {
    public Person(String name,int age){
        System.out.println("Person init.."+name+".."+age+".."+this);
    }
}

<!--applicationContext.xml配置-->
<bean id="person" class="cn.xxx.domain.Person">
<!--
	name：参数名
	type：参数类型
	index：参数位置
	value：参数值(直接赋值)
	ref：参数值(引用其他bean)
-->
<constructor-arg name="name" type="java.lang.String" index="0" value="zs"/>
<constructor-arg name="age" type="int" index="1" value="19"/>
</bean>

//通过配置bean的<constructor-arg>参数，实现控制spring容器通过指定构造器创建对象
@Test
public void test01(){
    //初始化Spring容器
    ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean
    Person person = (Person) context.getBean("person");
    System.out.println(person);
    //关闭容器
    ((ClassPathXmlApplicationContext)context).close();
}

• 通过工厂创建对象
  • 静态工厂创建对象
  • 实例工厂创建对象
  • Spring工厂创建对象

具体参考Spring内置的FactoryBean接口文档.

2.6 单例和多例

Spring容器管理的bean在默认情况下是单例的，也即，一个bean只会创建一个对象，存在内置 map中，之后无论获取多少次该bean，都返回同一个对象。

Spring默认采用单例方式，减少了对象的创建，从而减少了内存的消耗。

但是在实际开发中是存在多例的需求的，Spring也提供了选项可以将bean设置为多例模式。

<!--applicationContext.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-3.2.xsd">     
        <!-- 
                scope属性控制当前bean的创建模式：
                        singleton:则当前bean处在单例模式中,默认就是此模式
                        prototype:则当前bean处在多例模式中
         -->
        <bean id="cart" class="cn.xxx.beans.Cart" scope="prototype"></bean>
</beans>

bean在单例模式下的生命周期：

• bean在单例模式下，spring容器启动时解析xml发现该bean标签后，直接创建该bean的对象存入内部map中保存，此后无论调用多少次getBean()获取该bean都是从map中获取该对象返回，一直是一个对象。此对象一直被Spring容器持有，直到容器退出时，随着容器的退出对象被移除出容器。

bean在多例模式下的生命周期：

• bean在多例模式下，spring容器启动时解析xml发现该bean标签后，只是将该bean进行管理，并不会创建对象，此后每次使用 getBean()获取该bean时，spring都会重新创建该对象返回，每次都是一个新的对象。这个对象spring容器并不会持有，什么时候销毁取决于用户程序本身。

2.7 懒加载机制

Spring默认会在容器初始化的过程中，解析xml，并将单例的bean创建并保存到map中，这样的机制在bean比较少时问题不大，但一旦bean非常多时，spring需要在启动的过程中花费大量的时间来创建bean 花费大量的空间存储bean，但这些bean可能很久都用不上，这种在启动时在时间和空间上的浪费显得非常的不值得。

所以Spring提供了懒加载机制。所谓的懒加载机制就是可以规定指定的bean不在启动时立即创建，而是在后续第一次用到时才创建，从而减轻在启动过程中对时间和内存的消耗。

懒加载机制只对单例bean有作用，对于多例bean设置懒加载没有意义。
懒加载只是延后了对象创建的时机，对象仍然是单例的。

<!--applicationContext.xml配置-->
<!--为指定bean配置懒加载-->
<?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-3.2.xsd"
        >
        <bean id="cart" class="cn.xxx.beans.Cart" lazy-init="true"></bean>
</beans>

<!--applicationContext.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-3.2.xsd"
        default-lazy-init="true"
        >
        <bean id="cart" class="cn.xxx.beans.Cart"></bean>
</beans>

2.8 配置初始化和销毁的方法

在Spring中如果某个bean在初始化之后 或 销毁之前要做一些 额外操作可以为该bean配置初始化和销毁的方法 ，在这些方法中完成要功能。

// init()和destory()
public class ProdDao {     
        public ProdDao() {
                System.out.println("ProdDao 被创建。。。");
        }
        public void init(){
                System.out.println("init。。连接数据库。。。。。");
        }
        public void destory(){
                System.out.println("destory。。断开数据库。。。。。");
        }
        public void  addProd(){
                System.out.println("增加商品。。");
        }
        public void  updateProd(){
                System.out.println("修改商品。。");
        }
        public void  delProd(){
                System.out.println("删除商品。。");
        }
        public void  queryProd(){
                System.out.println("查询商品。。");
        }
}

<!--applicationContext.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-3.2.xsd"
        >
        <bean id="prodDao" class="cn.xxx.beans.ProdDao" 
                init-method="init" destroy-method="destory"></bean>
</beans>

Spring DI

见Spring(二.Spring DI).

Spring 注解

见Spring(三.Spring 注解).

SpringAOP

见Spring(四.SpringAOP).