Spring 容器

---

1. Spring是什么？

Spring是一个轻量级的，开源的用来简化企业级应用开发的框架。（软件的半成品 ）<br/>

特点：

（1）简化开发：
    Spring框架对常用的API做了简化（比如，直接使用JDBC访问数据库，
    需要写很多重复性代码，而使用SpringJdbc,则不需要写这些重复性的代码）。
(2)管理对象：
    Spring框架提供了一个容器，帮我们管理对象之间的依赖关系。这样一来，对象之间的的耦合度大大降低，方便代码的维护。
(3)集成其他框架：
    Spring可以集成其他的一些小的框架（—比如用于任务调度的Quartz）。被称为一站式框架.

---

———————-spring容器——————————-

---

1. Spring容器

（1）Spring容器是什么？

Spring框架中的一个核心模块，用来管理对象。

（2）如何启动Spring容器？

stept1. 导包。
stept2. 添加一个配置文件。
stept3. 启动Spring容器。

（3）如何创建对象？

方式一： 使用无参构造器

stept1. 给类添加无参构造器（或缺省构造器）。
stept2. 在配置文件中添加一个bean元素。
stept3. 启动容器，调用容器提供的getBean方法。

注：被Spring容器所管理的对象，称之为一个bean。和JavaBean没有关系。

方式二： 使用静态工厂方法（了解）

方式三： 使用实例工厂方法（了解）

代码：

public class FristSpring {

    public static void main(String[] args) {
        String config = "applicationcontext.xml";
        //启动Spring容器
        /*
         *  注：
         *  a. ApplicationContext是接口。
         *  b. ClassPatchXMLApplicationContext是一个具体类，实现上述接口。
         *  c. config是配置文件的位置及文件名。
         */
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //System.out.println(ac);

        //调用容器提供的getBean方法来获得对象。返回Object类型
        //Student stu = (Student) ac.getBean("stu1");
        /*
         *  Student.class：Student对应的class对象。  class对象 方法区 
         *  注：
         *  类加载器负责读取.class文件内容，然后将这些内容存到方法区里面对应的
         *  一个class对象里面。
         */
        //----------------------------------------------
        /*
         * 方式一创建对象
         */
        Student stu = ac.getBean("stu1",Student.class);
        System.out.println(stu);        
        //使用容器创建一个Date对象    
        Date date = ac.getBean("date",Date.class);
        System.out.println(date);   
        //----------------------------------------------
        /*
         * 方式二创建对象
         */
        Calendar cal1 = ac.getBean("cal1",Calendar.class);
        System.out.println(cal1);
        //----------------------------------------------
        /*
         *方式三创建对象 
         */
        Date time1 = ac.getBean("time1",Date.class);
        System.out.println(time1);

    }       
}
-------------在applicationContext.xml中添加bean元素---------------------------
    <!--使用无参构造器啦创建对象。
        注：
        id属性：是bean的名称，要求唯一。
        class属性：要求写完整的名字（包名.类名）
     -->
    <bean id="stu1" class="first.Student">
    </bean>
    <bean id="date" class="java.util.Date">
    </bean>
    <!-- ······································· -->    

    <!-- 使用静态工厂方法创建对象
         注：
        factory-metho属性：指定一个静态方法。容器会调用该类的静态方法来创建对象。
     -->
    <bean id="cal1" class="java.util.Calendar"  factory-method="getInstance">
    </bean>
    <!-- ······································· -->        

    <!--使用实例工厂方法创建对象
         注：
         factory-bean属性：值为一个bean的id    
         factory-method属性： 要调用的实例方法。
           容器会调用该bean的实例方法来创建对象
    -->
    <bean id="time1" factory-bean="cal1" factory-method="getTime">
    </bean>

（4）生命周期

初始化方法（分配资源）

a. 容器在创建好对象后，会立即调用初始化方法。
b. 使用init-method属性指定初始化方法名。

销毁方法（释放资源）

a. 容器在关闭之前，会销毁它所管理的对象,此时会调用销毁方法。
b. 使用destroy-method属性指定销毁方法。 

注：销毁方法只有在作用域为单例时才有效; 如果bean的作用域为多例，销毁方法会失效。
代码：

package basic;
public class MessageBean {

    public MessageBean() {
        System.out.println("MessageBean对象创建了！");
    }

    public void init(){
        System.out.println("初始化方法init()执行了");
    }
    public void sendMsg(){
        System.out.println("sendMsg()");
    }
    public void destroy(){
        System.out.println("销毁方法destroy()执行了");
    }
}
----------------------在basic.xml中添加bean----------------------------------
<!--指定初始化方法和销毁方法 
    注：
     init-method属性：指定初始化方法。
     destroy-method属性：指定销毁方法。
     junit 单元测试工具
 -->
<bean id="mb1" class="basic.MessageBean" 
init-method="init" destroy-method="destroy"
scope="prototype">
</bean>
---------------------------测试块-----------------------------------------------
@Test
//测试  生命周期
public void test1(){
    String config = "basic.xml";
    //启动Spring容器
    /*
     * ApplicationContext接口没有提供close方法，
     * AbstractApplicationContext是一个抽象类，实现了
     * ApplicationContext接口，并且提供了close方法。
     */
    AbstractApplicationContext ac = new ClassPathXmlApplicationContext(config);
    //调用容器提供的getBean方法获得对象
    MessageBean mb1 = ac.getBean("mb1",MessageBean.class);
    mb1.sendMsg();
    //关闭容器
    ac.close();     
}

（5）作用域

a. 默认情况下，对于一个bean的配置，容器只会创建一个实例。
b. 如果指定scope的属性值为"prototype",则容器会创建多个实例。

代码：

package basic;
public class ScopeBean {

    public ScopeBean() {
        System.out.println("ScopeBean()对象创建了！");
    }
}
----------------------在basic.xml中添加bean----------------------------------
<!-- 
    指定作用域。
    注：
        scope属性的缺省值是"singleton"(单例)，
        prototype（多例）
 -->
<bean id="sb1" class="basic.ScopeBean"
    scope="prototype">
</bean>
---------------------------测试块-----------------------------------------------
@Test
//测试 作用域
public void test2(){
    String config = "basic.xml";
    //启动Spring容器
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    //调用容器提供的getBean方法获得对象
    ScopeBean sb1 = ac.getBean("sb1",ScopeBean.class);
    ScopeBean sb2 = ac.getBean("sb1",ScopeBean.class);

    System.out.println(sb1==sb2);       
}

（6）延迟加载（了解）

a. 默认情况下，容器启动之后，会将所有作用域为单例的bean先创建出来。
b. 延迟加载指的是，容器启动后，对于这些作用域为单例的bean不再创建。直到调用getBean方法时才会创建。

代码：

package basic;
public class LazyBean {

    public LazyBean() {
        System.out.println("LazyBean()对象创建了！");
    }
}
----------------------在basic.xml中添加bean----------------------------------
<!-- 延迟加载
     注：
     lazy-init属性值如果为true，表示延迟加载。         
 -->
<bean id="lb1" class="basic.LazyBean"
    lazy-init="true">
</bean>
---------------------------测试块-----------------------------------------------
@Test
//测试 延迟加载
public void test3(){
    String config = "basic.xml";
    //启动Spring容器
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
}