个人博客网：https://wushaopei.github.io/    (你想要这里多有)

1、什么是IOC

IOC 全称指的是 Inverse Of Control 控制反转。

原来我们使用Spring之前对象都是通过代码 new 对象()来自己进行创建。

现在使用了Spring之后。只需要在Spring的配置文件中进行配置，那么spring就会帮我们new出对象来。

2、什么是DI

DI 指的是Dependency Injection 。是依赖注入的意思。

BookService{
    BookDao bookDao;    public void setBookDao( BookDao bookDao ){
        this.bookDao = bookDao;
    }
}

只需要配置就可以把依赖的对象的值注入到引用中。

3、第一个IOC示例程序 — 通过id获取对象（重点）

实验1：通过IOC容器创建对象，并为属性赋值★

1、创建一个Java工程：

​

创建相应的类

​

person类代码

为节省空间，省略get\set方法，toString不写

package com.webcode.pojo;
import java.util.List;
import java.util.Map;
import java.util.Properties;/** * @author Administrator *
 */
public class Person {private Integer id;
private String name;
private Integer age;
private String phone;
private Car car;public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(Integer id, String name, Integer age, String phone, Car car) {
super();
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
this.car = car;
}

Car 类的代码

public class Car {/*
    省略 get\set方法 和 toString方法不写
*/
private String name;
private String carNo;
public Car() {
super();
// TODO Auto-generated constructor stub
}
public Car(String name, String carNo) {
super();
this.name = name;
this.carNo = carNo;
}
}

2、导入jar包：

• commons-logging-1.1.3.jar
• log4j-1.2.17.jar
• spring-beans-4.3.18.RELEASE.jar
• spring-context-4.3.18.RELEASE.jar
• spring-core-4.3.18.RELEASE.jar
• spring-expression-4.3.18.RELEASE.jar

applicationContext.xml配置文件内容如下：

<!--
bean标签标识要配置一个bean对象
class 属性配置你要陪哪个Bean对象的全类名
id 属性给配置的Bean对象起一个唯一标识
 -->
<bean id="p1" class="com.webcode.pojo.Person">
<!--
property 标签配置属性的值
name 标识你要配置哪个属性
value 属性配置这个属性的值
 -->
 <property name="id" value="1"></property>
 <property name="name" value="旻"></property>
<property name="age" value="25"></property>
 <property name="phone" value="148999999"></property>
</bean>

测试的代码：

        @Test
public void test1()throws Exception {
//ApplicationContext 表示SpringIOC 容器
ApplicationContext applicationContext  =  new ClassPathXmlApplicationContext("applicationContext.xml");
//使用了Spring之后。对象都交给Spring窗口来创建和管理
//Spring 容器就是一个map，然后id是key class 时哪个value
Person person = (Person) applicationContext.getBean("p1");
System.out.println(person);
}

打印结果：

​

问题：

1、FileSystemXmlApplicationContext怎么用?

答：跟使用JavaSE的相对路径一样

2、Bean是在什么时候被创建的?

答：在创建Spring容器的时候，创建Bean对象（默认）

1. 如果调用getBean多次，会创建几个?

答：默认创建同一个

常见的错误：

指定的id不存在。找不到bean对象。

​

4、IOC示例程序 — 通过类型获取对象（重点）

实验2：根据bean的类型从IOC容器中获取bean的实例★

配置文件代码：

<bean id="p2" class="com.webcode.pojo.Person" >
<!-- property 标签配置属性的值
name 标识你要配置哪个属性
value 属性配置这个属性的值 --> <property name="id" value="2"></property>
 <property name="name" value="旻"></property>
<property name="age" value="25"></property>
 <property name="phone" value="148999999"></property>
</bean>

      @Test
      public void test2()throws Exception{
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml"); *
 * 按类型查找，找到一个就直接返回
 * 没有找到就报错
 * 找到多个也报错
 *
System.out.println(applicationContext.getBean(Person.class));
}

常见错误说明：

按类型查找，找不到就报错

​

当在applicationContext.xml配置文件中。有多个同Person.class类型实现的时候。

​

5、IOC示例程序 — 通过构造方法参数名注入值

实验3：通过构造器为bean的属性赋值

        <bean id="p3" class="com.webcode.pojo.Person"><!-- constructor-arg 是按构造器参数赋值
name给哪个属性赋值
value传递的参数值 --><constructor-arg name="name" value="王玄策" />
<constructor-arg name="id" value="3" />
<constructor-arg name="age" value="38" />
<constructor-arg name="phone" value="198745632" />
</bean>  

测试代码：

        @Test
public void test3()throws Exception{
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
 System.out.println(applicationContext.getBean("p3"));
}

打印结果:

​

6、IOC示例程序 — index属性指定参数的位置

实验4：通过index属性指定参数的位置

        <bean id="p4" class="com.webcode.pojo.Person"><!-- constructor-arg 是按构造器参数赋值
name给哪个属性赋值
value传递的参数值 --><constructor-arg index="1" value="大汉光武" />
<constructor-arg index="0" value="4" />
<constructor-arg index="2" value="26" />
<constructor-arg index="3" value="1888951233" />
</bean> 

测试代码：

        @Test
public void test4()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p4"));
}

打印结果：

​

7、IOC示例程序 — 根据参数类型注入

实验5：根据参数类型注入

public Person(Integer id, String name, Integer age, String phone) {
super();
System.out.println("创建了Person==有参");
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
}public Person(Integer id, String name, String phone,Integer age) {
super();
System.out.println("创建了Person==有参");
this.id = id;
this.name = name;
this.age = age;
this.phone = phone;
}

配置信息：

        <bean id="p5" class="com.webcode.pojo.Person">
<!-- Integer id, String name, Integer age, String phoneconstructor-arg 是按构造器参数赋值
index构造参数的索引
value传递的参数值 --> <constructor-arg index="0" value="4" type="java.lang.Integer"></constructor-arg>
 <constructor-arg index="1" value="帅才" type="java.lang.String"></constructor-arg>
 <constructor-arg index="2" value="19" type="java.lang.Integer"></constructor-arg>
 <constructor-arg index="3" value="18" type="java.lang.String"></constructor-arg></bean> 

测试代码：

        @Test
public void test5()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p5"));
}

打印结果：

​

8、IOC之 P名称空间

实验6：通过p名称空间为bean赋值

​

配置信息：

<!-- p名称空间是同过set方法复制 --><bean id="p6" class="com.webcode.pojo.Person"
p:id="6"  p:age="25" p:name="旻"  p:phone="145665389"></bean>

测试代码：

        @Test
public void test6()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(applicationContext.getBean("p6"));
}

打印结果：

​

9、测试null值的使用

实验7：测试使用null值

配置信息：

        <!-- 测试null值的应用 -->
<bean id="p7 " class="com.webcode.pojo.Person">
<property name="id" value="7"></property>
<property name="name"><null></null></property>
</bean>

测试代码：

@Test
public void test7() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p7");
System.out.println( person.getName().length() );
}

10、IOC之子对象的赋值测试（重点）

实验8：引用其他bean★

创建个新的工程。测试Spring的开发环境。此不重复。请参阅前面，环境搭建。

Car对象

public class Car {private String name;
private String carNo;public class Person {private Integer id;
private String name;
private Integer age;
private String phone;
private Car car;

配置信息：

        <bean id="car" class="com.webcode.pojo.Car" p:name="宝马" p:carNo="京B123412"/><bean id="p8" class="com.webcode.pojo.Person">
<property name="id" value="8" />
<!--
car属性，可以通过ref（引用的意思）某个指定id值的对象
 -->
<property name="car" ref="car" />
</bean>

测试代码：

@Test
public void test8() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p8");
System.out.println( person );
}

打印结果：

​

11、IOC之内部Bean的使用

实验9：引用内部bean

配置信息：

        <!--  引用内部bean -->
<bean id="p9" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="car">
<!-- 内部bean ,不能被外部使用 -->
<bean id="car02" class="com.webcode.pojo.Car"  p:name="内部car" p:carNo="京B123422" />
</property>
</bean>

测试代码：

        @Test
public void test9() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p9");
System.out.println( person );
System.out.println( applicationContext.getBean("car02") );
}

打印结果：

​

常见错误：内部的Bean不能被外部使用

​

12、IOC之List属性的赋值

实验10：使用list子元素为List类型的属性赋值

Person对象

​

配置的信息：

        <bean id="p10" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="list">
<!-- list标签，表示当前配置一个list集合 -->
<list>
<value>文</value>
<value>星</value>
<value>念</value>
</list>
</property>
</bean>

——————————————  此处省略测试代码！

打印结果

​

13、IOC之Map属性的赋值

实验11：使用map子元素为Map类型的属性赋值

​

配置信息：

        <!-- 实验11：使用map子元素为Map类型的属性赋值 -->
<bean id="p11" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="map">
<!-- map标签，表示当前配置一个map集合 -->
<map>
<entry key="key1" value="远方"></entry>
<entry key="key2" value="流星"></entry>
<entry key="key3" value-ref="car"></entry>
</map>
</property>
</bean>

——————————————  此处省略测试代码！

打印结果：

​

14、IOC之Properties属性的赋值

实验12：使用prop子元素为Properties类型的属性赋值

​

配置信息：

        <!-- 实验12：使用prop子元素为Properties类型的属性赋值 -->
<bean id="p12" class="com.webcode.pojo.Person">
<property name="id" value="9"></property>
<property name="map">
<!-- props标签，表示当前配置一个Properties -->
<props>
<prop key="user">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>

——————————————  此处省略测试代码！

打印结果：

​

15、IOC之util 名称空间

util名称空间，可以定义

实验13：通过util名称空间创建集合类型的bean

​

配置信息：

        <!--  util名称空间引用，可以定义
实验13：通过util名称空间创建集合类型的bean-->
<!-- 定义一个list集合 -->
<util:list id="list1">
<value>string1</value>
<value>string2</value>
<value>string3</value>
</util:list>
<bean id="p13" class="com.webcode.pojo.Person">
<property name="id" value="13"></property>
<property name="name" value="旻"></property>
<property name="age" value="24"></property>
<property name="phone" value="1722235896"></property>
<!-- list对象 ref表示引用 -->
<property name="phones" ref="list1"></property>
</bean>

测试代码：

        @Test
public void test13()throws Exception{
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("p13");
System.out.println( person );List<String> list = (List<String>) applicationContext.getBean("list1");
System.out.println(list);
}

打印结果：

​

图解：

​

16、IOC之级联属性赋值

实验14：给bean的级联属性赋值

配置：

        <!-- 实验14：给bean的级联属性赋值
常见错误：
级联属性一定要先注入对象。再注入对象的属性
-->
<bean id="p14" class="com.webcode.pojo.Person">
 <property name="id" value="14"></property>
 <property name="name" value="星"></property>
 <property name="age" value="27"></property>
 <property name="phone" value="17889652345"></property>
 <!-- list对象 ref 表示引用 -->
 <property name="car" ref="car"></property>
 <!-- -级联属性 -->
 <property name="car.name" value="凯迪拉克"></property>
</bean>

——————————————  此处省略测试代码！

打印结果：

​

常见错误：

级联属性一定要先注入对象。再注入对象的属性

图解：

​

17、IOC之静态工厂方法创建Bean

实验15：配置通过静态工厂方法创建的bean

代码：

    public class PersonFactory {
public static Person createPerson() {
return new Person(1, "我是静态工厂方法创建出来的", 18, "18688886666");
}
    }

配置信息：

        <!-- 静态工厂方法调用创建对象
factory-method 是指调用哪个方法返回对象 --><bean id="p15" class="com.webcode.pojo.factory.PersonFactory"
factory-method="createPerson"/>

——————————————  此处省略测试代码！

图解：

不重写toString方法的情况下，地址值相同，调用的是同一个对象，从工厂中的方法获取

​

创建对象流程：

​

18、IOC之工厂实例方法创建Bean

实验16：配置通过实例工厂方法创建的bean

    public class PersonFactory {public Person createPerson2() {
return new Person(1, "我是工厂实例方法创建出来的", 18, "18688886666");
}    }

配置信息：

        <!-- 配置工厂实例 -->
<bean id="personFactory" class="com.webcode.pojo.factory.PersonFactory"/>
<!--
factory-bean="personFactory" 表示准备调用哪个实例的方法
factory-method="createFacroty2"  是指调用哪个方法
 -->
 <bean id="p16" factory-bean="personFactory" factory-method="createPerson2">            </bean>

——————————————  此处省略测试代码！

打印结果：

​

流程图解：

​

19、IOC之FactoryBean接口方式创建对象

实验17：配置FactoryBean接口创建Bean对象

FactoryBean接口方式

package com.webcode.pojo.factory;
import org.springframework.beans.factory.FactoryBean;
import com.webcode.pojo.Person;
    public class PersonFactoryBean implements FactoryBean<Person> {
/*
 * 创建对象实例的适合，调用的方法
 * */
@Override
public Person getObject() throws Exception {
return new Person(1,"我是PersonFactoryBean类",18,"14568526666");
}
/*
 * 返回对象的类型，相当于class属性
 * */
@Override
public Class<?> getObjectType() {
return Person.class;
}
/*
 * 是否是单例
 * */
@Override
public boolean isSingleton() {
return true;
}
}

配置信息：

        <!--
创建一个工厂实例对象FactoryBean接口的实现类
 -->
<bean id="p17" class="com.webcode.pojo.factory.PersonFactoryBean"/>

——————————————  此处省略测试代码！

打印结果：

​

图解流程：

​

20、IOC之继承Bean配置

实验18：通过继承实现bean配置信息的重用

配置信息：

        <!-- 实验18：通过继承实现bean配置信息的重用 -->
<bean id="parent" class="com.webcode.pojo.Person">
<property name="id" value="100"></property>
<property name="name" value="我思念的人啊"></property>
<property name="age" value="24"></property>
<property name="phone" value="1477888999"></property>
</bean>
<!-- parent="parent" 继承指定的parentid的bean对象的配置信息-->
<bean id="p18" class="com.webcode.pojo.Person" parent="parent">
<property name="id" value="18"></property>
</bean>

——————————————  此处省略测试代码！

打印结果：

​

图解：先比较parent与id是否相同，再拿class进行比较，

​

注意：当有两个id相同，而类型不同的bean存在时，会出现ReaderContext.error读取异常

​

21、IOC之abstract抽象Bean定义（配置）

实验19：通过abstract属性创建一个模板bean

        <!--
abstract="true"表示这是一个抽象的配置，抽象的就不能被实例化
 -->
<bean id="parent" class="com.webcode.pojo.Person" abstract="true">
<property name="id" value="100"></property>
<property name="name" value="这是父亲的名称"/>
<property name="age" value="30" />
<property name="phone" value="父亲的电话" />
</bean>

​

22、IOC之组件创建顺序

实验20：bean之间的依赖  depends-on 属性

public class A {
public A() {
System.out.println("创建了A对象");
}
}
public class B {
public B() {
System.out.println("创建了B对象");
}
}
public class C {
public C() {
System.out.println("创建了C对象");
}
}

配置信息：

        <!--
depends-on="b"依赖b
如果你要创建a，要先有b
 -->
<bean id="a" class="com.webcode.pojo.A" depends-on="b,c"/>
<bean id="b" class="com.webcode.pojo.B"/>
<bean id="c" class="com.webcode.pojo.C"/>

测试代码：

        @Test
public void test1() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//System.out.println( applicationContext.getBean("a") );
}

打印结果：

​

23、IOC之Bean的单例和多例（重点）

实验21：测试bean的作用域，分别创建单实例和多实例的bean★

<!--
scope配置作用域分别是四个值：singleton、prototype、request、session
singleton这是默认值表示单例
1、当Spring容器创建的时候，单例的对象就会被创建出来。
2、单例的对象，在每次调用getBean的时候都返回同一个对象
prototype表示多例
1、当创建Spring容器的时候，不会创建出多例的对象
2、当调用getBaen方法时，会创建一个对象
3、每次调用getBean，都会创建一个实例
       ===============request和Session了解======================
request    表示一次请求内，多次调用getBean都只会返回同一个对象
当调用getBean方法时内部原理类似如：
            Object bean = request.getAttribute(id);
    if (bean == null) {
             bean = 创建一个实例;
         request.setAttribute(id,bean);
    }
    return bean;
session    表示同一个会话，多次调用getBean都只会返回同一个对象
当调用getBean方法时内部原理类似如：
    Object bean = session.getAttribute(id);
            if (bean == null) {
bean = 创建一个实例;
session.setAttribute(id,bean);
             }
    return bean;
 -->
<bean id="a" class="com.webcode.pojo.A" scope="request"></bean>

单例——singleton 打印结果：

​

多例——prototype打印结果：

​

24、基于xml配置文件的自动注入

先创建Person类和Car类

public class Car {private String name;
private String carNo;
public class Person {
private Integer id;
private Car car;public Person(Car car) {
this.car = car;
}

<!--
<bean id="car" class="com.webcode.pojo.Car">
<property name="name" value="海南马自达car" />
<property name="carNo" value="琼A123412"/>
</bean>
<bean id="car1" class="com.webcode.pojo.Car">
<property name="name" value="海南马自达car1" />
<property name="carNo" value="琼A123412"/>
</bean>default和no就是不配置就没值
byName按属性名做为id名称查找bean对象，并自动注入
1、找到就自动注入
2、找不到就null
byType按子对象的类型查找bean对象，并自动注入
1、找到一个就自动注入
2、找到多个就报错。
3、没有找到就null
constructor表示按构造器参数查找并自动注入
1、会先按类型查找
1.1、查找一个就自动注入
1.2、查找到多个，就继续以参数名做为id接着查找，然后注入
1.3、查找到多个，就继续以参数名做为id接着查找，没有找到就为null值
2、没有找到就是null
先按类型==>>再按参数名做为id===>>最后是null
 -->
<bean id="p20" class="com.webcode.pojo.Person" autowire="constructor">
<property name="id" value="20"></property>
<!-- <property name="car" ref="car" /> -->
</bean>

测试代码：

@Test
public void test2() throws Exception {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println( applicationContext.getBean("p20") );
}

手动配置引用注入：图解

​

Default指令效果图解

​

byType 指令效果图解

匹配的子对象为class中的Car

​

constructor按构造器参数查找并自动注入 图解

4~6步执行set\get和toString方法

​