Spring（1）之 （1.2_Spring Core）IOC控制反转（IOC容器装配bean）

1. IOC容器装配bean：将对象的创建交给IOC容器

SpringIOC容器：　SpringIOC容器：是Spring-core即Spring的核心内容；　　作用：创建对象，处理对象的依赖关系

SpringIOC容器创建对象的几种方式：

1. 调用无参构造方法
2. 调用带参构造方法
3. 工厂创建对象：
   　工厂类：静态方法创建对象
   　　　　　 非静态方法创建对象

1、调用无参构造
2、调用带参构造
（xml 文件中当< bean>中的< constructor-arg>标签没有添加 index 属性时，要注意多个属性的顺序； type 属性要写类的全名（如: java.lang.String，不可以写 string）； ref 属性引用已经存在的 bean对象；）
3、工厂创建对象
（工厂类 非静态方法创建对象，先创建工厂类的实例， class 属性是工厂类的全名（即指定工厂类的类型），再通过 factory-bean 属性来引用生成的工厂类实例，通过 factory-method 来调用工厂类中非静态方法；
工厂类 静态方法创建对象，class 属性是工厂类的全名（即指定工厂类的类型），再使用 factory-method 来调用工厂类中的静态方法；）
1.1．User.java
（当调用有参构造创建对象时，没有赋值即方法中没有this.id=id和this.name=name时对象的属性无值，与调用无参构方时运行结果一样；只有当pojo类的带参构方中添加this…,对应的 xml文件中再进行赋值，创建的对象属性值才会存在。）

public class User{  
	private int id;
	private String name;
	set、get(); 

	public User(){
		System.out.println("----对象被创建----");
		System.out.println("----无参构造----");
	}
	public User(int id,String name){
		System.out.println("----对象被创建----");
		System.out.println("----有参构造----");
		this.id=id; //
		this.name=name; //
	}
	public void init_user(){
	    	System.out.println("------对象初始化-----")
	}
	public void destory_user(){
	    	System.out.println("------对象销毁-----")
	}	  
}

1.２．bean.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 1.调用无参构造 -->
　  <bean id="user" class="com.mdd.User"></bean>

    <!-- 2.调用带参构造 -->
　  <bean id="user2" class="com.mdd.User">
　      <constructor-arg value="101"></constructor-arg>//age
　      <constructor-arg value="tom"></constructor-arg>//name
　      //<constructor-arg value="tom" index="1" type="java.lang.String"></constructor-arg>
　      //<constructor-arg value="101" index="0" type="int"></constructor-arg>
　  </bean>
　  
　  <!-- 2.带参构造，引用其他对象 -->
    <bean id="s" class="java.lang.String">
    	<constructor-arg value="jay"></constructor-arg>
    </bean>
　  <bean id="user3" class="com.mdd.User">
　      <constructor-arg ref="s"></constructor-arg>
　      <constructor-arg value="101"></constructor-arg>
　  </bean>
　  
　  <!-- 3.工厂创建对象，非静态方法 -->
    <bean id="userFactory" class="com.asd.UserFactory"></bean>//工厂类的实例
    <!-- 使用实例方法创建对象 -->
　  <bean id="user4" factory-bean="userFactory" factory-method="getInstance"></bean>
　  
　  <!-- 3.工厂创建对象，静态方法 -->
    <bean id="user5" class="com.asd.UserFactory" factory-method="getStaticInstance"></bean>

</beans>

1.３．Test.java

public class Test{
	public static void main(String[] args) {	    
	    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean.xml");
	    System.out.println("------得到IOC容器------");
	    //User user=(User)applicationContext.getBean("user");
	    User user=(User)applicationContext.getBean("user2");//user3、user4、user5
	    System.out.println(user);
	}     
}

1. 调用无参构造运行结果：

2. 调用带参构造（bean中只添加 value属性且顺序没写错 /
bean中顺序错但添加 index属性时 / 添加 type属性且String类写全名时 / 调用带参构造，ref 属性引用其他对象）运行结果：

2.1 调用带参构造（bean中未写 index属性且顺序错时 / type属性中未写 java.lang.String而写 string时）运行结果：（报错）
3、工厂创建对象
３.1 User.java
３.2 UserFactory.java

public class UserFactory{
	/*非静态方法*/
	public User getInstance(){
		System.out.println("使用工厂类中的非静态方法");
		//return new User();
		return new User(102,"Herry");
	}
	/*静态方法*/
	public static User getStaticInstance(){
		System.out.println("使用工厂类中的静态方法");
		//return new User();
		return new User(103,"Jack");
	}
}

３.3 bean.xml （上）

使用工厂类中的非静态方法运行结果：

使用工厂类中的静态方法运行结果：