Spring学习记录(二)---容器和bean属性配置

下载spring包，在eclipse搭建spring环境。

这步我在eclipse中无法导入包，看网上的：

http://sishuok.（和谐）com/forum/blogPost/list/2428.html

建一个java project

三个java文件，一个xml文件

 package com.guigu.spring.beans;

 public class HelloWord {
     private String name;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public  void hello(){
         System.out.println("hello: "+name);
     }
 }

 import java.applet.AppletContext;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.AbstractApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class Main {
     public static void main(String[] args) {
 //  传统调用方式
 //        HelloWord h = new HelloWord();
 //        h.setName("evan");
 //        h.hello();
         //1、读取配置文件实例化一个IoC容器  ，会动态创建对象，调用构造函数，xml中有属性还会调用setname()
         ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
         //2、从容器中的id获取Bean，注意此处完全“面向接口编程，而不是面向实现”
          HelloWord hello = (HelloWord) context.getBean("helloword");
          //3、执行业务逻辑
          hello.hello();
     }

 }

 <?xml version="1.0" encoding="UTF-8"?>
 <beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context                http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   <!-- id 表示你这个组件的名字，class表示组件类 -->
   <bean id="helloword" class="com.guigu.spring.beans.HelloWord">
         <property name="name" value="Spring"></property>
     </bean>
</beans>  

helloword是一个id标识，它属于com.guigu.spring.beans.HelloWord类，是它的一个实例。一个类可以有多个实例。所以可以有多个bean的类相同，表示一个类的不同实例。

bean中可以添加属性，用property属性

IoC容器

用的是ApplicationContext（应用上下文），它是由BeanFactory（Bean工厂）扩展而来，BeanFactory提供了IoC容器最基本功能如： getBean();

ApplicationContext扩展了BeanFactory，还提供了与Spring AOP集成、国际化处理、事件传播及提供不同层次的context实现。

【  ApplicationContext 的初始化和BeanFactory 有一个重大的区别：BeanFactory在初始化容器时，并未实例化Bean，直到第一次访问某个Bean 时才实例目标Bean，即调用getBean才初始化；而ApplicationContext 则在初始化应用上下文时就实例化所有单实例的Bean 。】

（了解更多去大牛博客：http://elf8848.iteye.com/blog/324796）

ApplicationContext的实现有两个：

• ClassPathXmlApplicationContext：从类路径获取配置文件。

 ApplicationContext context = new ClassPathXmlApplicationContext("application.xml") 

• FileSystemXmlApplicationContext：从文件系统获取配置文件。

ApplicationContext context = new FileSystemXmlApplicationContext("c:/application.xml");  

ApplicationContext获取bean的方法：

1、通过id获取容器中的bean

 ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
 HelloWord hello = (HelloWord) context.getBean("helloword");  

2、通过类类型获取。但是只能在HelloWord类只有一个bean对象才行，不然就不知道到底获取哪一个而报错

  ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
  HelloWord hello = context.getBean(HelloWord.class);  //不用类型强转，因为已经知道返回类型了

IOC容器注入依赖资源，三种注入方式：

1、属性注入（最常用）

2、构造器注入

3、工厂方法注入（很少用，不推荐）

属性注入：通过setter方法注入；使用<property>，使name属性指定bean的属性名称

 <property name="name" value="Spring"></property>

表示bean所在类有一个name属性，值是Spring

构造器注入 

用bean里的constructor-arg属性

例子--新建一个Car类

 public class Car{
     private String brand;
     private String corp;
     private double price;
     private int maxSpeed;
 }
   public Car(String brand,String corp,double price){
     super();
     this.brand=brand;
     this.corp=corp;
     this.price=price;
 }

xml中添加，index表示对应的属性，若不写，默认按顺序匹配

 <bean id="car" class="com.guigu.spring.beans.Car">
      <constructor-arg value="aodi" index="0"></constructor-arg>
      <constructor-arg value="ShangHai" index="1"></constructor-arg>
      <constructor-arg value="300000" index="2"></constructor-arg>
  </bean>

main函数中

   ApplicationContext ctx= new ClassPathXmlApplicationContext("application.xml");
   HelloWord car=ctx.getBean(Car.class);
   system.out.println(car); //调用Car中的toString函数，已省略

输出结果：Car [brand=aodi, corp=ShangHai, price=300000, maxSpeed=0];

若构造函数是多个呢？重载的构造函数，xml中对应哪一个呢？

 public class Car{
       private String brand;
       private String corp;
       private double price;
       private int maxSpeed;
   }
     public Car(String brand,String corp,double price){
       super();
       this.brand=brand;
      this.corp=corp;
      this.price=price;
  }
      public Car(String brand,String corp,int maxSpeed){
       super();
       this.brand=brand;
      this.corp=corp;
      this.maxSpeed=maxSpeed;
  }

  <bean id="car2" class="com.guigu.spring.beans.Car">
       <constructor-arg value="aodi" type="java.lang.String"></constructor-arg>   //除基本类型外，其余都要写全类名
       <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg>
       <constructor-arg value="240" type="int"></constructor-arg>   //基本类型，不用谢全类名
   </bean>

    ApplicationContext ctx= new ClassPathXmlApplicationContext("application.xml");
    HelloWord car=ctx.getBean("car");
    system.out.println(car);
    HelloWord car=ctx.getBean("car2");
    system.out.println(car); 

输出结果：

Car [brand=aodi, corp=ShangHai, price=300000.0, maxSpeed=0];

Car [brand=aodi, corp=ShangHai, price=0.0, maxSpeed=240];

总结：通过构造器方法时，可以用参数的位置和参数的类型来区分重载构造函数，位置和参数是可以同时使用,如下

  <bean id="car" class="com.guigu.spring.beans.Car">
        <constructor-arg value="aodi" index="0"></constructor-arg>
        <constructor-arg value="ShangHai" index="1"></constructor-arg>
        <constructor-arg value="240" type="int"></constructor-arg>
    </bean>

细节1:value用节点表示

   <bean id="car" class="com.guigu.spring.beans.Car">
         <constructor-arg value="aodi" index="0"></constructor-arg>
         <constructor-arg value="ShangHai" index="1"></constructor-arg>
         <constructor-arg  type="int">
             <value>240</value>
         </constructor-arg>
     </bean>                

这个可以解决value是特殊字符的问题 如：<ShangHai> ,直接字面写就报错，用value节点再结合<![CDATA[]]解决

    <bean id="car" class="com.guigu.spring.beans.Car">
           <constructor-arg value="aodi" index="0"></constructor-arg>
           <constructor-arg index="1">
               <value><![CDATA[<ShangHai>]]></value>  // 值是:<ShangHai>
           </constructor-arg>
           <constructor-arg value="240" type="int">
           </constructor-arg>
       </bean>          

细节2：属性是引用类型 ref元素或ref属性

若又一个Person类，有一个Car属性，Car就是前面的对象

   public class Person{
         private String name;
         private Car car;
     }

     public  void setName(String name){
             this.name=name;
     }
     public getName(){
             return name;
     }
     public  void setCar(Carcar){
             this.car=car;
     }
     public getCar(){
             return car;
     }

   }

用ref="car2" 指向之前的car2对象，来引用；同样可以改成节点式<ref bean="car2"/>

  <bean id="person" class="com.guigu.spring.beans.Person">
         <property name="name" value="Tom"></proerty>
         <property name="car" ref="car2"></proerty>
     </bean>              

细节3：内部bean,达到和引用的目的。但这个bean不能被外部引用，只能自己内部使用

   <bean id="person" class="com.guigu.spring.beans.Person">
          <property name="name" value="Tom"></proerty>
          <property name="car">
                 <bean class="com.guigu.spring.beans.Car">
                     <constructor-arg value="Ford"></constructor-arg>
                     <constructor-arg value="ChangAn"></constructor-arg>
                     <constructor-arg value="200000" type="double"></constructor-arg>
                 </bean>
          </proerty>
      </bean>           

细节4：赋空值: <null/>;或者，直接不写就行。

  <bean id="person" class="com.guigu.spring.beans.Person">
            <property name="name" value="Tom"></proerty>
            <property name="car">
                   <bean class="com.guigu.spring.beans.Car">
                       <constructor-arg value="Ford"></constructor-arg>
                       <constructor-arg value="ChangAn"></constructor-arg>
                       <constructor-arg><null/></constructor-arg>
                   </bean>
            </proerty>
       </bean>        

细节5：像struts一样，可以为级联属性赋值。它调用了改属性的set方法，所以类中必须要有改属性的set方法。

   <bean id="person" class="com.guigu.spring.beans.Person">
          <constructor-arg

name

="name" value="Tom"></constructor-arg>  <constructor-arg name="car" ref="car2">  <property name="car.maxSpeed" value="230"></property> //   </constructor-arg>  </bean>

注意：和struts不同，不能不初始化直接赋值

     <bean id="person" class="com.guigu.spring.beans.Person">
            <property name="name" value="Tom"></proerty>
            <!--
            <property name="car">
                   <bean class="com.guigu.spring.beans.Car">
                       <constructor-arg value="Ford"></constructor-arg>
                       <constructor-arg value="ChangAn"></constructor-arg>
                       <constructor-arg value="200000" type="double"></constructor-arg>
                   </bean>
            </proerty>
            -->
            <property name="car.maxSpeed" value="260"></property>
       </bean>           

这里的意思是，不创建car对象，直接对它的属性赋值。

在struts中可以，会自动先创建一个car对象，然后赋值。二spring不可以，必须先初始化一个对象，再赋值。

细节6：集合属性赋值

一个person可以有多个car，怎么表示？  如下，用节点<list>  。数组list和Set与集合类似。也可以用内部bean

     public class Person{
           private String name;
           private List<Car> cars;
       }

       public  void setName(String name){
               this.name=name;
       }
       public getName(){
              return name;
      }
      public  void setCar(List<Car> cars){
              this.cars=cars;
      }
      public List<Car> getCars(){
              return cars;
      }

    }

    <bean id="person1" class="com.guigu.spring.beans.Person">
           <constructor-arg name="name" value="Tom"></constructor-arg>
           <property name="car">
                  <list>
                       <ref bean="car1"/>
                       <ref bean="car2"/>
                  </list>
           </property >
       </bean>   

注意：集合中Map又不一样，因为它是键值对,用<map>、entry

 public class NewPerson{
     private String name;
     private Map<String, Car> cars;

     public String getName(){
         return name;
     }
     public void setName(){
         this.name=name;
     }
     public Map<String, Car> getCars(){
         return cars;
     }
     public void setCars(Map<String, Car> cars)    {
     this.cars=cars;
 }

     <bean id="newPerson" class="com.guigu.spring.beans.Person">
            <property name="name" value="evan"></property >
            <property name="cars">
                   <map>
                        <entry key="AA" value-ref="car"/>
                        <entry key="BB" value-ref="car2"/>
                    </map>
            </property >
        </bean>   

细节7：配置properties 。 一个DataSource类，xml配置properties。如连接数据库

 public class DataSource{
      private Properties properties;
      public Properties getProperties(){
        return properties;
 }
      public void setProperties(Properties properties){
             this.properties = properties;
 }

 <bean id="dataSource" class="com.guigu.spring.beans.DataSource">
     <property name="properties">
          <props>
                <prop key="user">root<prop>
                <prop key="password">1234<prop>
                <prop key="jdbcUrl">jdbc:mysql://test<prop>
          </prop>
     <properties>
 </bean>

 DataSource datasource = ctx.getBean(DataSource.class);
 System.out.print(datasource.getProperties);

输出：

{user=root, password=1234, jdbcUrl=jdbc://test}

细节8：上面集合的配置，如果多个对象要使用，怎么提高内部属性的利用率<props>、<map>。用一个util命名空间

//单独拿出来，可以供多个bean调用
<util:list id="cars">
　　<ref bean="car"/>
　　<ref bean="car2"/>
</util:list>
//引用
<bean id="person3" class="com.guigu.spring.beans.Person">
    <property name="name" value="jack"></property >
    <property name="cars" ref="cars"></property >
</bean>