1 Spring IOC容器

(1)IOC底层原理
(2)IOC接口(BeanFactory)
(3)IOC操作Bean管理(基于XML)
(4)IOC操作Bean管理(基于注释)

1.1 IOC概念

(1)控制反转(Inversion of Control)，把对象的创建和对象之间的调用过程，交给Spring进行管理。
(2)使用IOC目的：为了降低耦合度。
(3)IOC底层原理：xml解析、工厂模式、反射。
工厂模式：降低耦合度。
反射：得到类的字节码文件。

1.2 IOC底层原理

在UserService类中调动用UserDao类中的方法。

class UserService{execute(){}
}class UserDao{add(){...}
}

1.2.1 原始方式(耦合度高)

1.2.2 工厂模式(解耦)

1.2.3 IOC过程 (最低耦合度)

1.3 IOC接口

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
2、Spring提供IOC容器实现两种方式:(两个接口)
(1)BeanFactory：IOC容器基本实现，是Spring内部使用的接口，不提供开发人员进行使用。
加载配置文件时不会创建对象，在获取对象或使用对象时才会创建。

(2)ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
加载配置文件时，就会把在配置文件中的对象都进行创建。
3、ApplicationContext中的实现类
(1)FileSystemXmlApplicationContext
(2)ClassPathXmlApplicationContext

1.4 Bean管理

1、什么是Bean管理
Bean管理指的是两个操作：
(1)Spring创建对象
(2)Spring注入属性
2、Bean管理操作有两种方式：
(1)基于xml配置文件方式实现
(2)基于注解方式实现

2 基于xml方式

2.1 创建对象

2.1.1 new方法(原始)

HellowWorld hello = new HelloWorld();

2.1.2 xml方式(spring)

1、基于xml方式创建对象
<!--配置HellowWorld对象创建-->
<bean id="helloWorld123" class="HelloWorld"></bean>
(1)在spring配置文件中，使用bean标签，
标签里面添加对应属性，就可以实现对象创建。
(2)在bean标签中有很多属性
id属性：唯一标识。
class属性：类全路径(包名+类名)。
name属性：与id属性功能相似，已不再使用。
(3)创建对象的时候，默认也是执行无参数构造方法

2.2 set方法注入属性

2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。

2.2.1 set方法(原始)

public class Book {//创建属性private String bname;private String bauthor;//创建属性对应的set方法public void setBname(String bname) {this.bname = bname;}public void setBauthor(String bauthor) {this.bauthor = bauthor;}public void getMessage(){System.out.println(bname+":"+bauthor);}public static void main(String[] args){// 使用时，先创建对象，再用set方法注入属性Book book = new Book();book.setBname("孔乙己");book.setBauthor("鲁迅");book.getMessage();}}

2.2.2 xml方式(spring)

使用property完成属性注入
name：类里面属性名称
value：向属性注入的值<bean id="book" class="Book"><property name="bname" value="孙子兵法" /><property name="bauthor" value="孙子" />
</bean>

使用方式

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class zzz {public static void main(String[] args) {// 1 加载spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");// 2 获取配置创建的对象Book book = (Book) context.getBean("book");book.getMessage();}
}

2.3 有参构造注入属性

2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。

2.3.1 构造方法(原始)

右键->Generate->选择生成有参构造

public class Orders {//创建属性private String oname;private String address;// 创建有参构造public Orders(String oname, String address) {this.oname = oname;this.address = address;}public void getMessage(){System.out.println(oname+":"+address);}public static void main(String[] args){// 使用时Orders order = new Orders("lily","NewYork");order.getMessage();}
}

2.3.2 xml方式(spring)

<!--有参构造注入属性-->
<bean id="orders" class="Orders"><constructor-arg name="oname" value="lucy"/><constructor-arg name="address" value="china"/>
</bean>

使用方式

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class zzz {public static void main(String[] args) {// 1 加载spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");// 2 获取配置创建的对象Orders order = (Orders) context.getBean("orders");order.getMessage();}
}

2.4 p名称空间注入

(1)使用p名称空间注入，可以简化基于xml的set方法注入
第一步 添加p名称空间在配置文件中
<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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd">第二步 进行属性注入，在bean标签中进行操作
<bean id="book" class="Book" p:bname="天龙八部" p:bauthor="金庸"></bean>

2.5 注入null和特殊字符

一、字面量
(1)null值
<bean id="book" class="Book"><property name="bname" value="孙子兵法" /><property name="bauthor"><null/></property>
</bean>输出如下:孙子兵法:null(2)属性值包含特殊符号
方式一：把<>进行转移 &lt;&gt;
<bean id="book" class="Book"><property name="bname" value="孙子兵法" /><property name="bauthor" value="&lt;&lt;孙子&gt;&gt;"/>
</bean>
方式二：把带特殊符号内容写到CDATA
<bean id="book" class="Book"><property name="bname" value="孙子兵法" /><property name="bauthor"><value><![CDATA[<<老子>>]]></value></property>
</bean>

2.6 注入外部Bean

web层，service层，dao层。

2、注入属性-外部bean
(1)创建两个类service类和dao类
(2)在service中调用dao
(3)在spring配置文件中配置

2.6.1 原始方式

一、Dao层接口
代码文件UserDao.java

package dao;public interface UserDao {public void update();
}

二、Dao层接口实现
代码文件UserDaoImpl.java

package dao;public class UserDaoImpl implements UserDao{@Overridepublic void update() {System.out.println("dao update ......");}
}

三、service层
代码文件UserService.java

package service;import dao.UserDao;
import dao.UserDaoImpl;public class UserService {public void add(){System.out.println("service add ......");// 在service层中调用Dao层// 创建UserDao对象UserDao userdao = new UserDaoImpl();userdao.update();}public static void main(String[] args) {UserService userservice = new UserService();userservice.add();}
}

2.6.2 xml方式

一、Dao层接口
代码文件UserDao.java
二、Dao层接口实现
代码文件UserDaoImpl.java
三、service层
代码文件UserService.java

package service;import dao.UserDao;public class UserService {//创建UserDao类型属性,生成set方法private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void add(){System.out.println("service add ......");// 调用dao层userDao.update();}
}

四、beans.xml配置文件

<!-- 1 service和dao对象创建-->
<bean id="userservice123" class="service.UserService"><!--注入userDao对象name属性：类里面的属性名称ref属性：创建userDao对象bean标签id值--><property name="userDao" ref="userDaoImpl123"/>
</bean>
<bean id="userDaoImpl123" class="dao.UserDaoImpl"></bean>

五、测试使用

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;public class zzz {public static void main(String[] args) {// 1 加载spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");// 2 获取配置创建的对象UserService userservice = (UserService) context.getBean("userservice123");userservice.add();}
}

2.7 注入内部Bean

(1)一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
(2)在实体类间表示一对多关系,员工所属部门，使用对象类型属性表示

一、Dept.java

//部门类
public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;}public String getDname() {return dname;}
}

二、Emp.java

//员工类
public class Emp {private String ename;private String gender;//员工属于某一个部门，使用对象类型属性表示private Dept dept;public void setDept(Dept dept) {this.dept = dept;}public void setEname(String ename) {this.ename = ename;}public void setGender(String gender) {this.gender = gender;}public void getMessage(){System.out.println(ename+":"+gender+":"+dept);}
}

三、beans.xml配置文件

<!--内部bean-->
<bean id="emp" class="Emp"><!--设置两个普通属性--><property name="ename" value="lily"/><property name="gender" value="女"/><!--设置对象类型属性--><property name="dept"><bean id="dept" class="Dept"><property name="dname" value="人力资源部"/></bean></property>
</bean>

四、测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class zzz {public static void main(String[] args) {// 1 加载spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");// 2 获取配置创建的对象Emp emp = (Emp) context.getBean("emp");emp.getMessage();}
}

2.8 级联赋值

(1)第一种写法：
<!--级联赋值-->
<bean id="emp" class="Emp"><!--设置两个普通属性--><property name="ename" value="lily"/><property name="gender" value="女"/><!--级联赋值--><property name="dept" ref="dept12"/>
</bean>
<bean id="dept12" class="Dept"><property name="dname" value="人力资源部"/>
</bean>(2)第二种方法
<!--级联赋值-->
<bean id="emp" class="Emp"><!--设置两个普通属性--><property name="ename" value="lily"/><property name="gender" value="女"/><!--级联赋值--><property name="dept" ref="dept12"/><property name="dept.dname" value="技术部"/>
</bean>
<bean id="dept12" class="Dept"><property name="dname" value="人力资源部"/>
</bean>

第二种方法需要注意：

3 Spring IoC容器

IoC(Inverse of Control)控制反转。
IoC指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们使用new创建，而使用Spring之后，对象的创建都交给了Spring框架。

IoC容器是Spring的核心，也可以称为Spring容器。Spring通过IoC容器来管理对象的实例化和初始化，以及对象从创建到销毁的整个生命周期。

Spring中使用的对象都由IoC容器管理，不需要我们手动使用new运算符创建对象。由 IoC容器管理的对象称为Spring Bean，Spring Bean就是Java对象，和使用new运算符创建的对象没有区别。

Spring通过读取XML或Java注解中的信息来获取哪些对象需要实例化。

Spring提供2种不同类型的IoC容器，即BeanFactory和ApplicationContext容器。

3.1 BeanFactory容器

BeanFactory是最简单的容器，由org.springframework.beans.factory.BeanFactory接口定义，采用懒加载(lazy-load)，所以容器启动比较快。

BeanFactory 提供了容器最基本的功能。

为了能够兼容 Spring集成的第三方框架(如BeanFactoryAware、InitializingBean、DisposableBean)，所以目前仍然保留了该接口。

简单来说，BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法。

BeanFactory 接口有多个实现类，
最常见的是org.springframework.beans.factory.xml.XmlBeanFactory。
使用BeanFactory需要创建XmlBeanFactory类的实例，
通过XmlBeanFactory类的构造函数来传递Resource对象。如下所示。
Resource resource = new ClassPathResource("Beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource);  

MainApp.java文件

package net.biancheng;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;public class MainApp {public static void main(String[] args) {Resource resource = new ClassPathResource("Beans.xml");BeanFactory factory = new XmlBeanFactory(resource);HelloWorld obj = (HelloWorld) factory.getBean("helloWorld123");obj.getMessage();}
}

在主程序当中，需要注意以下两点：
(1)第一步利用框架提供的XmlBeanFactory() API去生成工厂bean以及利用 ClassPathResource() API去加载在路径CLASSPATH下可用的bean配置文件。XmlBeanFactory() API负责创建并初始化所有的对象，即在配置文件中提到的 bean。

(2)第二步利用第一步生成的bean工厂对象的getBean()方法得到所需要的bean。 这个方法通过配置文件中的bean ID来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。
后期这个XmlBeanFactory类被废除了。

3.2 ApplicationContext容器

ApplicationContext继承了BeanFactory接口，由 org.springframework.context.ApplicationContext接口定义，对象在启动容器时加载。ApplicationContext在BeanFactory的基础上增加了很多企业级功能，例如AOP、国际化、事件支持等。

ApplicationContext 接口有两个常用的实现类，具体如下。
(1)ClassPathXmlApplicationContext
该类从类路径ClassPath中寻找指定的XML配置文件，并完成ApplicationContext的实例化工作，具体如下所示。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

在上述代码中，configLocation参数用于指定Spring配置文件的名称和位置，如 Beans.xml。
(2)FileSystemXmlApplicationContext
该类从指定的文件系统路径中寻找指定的 XML 配置文件，并完成ApplicationContext的实例化工作，具体如下所示。

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不会从类路径中读取配置文件，而是通过参数指定配置文件的位置。即 FileSystemXmlApplicationContext 可以获取类路径之外的资源，如“F:/workspaces/Beans.xml”。