IOC与DI（xml 配置）

　　Spring可以帮助我们管理软件开发过程中的对象，以及如何创建和维护对象之间的关系。 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，可以将组建的耦合度降至最低，即实现解耦，便于系统以后的维护和升级。

1.spring 开发

　　eclipse开发工具

　　　　maven搭建项目-添加spring-context依赖包

　　　　引入applicationContext.xml配置文件

2.IOC （Inversion of Control） ：控制反转，通过容器来控制对象的创建及维护，对象中成员变量的创建及维护。反转就是将对象的控制权转移给容器处理，目的是获得更好的扩展性和可维护性。

3.Spring Core Container(即Spring核心容器)——Spring框架的核心

4.Spring管理Bean的原理

　　Spring的核心容器可以管理任何java类，容器可以初始化该类，并返回该类的实例。

xml配置方式：

    <!-- spring中进行控制反转的标记
        通过配置bean  可以指定某个class由spring来管理
        spring在读取主配置文件的时候会将当前标记读取，并且根据当前标记的class
        的值，通过反射来创建该bean的对象  id是用来给某个创建的对象设置一个唯一
        标识
        lazy-init:懒加载设置    默认为立即加载，即值为false
        设置成true，会在用到该bean的时候才创建该bean的对象
     -->

测试：

　　添加Junit依赖包

　　新建Javabean类（完整的），添加init、destroy方法（略。。。）

　　配置xml文件：

    <bean id="animal" class="com.rong.entity.Animal" lazy-init="false" init-method="init" destroy-method="destroy"></bean>

　　方法测试：

 public class MyTest {
     //ApplicationContext context=null;
     ClassPathXmlApplicationContext context=null;
     @Before
     public void before(){
         context=new ClassPathXmlApplicationContext("application.xml");
     }
     //测试destroy需要关闭容器，关闭容器的时候会自动销毁容器中的对象
     @Test
     public void test1(){
         Animal animal = context.getBean("animal", Animal.class);
         System.out.println(animal);
         context.close();//容器关闭，对象销毁  destroy调用只在单例模式下有效 (默认单例)
     }
 }

单例与多例

    <!--
        bean的作用域
        scope：默认是单例singleton
               pototype 表示多实例  每次getBean都会创建一个新的对象
     -->
     <bean name="animal1" class="com.rong.entity.Animal" scope="prototype"></bean>

     @Test
     public void test2(){
         //修改了作用域后，每次getBean都会创建一个对象
         Animal animal1 = context.getBean("animal1", Animal.class);
         Animal animal2 = context.getBean("animal1", Animal.class);
     }

5.Bean对象的实例化

A.用构造器来实例化

　　如果不指定调用哪个构造器，spring默认会调用无参构造方法。

　　例：<bean name="animal1" class="com.rong.entity.Animal" scope="prototype"></bean>

     <!--
         constructor-arg:设置构造方法注入，通过该标签来设置构造方法中 的  index的位置上的参数，
         赋于value属性的值
         index:构造方法中的参数的索引位置，从0开始计算
         value:设置属性值，只有String和基本数据类型可以直接用value指定值
         ref：如果需要引用其他的bean作为属性值，用ref(用其他bean的id或name)
         type:设置当前参数的类型，可以省略
       -->

    <bean id="animal" class="com.rong.entity.Animal" lazy-init="false" init-method="init" destroy-method="destroy">
        <constructor-arg index="0" type="java.lang.String" value="小花"></constructor-arg>
        <constructor-arg index="1" value="18"></constructor-arg>
    </bean>

B.使用静态工厂实例化

　　类中声明静态工厂方法

    public Animal() {
        super();
        System.out.println("无参Animal");
    }
    public static Animal getInstance(){
        System.out.println("静态工厂创建实例");
        return new Animal();
    }

<!--
        factory-method：使用对象静态工厂的方式创建对象
     -->
    <bean id="animal2" class="com.rong.entity.Animal" factory-method="getInstance"></bean>

C.使用实例工厂实例化

    <!-- 通过对象工厂创建对象
        1.创建工厂对象
        2.设置bean使用工厂对象的方法来创建
     -->

 public class AnimalFactory {
     public Animal getInstance(){
         System.out.println("工厂方法调用");
         return new Animal();
     }
 }

    <bean id="animalFactory" class="com.rong.entity.AnimalFactory"></bean>
    <bean id="animal3" class="com.rong.entity.Animal" factory-bean="animalFactory" factory-method="getInstance"></bean>

     @Test
     public void test4(){
         Animal animal = context.getBean("animal3", Animal.class);
         System.out.println(animal);
     }

D.延时实例化——lazy-init

6.依赖注入(DI全称是Dependency Injection)

<!-- DI  依赖注入配置   即通过spring去做  构造方法或set方法给属性赋值工作 -->

A.构造方法注入（示例如上）

B.set方法注入

1)类中提供set方法

2）在spring主配置文件中通过property属性来设置(value和ref属性不能同时使用)

<!-- setter注入
        property  :调用setter方法设置属性值
        name:设置哪个属性赋值
        value:给该属性赋予什么值
        ref : 给引用类型属性赋值
    -->

     <bean id="animal3" class="com.rong.entity.Animal" factory-bean="animalFactory" factory-method="getInstance">
         <property name="age" value="60"></property>
         <property name="type" value="www"></property>
     </bean>

C.自动装配的方式

<!-- 自动装配 ，一般结合依赖注入使用 -->

     <!--
         autowire:使用自动装配的方式，给当前bean的属性赋值
         byType:spring自动检索容器中有哪些bean，并且找到符合当前bean的属性的类型的bean出来，如果找到了
         则自动给该属性赋值
         byName:spring自动根据当前bean的属性的名称，从容器中查找与该属性名一致的bean，注入到该属性上
      -->

     <!-- <bean id="favourite" class="com.web.entity.Favourite">
         <property name="sport" value="游泳"></property>
     </bean> -->
     <bean id="favourite2" class="com.web.entity.Favourite">
         <property name="sport" value="打篮球"></property>
     </bean>
     <!-- <bean id="myAnimal" class="com.web.entity.Animal" autowire="byName"></bean> -->
     <bean id="myAnimal2" class="com.web.entity.Animal" autowire="byType"></bean>

list、set、map、property的注入方式

 package com.web.entity;

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

 public class MyBean {
     private List<String> cities;
     private Set<String> names;
     private Map<String,Integer> map;
     private Properties props;
     public List<String> getCities() {
         return cities;
     }
     public void setCities(List<String> cities) {
         this.cities = cities;
     }
     public Set<String> getNames() {
         return names;
     }
     public void setNames(Set<String> names) {
         this.names = names;
     }
     public Map<String, Integer> getMap() {
         return map;
     }
     public void setMap(Map<String, Integer> map) {
         this.map = map;
     }
     public Properties getProps() {
         return props;
     }
     public void setProps(Properties props) {
         this.props = props;
     }

     public void show(){
         System.out.println("list==========");
         for (String string : cities) {
             System.out.println(string);
         }
         System.out.println("set==========");
         for (String name : names) {
             System.out.println(name);
         }
         System.out.println("map==========");
         Set<Entry<String, Integer>> entrySet = map.entrySet();
         Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
         while(iterator.hasNext()){
             Entry<String, Integer> entry = iterator.next();
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+":"+value);
         }
         System.out.println("property==========");
         Set<Object> Set = props.keySet();
         for (Object object : Set) {
             String key=(String)object;
             String value = props.getProperty(key);
             System.out.println(key+":"+value);
         }

     }

 }

    <bean id="myBean" class="com.web.entity.MyBean">
        <property name="cities">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
                <value>深圳</value>
            </list>
        </property>
        <property name="names">
            <set>
                <value>胡歌</value>
                <value>杨幂</value>
                <value>霍建华</value>
                <value>叶剑英</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry>
                    <key>
                        <value>Java</value>
                    </key>
                    <value>100</value>
                </entry>
                <entry>
                    <key>
                        <value>C++</value>
                    </key>
                    <value>98</value>
                </entry>
                <entry>
                    <key>
                        <value>Android</value>
                    </key>
                    <value>96</value>
                </entry>
            </map>
        </property>
        <!-- ref引用方式 -->
<!--         <property name="props" ref="dbProps">

        </property> -->
        <!-- 直接赋值方式 -->
        <property name="props">
            <props>
                <prop key="username">#{dbProps.username}</prop>
                <prop key="password">#{dbProps.password}</prop>
                <prop key="driver">com.mysql.jdbc.Driver</prop>
            </props>
        </property>
    </bean>
    <!-- 读取配置文件转成Properties对象
    id:唯一标识
    location：从哪里读取文件
    classpath:    通过类路径开始读取
    -->
    <util:properties id="dbProps" location="classpath:db.properties"></util:properties>

 url=jdbc:mysql://localhost:3306/utf8?useUnicode=true&characterEncoding=utf-8
 username=root
 password=123123
 driver=com.mysql.jdbc.Driver