（二）Spring IOC容器

使用Spring IOC容器(用new对象的方式去创建实例，交给IOC容器去创建对象实例)

1.创建JAVA工程
创建java项目，新建lib文件夹，导入spring jar包，选择jar包 build pats→add to build pats
在src下新建pojo文件夹（实体类），创建实体类Student.java；
在src下新建Spring 配置文件application.xml；步骤：选择src文件夹右击New→Other→Spring→Spring Bean Configuration File 。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
<!-- 注册一个Studnet对象到IOC容器中 id: 对象名 class: 指定对象的类型 ，取值为类全名，作用是框架根据类全名进行反射 创建对象 相当于：Student st = new Student() --> 

<bean id="st" class="com.bjlemon.pojo.Student" > </bean>
</beans>

2.测试
在src下新建test文件夹，新建测试类：

 public class SpringTest { public static void main(String[] args) { 
 //原始方式 //
 Student st = new Student(); 
 st.sayHello(); 
//Spring IOC方式
//1 创建容器 
ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml"); 
Student st2 = (Student)ioc.getBean("st");
st2.sayHello(); 
 	}
 }

创建Bean的方式(JavaBean : 是企业应用中对组件抽象)

1. 基于构造器 创建对象实例

<!-- 构造器方式 class的名称是类的全路径--> 
<bean id="d1" class="com.bjlemon.pojo.Dog"/>

构造器创建对象的底层代码：

String className= "com.bjlemon.pojo.Dog";
Class cls= Class.forName(className);
Object dd= cls.newInstance();

2. 静态工厂方法 创建对象实例

<!-- 通过静态工厂方法；name的名称可以是多个，最好是一个；factory-method工厂方法的名称“getDog”是自己取的，该方法是static静态方法--> 
<bean name="d2,d3" class="com.bjlemon.pojo.DogFactory" factory-method="getDog"/>

3. 工厂实例方法 创建对象实例

<!--1.创建工厂 --> 
<bean name="factory" class="com.bjlemon.pojo.DogFactory"/> 
<!--2.调用工厂方法 factory-bean是工厂实例的name的名称，factory-method的值是自定义方法的名称，该方法是实例对象的普通方法--> 
<bean name="d4" factory-bean="factory" factory-method="getDogInstance"/>

以上3种创建对象的方法，都相当于new 对象，加载时都会调用对象的无参构造器。
生产工厂类：

public class DogFactory {
    /**
     * 创建Dog对象的工厂
     * 生产黄色小狗，2岁，攻击力100
     */
    public static Dog getDog() {
        Dog dog = new Dog();
        dog.setName("黄色小狗");
        dog.setAge(2);
        dog.setGjl(100);
        System.out.println("---");
        return dog;
    }

    /**
     * 成员方法
     * 生产黄色小狗，2岁，攻击力100
     */
    public Dog getDogInstance() {
        Dog dog = new Dog();
        dog.setName("黄色小狗");
        dog.setAge(2);
        dog.setGjl(100);
        System.out.println("---");
        return dog;
    }
}

Bean的生命周期（bean的生命周期，指的是bean 创建 ，初始化，销毁的各个阶段）

application.xml文件：

<!-- 初始化init-method=“自己的监听方法init”；销毁destroy-method=“自己的监听方法destory；只作用于该bean--> 
<bean name="myDog" class="com.bjlemon.pojo.Dog" init-method="init" destroy-method="destory"/>

1. 创建：通过无参构造器可获得；
2. 初始化：init-method=“自己的监听方法”；
3. 销毁：destroy-method=“自己的监听方法。
   全局配置application.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
	default-init-method="init" default-destroy-method="destory">

Bean作用域

<!-- scope取值:prototype 原型模式，每次创建一个新的;singleton单例模式，第一次创建，然后被缓存，以后都返回这一个相同的对象 --> 
<bean name="dog" class="com.bjlemon.pojo.Dog" scope="prototype"/>

Bean懒加载(懒加载也叫延迟加载，只有使用时才去加载)

<!-- lazy-init 取值true ：表示启用懒加载;default 默认是false表示禁用懒加载;lazy-init属性加在bean中只作用于改bean--> 
<bean name="dog" class="com.bjlemon.pojo.Dog" scope="singleton" lazy-init="true"/>

全局配置：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
	default-init-method="init" default-destroy-method="destory"  default-lazy-init="true">

依赖注入（set赋值,有参构造函数赋值）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean name="p1" class="pojo.Person">
		<!-- 为属性赋值 -->
		<property name="name" value="王老五"></property>
		<property name="age">
			<value>40</value>
		</property>
		<property name="car" ref="myCar"/>
		<!-- 说明： name：属性名字，但是底层会根据属性名推测 set方法 推测原理:  set + 属性首字母大写 - setName  setAge
		    value：属性的值: 支持 8大基本数据类型 和String类型；ref：属性引用值: 引用类型属性赋值
		  -->
	</bean>
	<bean name="myCar" class="pojo.Car">
	     <property name="brand" value="奥迪"/>
	     <property name="name" value="A6L"/>
	     <property name="price" value="300000"/>
	 </bean>
</beans>

1. Set注入：调用set方法注入
步骤：1.创建实例类Preson，Car；2.创建测试类SpringTest

public class Person {

    private String name;
    private Integer age;

    private Car car;

    public Person() {

    }

    public Person(String name, Integer age, Car car) {

        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
}

public class Car {
    private String brand;
    private String name;
    private Double price;

    public Car() {

    }

    public Car(String brand, String name, Double price) {

        this.brand = brand;
        this.name = name;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + ", name=" + name + ", price=" + price + "]";
    }
}

测试类：

public class SpringTest {

    ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");

    @Test
    public void test1() {
        Person p1 = (Person) ioc.getBean("p1");
        System.out.println(p1);
    }
}

2. 构造器注入 : 调用构造器注入
步骤：1.在Car实体类中添加有参构造函数 public Car(String brand, String name, Double price)；2.application.xml文件添加bean

<!-- 第一种：属性赋值 -->
<bean name="yourCar" class="com.bjlemon.pojo.Car"> 
<constructor-arg name="name" value="X6"/> 
<constructor-arg name="brand" value="宝马"/> 
<constructor-arg name="price" value="500000"/> 
</bean>
<!--  第二种：下标赋值 -->
<bean name="heCar" class="com.bjlemon.pojo.Car">
<constructor-arg index="0" value="吉利"/> 
<constructor-arg index="1" value="博瑞"/> 
<constructor-arg index="2" value="120000"/> 
</bean>
<!-- 对象赋值:ref="yourCar" -->
<bean name="p2" class="com.bjlemon.pojo.Person">
<constructor-arg name="name" value="李小龙"/>
<constructor-arg name="age" value="100"/>
<constructor-arg name="car" ref="yourCar"/>
</bean>

集合注入

<bean name="p3" class="com.bjlemon.pojo.Person"> 
	<property name="name" value="刘德华" /> 
	<property name="age" value="55" /> 
	<property name="car" ref="myCar" /> 
	<!-- List 注入 --> 
	<property name="list">
		<list>
			<value> 苹果 </value> 
			<value> 900 </value> 
			<!--引用 bean对象--> 
			<ref bean="yourCar" /> 
			<!--内部匿名bean对象，不需要name--> 
			<bean class="com.bjlemon.pojo.Car"> 
				<constructor-arg index="0" value="吉利" /> 
				<constructor-arg index="1" value="博瑞" /> 
				<constructor-arg index="2" value="120000" /> 
			</bean> 
		</list> 
	</property> 
	<!-- set集合注入 --> 
	<property name="sets"> 
		<set>
			<value>电视</value> 
			<value>手机</value> 
			<ref bean="p1"/> 
		</set> 
	</property>
	<!-- map注入 --> 
	<property name="maps"> 
		<map>
			<entry key="s1" value="语文"/> 
			<entry key="s2" value="数学"/> 
			<entry key="s3" value-ref="p1"/> 
		</map> 
	</property> 
</bean>

自动注入

<bean name="car" class="com.bjlemon.pojo.Car" > 
	<property name=" brand" value="奥迪" /> 
	<property name="name" value="A6L" /> 
	<property name="price" value="300000.33" /> 
</bean> 
<bean name="yourCar" class="com.bjlemon.pojo.Car" > 
	<constructor-arg name="name" value="X6" /> 
	<constructor-arg name="brand" value="宝马" /> 
	<constructor-arg name="price" value="500000" /> 
</bean> 
<bean name="heCar" class="com.bjlemon.pojo.Car" > 
	<constructor-arg index="1" value="吉利" /> 
	<constructor-arg index="0" value="博瑞" /> 
	<constructor-arg index="2" value="120000" /> 
</bean>

<!-- autowire="byName" 根据实体类Person中的属性名字 car 从ioc容器中选择同名car的bean自动注入 --> 
<bean name="pp" class="com.bjlemon.pojo.Person" autowire="byName"> </bean>

<!-- autowire="byType" 根据实体类Person中具有的Car类型, 根据属性类型 从ioc容器中选择同类型的bean注入，可能出现异常，可能找到多个满足条件的bean，这时，可以设置其它 bean 为非候选bean autowirecandidate="false" --> 
<bean name="pp1" class="com.bjlemon.pojo.Person" autowire="byType"> </bean>

<!-- 可以设置其它 bean 为非候选bean autowirecandidate="false" 放弃自动注入. 例如：我们想注入 第一个car 让其它两个 bean 放弃自动注入。--> 
<bean name="car" class="com.bjlemon.pojo.Car" > 
<bean name="yourCar" class="com.bjlemon.pojo.Car" autowire-candidate="false" > 
<bean name="heCar" class="com.bjlemon.pojo.Car" autowire-candidate="false" >

<!-- autowire="constructor"根据构造器参数类型注入，但是会优先考虑名字。autowire="no": 不注入 autowirte="default":默认注入方式,就是no--> 
<bean name="pp2" class="com.bjlemon.pojo.Person" autowire="constructor"> 
	<constructor-arg name="name" value="张三丰"/> 
	<constructor-arg name="age" value="150"/> 
	<!-- 这个参数自动注入 --> 
</bean>