spring容器创建bean对象的方式以及如何处理多个spring配置文件

spring学习教程7-spring容器创建bean对象的方式以及如何处理多个spring配置文件 

spring容器创建bean对象的方式以及如何处理多个spring配置文件

1.spring容器创建bean对象的方式

注意：我们之前说的DI依赖注入是对于bean对象的属性的注入，是如何给属性赋值，如何配置属性，并不是创建对象。

（1）xml文件中有bean的配置,而且这个bean所对应的java类中存在一个无参构造器,那么这个时候spring容器就可以使用反射调用无参构造器来创建实例了(常规的方式)；所以默认下我们是用无参构造器来创建bean的。这里和我们就是我们原来的做法，不进行代码演示，如果想测试，可以把一个bean类的无参构造器去掉，发现程序会报错。

（2）通过工厂类获得实例(工厂类实现了接口FactoryBean<?>)
注意spring中的PropertyPlaceholderConfigurer类的使用,在htmlsingle中直接搜索类名即

例如:
//工厂类实现指定接口并且实现接口中的三个抽象方法:
   

[java] view plain copy
 
  1. public class ConnectionFactory implements FactoryBean<Connection>{  
  2.         private String driver;  
  3.         private String url;  
  4.         private String username;  
  5.         private String password;  
  6.   
  7.   
  8.         @Override  
  9.         public Connection getObject() throws Exception {  
  10.             Class.forName(driver);  
  11.             Connection conn =   
  12.                 DriverManager.getConnection(url,username,password);  
  13.             return conn;  
  14.         }  
  15.   
  16.   
  17.         @Override  
  18.         public boolean isSingleton() {  
  19.             return false;  
  20.         }  
  21.           
  22.         @Override  
  23.         public Class<Connection> getObjectType() {  
  24.             return Connection.class;  
  25.         }  
  26.         set/get  
  27.         ....  
  28.     }  
其实这种方法就是用spring的类来实现的工厂创建bean，所以必须实现spring的FactoryBean接口，在后面我们可以通过我们熟悉的一般工厂类来创建bean，俩者比较，你会更清楚这种方法的过程。不过这种方法感觉不好用。

      
    xml文件:

<!-- 
    下面配置的这个类,可以自动的帮我们去读取指定的properties文件的内容,文件中用key-value的形式存放数据,读完之后我们就可以用${key}这种形式去拿文件中的value值了
在htmlsingle中直接搜索类名即可得到相关配置样例
    classpath指的是从src下面找.
    -->
   
[html] view plain copy
 
  1. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  2.     <property name="location">  
  3.         <value>classpath:oracle.properties</value>  
  4.     </property>  
  5.    </bean>  
上面这个代码是配置类PropertyPlaceholderConfihurer的使用，代码的作用就是加载properties配置文件，在下面的配置中使用。 Spring 2.5 之后: 可通过 <context:property-placeholder> 元素简化:
[html] view plain copy
 
  1. <context:property-placeholder location="classpath:beanProperty.properties"/><span style="font-size:16px;text-align:justify;font-family:'Microsoft YaHei', SimHei, Arial;background-color:rgb(255,255,255);"> </span>  

 <!-- 
    因为这个类是一个工厂类,所以我们用名字conn在容器中拿对象的时候,
    拿到并不是这个工厂类对象,而是这个工厂类对象调用完工厂方法后所返回的对象.
    -->
   

[html] view plain copy
 
  1. <bean name="conn" class="com.briup.ioc.factory.ConnectionFactory">  
  2.     <property name="driver">  
  3.         <value>${driver}</value>  
  4.     </property>  
  5.       
  6.     <property name="url">  
  7.         <value>${url}</value>  
  8.     </property>  
  9.       
  10.     <property name="username">  
  11.         <value>${username}</value>  
  12.     </property>  
  13.       
  14.     <property name="password">  
  15.         <value>${password}</value>  
  16.     </property>  
  17.    </bean>  

    上面的代码是配置bean的工厂类，然后得到bean
[html] view plain copy
 
  1. main:  
  2.         String path = "com/briup/ioc/factory/factory.xml";  
  3.         ApplicationContext container =   
  4.             new ClassPathXmlApplicationContext(path);  
  5.         Connection conn =   
  6.             (Connection)container.getBean("conn");  
  7.   
  8.   
  9.         System.out.println(conn);  
（3）.通过实例工厂获得bean对象(不需要实现或者继承任何接口或者父类),就是一个普通的工厂实例instanceFactory
//一个普通的工厂类 
    
[java] view plain copy
 
  1. public class CatFactoryBean {  
  2.       
  3.     public Cat getCat(int id,String name){  
  4.         return new Cat(id, name);  
  5.     }  
  6. }  
这时一般我们写的工厂类
[html] view plain copy
 
  1. <bean id="catFactory" class="com.hoperun.spring.CatFactoryBean"></bean>  
  2.      <bean id="cat" class="com.hoperun.spring.Cat" factory-bean="catFactory" factory-method="getCat">  
  3.         <constructor-arg value="22"></constructor-arg>  
  4.         <constructor-arg value="fengwei"></constructor-arg>  
  5.      </bean>  
这时配置文件，可以看到，先是配置了工厂的bean，然后在配置bean，关键实在bean的属性中有factory-bean和factory-method，指定了工厂类和得到这个bean对象对应的方法，下面constructor-arg是方法的参数，通过这样，我们就得到了对象。

（4）通过静态工厂获得实例

静态工厂：就是得到工厂的方法是静态的

[java] view plain copy
 
  1. public static Cat getCat1(int id,String name){  
  2.     return new Cat(id, name);  
  3. }  
[html] view plain copy
 
  1. <bean id="cat" class="com.hoperun.spring.CatFactoryBean" factory-method="getCat1">  
  2.     <constructor-arg value="2222"></constructor-arg>  
  3.     <constructor-arg value="fengwei"></constructor-arg>  
  4.  </bean>  
这样我们就配置好了，可以看到，和实例工厂相比较还是bean属性的问题，静态工厂不需要建立bean，在class中填入静态工厂类就可以了，然后指定方法，参数。

2，处理多个配置文件

我们发现spring的配置文件每次都是指定加载的applicationContext.xml，如果把所有的bean配置都加入一个文件中，太大了，所以spring的配置文件是可以有多个的，多个文件可以一起加载。方法一：ClassPathXmlApplicationContext(),它有几个重载的构造器，参数不一样，可以是一个String[]数组，这样就明白了，可以将所有的名字都放在数组里，让它加载。

方法二：如果我们在spring框架中配置了多个xml文件,我们可以在读取配置文件的时候把这些xml文件一下全都读取,也可以只读一个总的xml文件,在这个总的xml文件中把其他的xml全都都导入进来。
例如:

[java] view plain copy
 
  1. student.xml文件:  
  2.     <bean name="student" class="com.briup.bean.Student">  
  3.         <property name="id">  
  4.             <value>25</value>  
  5.         </property>  
  6.     </bean>  
  7.       
  8.     teacher.xml文件:  
  9.     <bean name="teacher" class="com.briup.bean.Teacher">  
  10.         <property name="student" ref="student"></property>  
  11.     </bean>  
  12.   
  13.   
  14.     import.xml文件:  
  15.     <import resource="teacher.xml"/>  
  16.     <import resource="student.xml"/>  
  17.   
  18.   
  19.     main:  
  20.     String[] path = {"com/briup/ioc/imp/import.xml"};  
  21.     ApplicationContext container =   
  22.             new ClassPathXmlApplicationContext(path);  
  23.   
  24.   
  25.     Teacher t = (Teacher) container.getBean("teacher");  
  26.     System.out.println(t.getStudent());  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/erma0-007/p/8655313.html