2.Spring基本用法

  spring 中的xml配置相对于spring注解去注释，要早很多产生的，后期spring意识到，在大型的项目中越来越日益，庞大和臃肿，所以就产生了，注解的形式。

  1.bean的作用域:

       在spring容器中产生的bean，这个bean是有生命周期

      (1)singleton：单例模式，在springIOC中使用singleton来创建一个实例

      (2)prototype：原形模式,在每次getBean的时候都会产生一个新的Bean实例

      (3)request：对于每次Http请求，request定义的bean都会产生一个新的bean实例

      (4)session：对于每次HttpSession请求，使用session定义的bean都会产生一个新的bean实例 只有在web 中的spring 才会起到作用

       (5)global Session：使用全局的http session请求。

bean默认是的单例模式

 例如<bean id="xxx" class="test.xxx" scope="prototype"/> 原形模式创建的新的bean的实例

request和session则需要在web.xml配置监听或者filter,当http请求的时候在监听到或者过滤到

2.自动装配注入bean：

    (1)no：不自动装配

    (2)byName:根据属性名称来自动装配，beanFactory 查找容器中全部bean，找出其中的id与属性同名的Bean来完成注册

      例如:

              

<bean id="chinese"  class=“test.Chinese” autowire="byName"/>
             <bean id="gundong" class="test.Gudong"   autowire="byName">
                  <property name="name" value="wanwan"/> 
             </bean>

             在test.Chinese 这个类的java 代码中根据id名称和属性进行匹配

            

  public void setGundong(Dog dog){
                 this.dog=dog;
                }

    (3)byType：根据属性类型来自动装配，beanFactory 查找容器中全部bean，如果有匹配的这种类型的bean就会自动装配，如果有多个就会报异常。 

     例如:

            

  <bean id="chinese"  class=“test.Chinese” autowire="byType"/>
             <bean id="gundong" class="test.Gudong"   autowire="byType">
                  <property name="name" value="wanwan"/> 
             </bean>

             在test.Chinese 这个类的java 代码中根据传入的类型进行匹配

            

  public void setGundong(Dog dog){
                 this.dog=dog;
                }

    (4)constructor：与byType类似，只是不同的是通过构造器来进行装配，如果有多个就会报异常

    (5)autodetect：

3.bean的创建方式及依赖配置：

   (1)构造器创建bean：

        java代码中要创建一个默认构造器，当applicationContext进行spring容器的初始化的时候，相应的容器的中的所有的bean会调用代码中的默认的构造器，来创建对象，这个对象是单例的，然后再根据要文件注入的依赖关系，先实例化依赖bean,然后再依赖bean注入

   (2)静态工厂创建bean：

         例如:

           

   public interface Being {
	            //接口定义testBeing方法
	             public void testBeing();

</pre></p><pre name="code" class="java">    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 Dog implements Being {
	private String msg;
	
	public void setMsg(String msg) {
		this.msg = msg;
	}

	public void testBeing() {
		System.out.println(msg+"狗爱肯骨头");
	}
}

 

public class BeingFactory {
	
	public static Being getBeing(String arg){
		if (arg.equalsIgnoreCase("dog")) {
			return new Dog();
		}else {
			return new Cat();
		}
	}

}

 //bean.xml中

      <bean id="dog" class="factory.BeingFactory" <strong>factory-method="getBeing"</strong>>
		<constructor-arg value="dog"/>
		<property name="msg" value="我是狗"/>
	</bean> 
	<bean id="cat" class="factory.BeingFactory" <strong>factory-method="getBeing"</strong>>
		<constructor-arg value="cat"/>
		<property name="msg" value="我是猫"/>
	</bean> 

spring 容器通过反射来创建静态工厂的实例，然后调用静态的工厂的getBeing方法，然后利用构造器的注入传入一个值，然后就交给静态工厂来创建对象，然后再根据set注入值的方式,对静态工厂创建出来的对象进行set注入值

(3)实例工厂创建bean：

        <bean id="dog" class="factory.BeingFactory" factory-bean="personFctory"  factory-method="getPerson">
		<constructor-arg value="chin"/>
	</bean> 
	<bean id="cat" class="factory.BeingFactory" factory-bean="personFctory"   factory-method="getPerson">
		<constructor-arg value="ame"/>
	</bean> 
        <bean id="personFactory" class="factory.personFactory"/>

</pre><p></p><pre>

spring实例工厂创建bean与静态工厂创建bean不同的地方就是实例工厂要创建一个bean然后再去引用这个实例工厂的bean，而静态工厂不用创建bean