Bean&BeanFactory&创建bean实例

一、Bean和BeanFactory
// 以指定路径下bean.xml配置文件为参数，创建文件输入流
InputStream is  =   new  FileInputStream( " beans.xml " );
// 以指定的文件输入流is，创建Resource对象
InputStreamResource isr  =   new  InputStreamResource(is);
// 以Resource对象作为参数，创建BeanFactory的实例
XmlBeanFactory factory  =   new  XmlBeanBeanFactory(isr);

// 搜索CLASSPATH路径，以CLASSPATH路径下的beans.xml文件创建Resource对象
ClassPathResource res  =   new  ClassPathResource( " beans.xml " );
// 以Resource对象为参数，创建BeanFactory实例
XmlBeanFactory factory  =   new  XmlBeanFactory(res);

// 搜索CLASSPATH路径，以CLASSPATH路径下的applicationContext.xml
// serve.xml 文件创建 ApplicationContext
ClassPathXmlApplicationContext appContext  =
     new  ClassPathXmlApplicationContext(
         new  String[]  ... {"applicationContext.xml", "service.xml"} );
// 事实上，ApplicationContext是BeanFactory的子接口，支持强制类型转换
BeanFactory factory  =  (BeanFactory) appContext;

// 指定路径下的applicationContext.xml,service.xml文件创建ApplicationContext
FileSystemXmlApplicationContext appContext  =  
     new  FileSystemXmlApplicationContext(
         new  String[]  ... {"applicationContext.xml", "service.xml"} );
// 事实上，ApplicationContext是BeanFactory的子接口，支持强制类型转换
BeanFactory factory  =  (BeanFactory) appContext;

* 附加：
< bean id = " p2 "   class = " prolove.Person "  singleton = " false " />

<? xml version = " 1.0 "  encoding = " gb2312 " ?>
<! DOCTYPE beans PUBLIC  " -//SPRING//DTD BEAN//EN "
     " http://www.springframework.org/dtd/spring-beans.dtd " >
< beans >
     < bean id = " dataSource "   class = " org.apache.commons.dbcp.BasicDataSource
        destroy - method = " close "" >
         < property name = " driverClassName " >
             < value > com.mysql.jdbc.Driver </ value >
         </ property >
         < property name = " url " >
             < value > jdbc:mysql: // localhost:3306/j2ee</value>
         </ property >
         < property name = " username " >
             < value > root </ value >
         </ property >
         < property name = " password " >
             < value > root </ value >
         </ property >
     </ bean >
</ beans >

public   class  BeanTest
... {
    public static void main(String[] args) ...{
        //实例化Spring容器，Spring容器负责实例化Bean
        ApplicationContext ctx =
            new FileSystemXmlApplicationContext("beans.xml");
        //通过bean id获取bean实例，并强制类型转换为DataSource
        DataSource ds = (DataSource)ctx.getBean("dataSource");
        //通过DataSource来获取数据库连接
        Connection conn = ds.getConnection();
        //通过数据库连接获取Statement
        java.sql.Statement stmt = conn.createStatemen();
        //使用statement执行sql语句
        stmt.execute("insert into mytable values('prolove')");
        //清理资源，回收数据库连接资源
        if (stmt != null) stmt.close();
        if (conn != null) conn.close();
    }
}

二、创建bean实例
创建bean通常有如下方法：
* 调用构造器创建一个bean实例
* BeanFactory调用某个类的静态工厂方法创建bean
* BeanFactory调用实例工厂方法创建bean

1 .调用构造函数 " new " 一个bean实例
public   interface  Person
... {
    public void useAxe();
}
public   class  Chinese  implements  Person
... {
    private Axe axe;
    public Chinese() ...{
        System.out.println("Spring实例化主调bean:Chinese实例...");
    }
    public void setAxe(Axe axe) ...{
        System.out.println("Spring执行依赖关系注入...");
        this.axe = axe;
    }
    public void useAxe() ...{
        System.out.println(axe.chop());
    }
}
public   interface  Axe
... {
    public void chop();
}
public   class  SteelAxe  implements  Axe
... {
    public SteelAxe() ...{
        System.out.println("Spring实例化依赖bean:SteelAxe实例...");
    }
    public String chop() ...{
        return "钢斧砍柴真快";
    }
}
<? xml version = " 1.0 "  encoding = " gb2312 " ?>
<! DOCTYPE beans PUBLIC  " -//SPRING//DTD BEAN//EN "
     " http://www.springframework.org/dtd/spring-beans.dtd " >
< beans >
     < bean id = " chinese "   class = " prolove.Chinese " >
         < property name = " axe " >
             < ref local = " steelAxe " />
         </ property >
     < bean >
     < bean id = " steelAxe "   class = " prolove.steelAxe " />
</ beans >

public   class  BeanTest
... {
    public static void main(String[] args) throws Exception ...{
        //在当前路径下搜索bean.xml文件，实例化文件输入流
        InputStream is = new FileInputStream("bean.xml");
        //以指定的文件输入流is，创建Resource对象
        InputStreamResource isr = new InputStreamResource(is);
        //以Resource对象作为参数，创建BeanFactory的实例
        XmlBeanFactory factory = new XmlBeanFactory(isr);
        System.out.println("程序已经实例化BeanFactory...");
        Person p = (Person)factory.getBean("chinese");
        System.out.println("程序中已经完成了chinese bean的实例化...");
        p.useAxe();
    }
}
执行结果如下：
程序已经实例化BeanFactory...
Spring实例化主调bean:Chinese实例...
Spring实例化依赖bean:SteelAxe实例...
Spring执行依赖关系注入...
程序中已经完成了chines bean的实例化...
钢斧砍柴真快

执行结果清楚地反映了执行过程：
( 1 )创建BeanFactory实例
( 2 )调用Chinese类的默认构造器创建默认实例
( 3 )根据配置文件注入依赖关系：先实例化依赖bean，然后将依赖bean注入
( 4 )返回一个完整的JavaBean实例

2 .使用静态工厂方法创建bean
public   interface  Being
... {
    public void testBeing();
}
public   class  Dog  implements  Being
... {
    private String msg;
    public void setMsg(Stirng msg) ...{
        this.msg = msg;
    }
    public void testBeing() ...{
        System.out.println(msg + "  狗爱啃骨头");
    }
}
public   class  Cat  implements  Being
... {
    private String msg;
    public void setMsg(String msg) ...{
        this.msg = msg;
    }
    public void testBeing() ...{
        System.out.println(msg + "  猫喜欢吃鱼");
    }
}

public   class  BeingFactory
... {
    /** *//**
     * 获取Being实例的静态工厂方法
     * param arg 静态工厂方法根据该参数决定返回Being的哪个实例
     */
     public static Being getBeing(String arg) ...{
        //调用此静态方法的参数为dog，则返回Dog实例
        if (arg.equalsIgnoreCase("dog"))
        ...{
            return new Dog();
        }
        else
        ...{
            return new Cat();
        }
     }
}

<? xml version = " 1.0 "  encoding = " gb2312 " ?>
<! DOCTYPE beans PUBLIC  " -//SPRING//DTD BEAN//EN "
     " http://www.springframework.org/dtd/spring-beans.dtd " >
< beans >
     < bean id = " dog "   class = " prolove.BeingFactory "  factory - method = " getBeing " >
         < constructor - arg >
             < value > dog </ value >
         </ constructor - arg >
         < property name = " msg " >
             < value > 我是狗狗 </ value >
         </ property >
     </ bean >
     < bean id = " cat "   class = " prolove.BeingFactory "  factory - method = " getBeing " >
         < constructor - arg >
             < value > cat </ value >
         </ constructor - arg >
         < property name = " msg " >
             < value > 我是猫猫 </ value >
         </ property >
     </ bean >
</ beans >

public   class  SpringTest
... {
    public static void main(String[] args) throws Exception ...{
        InputStream is = new FileInputStream("bean.xml");
        InputStreamResource isr = new InputStreamResource(is);
        XmlBeanFactory factory = new XmlBeanFactory(isr);
        System.out.println("程序已经实例化BeanFactory...");
        Being b1 = (Being)factory.getBean("dog");
        b1.testBeing();
        Being b2 = (Being)factory.getBean("cat");
        b2.testBeing();
    }
}
通过静态工厂方法创建实例时，必须要改变配置文件，主要有如下改变：
* class属性的值不再是bean对实现类，而是静态工厂类
* 必须使用factory - method属性确定产生实例的静态工厂方法
* 如果静态工厂方法需要参数，则使用 < constructor - arg > 元素确定静态工厂方法

3 .调用实例工厂方法创建bean
public   interface  Person
... {
    public String sayHello(String name);
    public String sayGoodbye(String name);
}
public   class  American  implements  Person
... {
    public String sayHello(String name) ...{
        return name + ",Hello";
    }
    public String sayGoodbye(String name) ...{
        return name + ",Goodbye";
    }
}
public   class  Chinese  implements  Person
... {
    public String sayHello(String name) ...{
        return name + ",您好";
    }
    public String sayGoodbye(String name) ...{
        return name + ",再见";
    }
}

public   class  PersonFactory
... {
    /** *//**
     * 获得Person实例的实例工厂方法
     * @ param ethnic 调用该实例工厂方法传入的参数
     * @ return 返回Person实例
     */
     public Person getPerson(String ethnic) ...{
        //根据参数返回Person接口的实例
        if (ethnic.equalsIgnoreCase("chin"))
        ...{
            return new Chinese();
        }
        else
        ...{
            return new American();
        }
     }
}

<? xml version = " 1.0 "  encoding = " gb2312 " ?>
<! DOCTYPE beans PUBLIC  " -//SPRING//DTD BEAN//EN "
     " http://www.springframework.org/dtd/spring-beans.dtd " >
< beans >
     < bean id = " personFactory "   class = " prolove.PersonFactory " />
     < bean id = " chinese "  factory - bean = " personFactory "  factory - method = " getPerson " >
         < constructor - arg >
             < value > chin </ value >
         </ constructor - arg >
     </ bean >
     < bean id = " american "  factory - bean = " personFactory "  factory - method = " getPerson " >
         < constructor - arg >
             < value > ame </ value >
         </ constructor - arg >
     </ bean >
</ beans >