Spring详解（二）

　　传统的创建对象的方法是直接通过  new 关键字 ，而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC
　　IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做
　　Spring 容器创建对象的三种方式 //这是测试对象，我们通过 IOC 来创建对象 public  class  HelloIoc  {
　　public  void  sayHello (){System. out .println(＂Hello IOC＂ );} }
　　传统的创建对象的方法：new 关键字 //传统的创建对象方法----new @Test public  void  testTradition (){HelloIoc  hello = new  HelloIoc ();hello. sayHello ();}
　　这里通过 Spring 容器怎么来创建呢？
　　第一种方法：利用默认的构造方法
　　在 src 目录下新建 applicationContext.xml 文件，这是 spring 配置文件，添加如下代码：
　　<?xml version=＂1.0＂ encoding=＂UTF-8＂?>
　　
　　
　　/**
　　* Spring 容器利用构造函数创建对象
　　*/
　　@Test
　　public void testCreateObjectByConstrutor(){
　　//1、启动 spring 容器
　　ApplicationContext context =
　　new ClassPathXmlApplicationContext(＂applicationContext.xml＂);
　　//2、从 spring 容器中取出数据
　　HelloIoc IOC = (HelloIoc) context.getBean(＂helloIoc＂);
　　//3、通过对象调用方法
　　IOC.sayHello();
　　//利用配置文件 alias 别名属性创建对象
　　HelloIoc IOC2 = (HelloIoc) context.getBean(＂helloIoc2＂);
　　IOC2.sayHello();
　　}
　　HelloIoc.java 中手动添加无参的构造方法，然后执行上面的测试代码，会发现构造方法会在 sayHello()方法执行之前调用
　　<?xml version=＂1.0＂ encoding=＂UTF-8＂?>
　　
　　
　　
　　public static void main(String[] args) {
　　ApplicationContext ac=new ClassPathXmlApplicationContext(＂beans.xml＂);
　　JavaWork javaWork=(JavaWork)ac.getBean(＂javaWork＂);
　　javaWork.doTest();
　　}
　　public class JavaWork {
　　private Tester tester;
　　public void setTester(Tester tester) {
　　this.tester = tester;
　　}
　　public void doTest(){
　　/*ZhangSan zhangsan=new ZhangSan();
　　zhangsan.test();*/
　　tester.test();
　　}
　　}
　　第二种方法：利用静态工厂方法
　　 首先创建静态工厂类 HelloStaticFactory.java  public class HelloStaticFactory {     public HelloStaticFactory(){         System.out.println(＂HelloStaticFactory constructor＂);     }     //静态工厂方法     public static HelloIoc getInstances(){         return new HelloIoc();     } }
　　接着在 applicationContext.xml 中进行如下配置：
　　/**
　　* Spring 容器利用静态工厂方法创建对象
　　*/
　　@Test
　　public void createObjectStaticFactory(){
　　ApplicationContext context =
　　new ClassPathXmlApplicationContext(＂applicationContext.xml＂);
　　HelloIoc staticFactory =
　　(HelloIoc) context.getBean(＂helloStaticFactory＂);
　　staticFactory.sayHello();
　　}
　　spring容器只负责调用静态工厂方法，而这个静态工厂方法内部实现由程序员完成
　　利用实例工厂方法
　　首先创建实例工厂类 HelloInstanceFactory .java
　　public class HelloInstanceFactory {
　　public HelloInstanceFactory(){
　　System.out.println(＂实例工厂方法构造函数＂);
　　}
　　//利用实例工厂方法创建对象
　　public HelloIoc getInstance(){
　　HelloIoc instanceIoc = new HelloIoc();
　　return instanceIoc;
　　}
　　}
　　接着在 applicationContext.xml 中进行如下配置：
　　/**
　　* Spring 容器利用实例工厂方法创建对象
　　*/
　　@Test
　　public void createObjectInstanceFactory(){
　　ApplicationContext context =
　　new ClassPathXmlApplicationContext(＂applicationContext.xml＂);
　　HelloIoc staticFactory =
　　(HelloIoc) context.getBean(＂instance＂);
　　staticFactory.sayHello();
　　}
　　Spring 容器创建对象的时机
　　默认情况下，启动 spring 容器便创建对象
　　在spring的配置文件bean中有一个属性 lazy-init=＂default/true/false＂
　　①、如果lazy-init为＂default/false＂在启动spring容器时创建对象（默认情况）
　　 ②、如果lazy-init为＂true＂,在context.getBean时才要创建对象
　　在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat,如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了内存中，如果有数据，则对内存来是一个消耗。
　　反过来，在第二种情况下，可以减少内存的消耗，但是不容易发现错误
　　spring的bean中的scope：＂singleton/prototype/request/session/global session＂
　　一、默认scope的值是singleton，即产生的对象是单例的
　　applicationContext.xml 文件中配置：
　　//spring 容器默认产生对象是单例的 scope=＂singleton＂
　　@Test
　　public void test_scope_single_CreateObject(){
　　ApplicationContext context = new ClassPathXmlApplicationContext(＂applicationContext.xml＂);
　　HelloIoc hello1 = (HelloIoc) context.getBean(＂helloIoc＂);
　　HelloIoc hello2 = (HelloIoc) context.getBean(＂helloIoc＂);
　　System.out.println(hello1.equals(hello2)); //true
　　}
　　scope=＂prototype＂
　　多例模式，并且spring容器启动的时候并不会创建对象，而是在得到 bean 的时候才会创建对象
　　applicationContext.xml 文件中配置：
　　总结：在单例模式下，启动 spring 容器，便会创建对象；在多例模式下，启动容器并不会创建对象，获得 bean 的时候才会创建对象
　　scope=＂request＂ 每次HTTP请求都会创建一个新的bean
　　scope=＂session＂同一个HTTP Session共享一个Bean
　　scope=＂global session＂ 同一个全局Session共享一个Bean，一般用于portlet应用环境
　　scope=＂application＂同一个Application 共享一个Bean
　　Spring 容器生命周期
　　/**
　　* Spring 容器的生命周期
　　* @author hadoop
　　*
　　*/
　　public class SpringLifeCycle {
　　public SpringLifeCycle(){
　　System.out.println(＂SpringLifeCycle＂);
　　}
　　//定义初始化方法
　　public void init(){
　　System.out.println(＂init...＂);
　　}
　　//定义销毁方法
　　public void destroy(){
　　System.out.println(＂destroy...＂);
　　}
　　public void sayHello(){
　　System.out.println(＂say Hello...＂);
　　}
　　}
　　applicationContext.xml
　　public void testSpringLifeCycle(){
　　ApplicationContext context = new ClassPathXmlApplicationContext(＂applicationContext.xml＂);
　　SpringLifeCycle hello = (SpringLifeCycle) context.getBean(＂springLifeCycle＂);
　　hello.sayHello();
　　//销毁spring容器
　　ClassPathXmlApplicationContext classContext = (ClassPathXmlApplicationContext) context;
　　classContext.close();
　　}
　　spring 容器的声明周期
　　1、spring容器创建对象
　　2、执行init方法
　　3、调用自己的方法
　　4、当spring容器关闭的时候执行destroy方法
　　注意：当scope为＂prototype＂时，调用 close（） 方法时是不会调用 destroy 方法的