【后端】SSM框架体系（一）

SSM框架

Spring

一、Spring相关概念

1. 初识Spring

1.1 Spring家族

• 官网：https://spring.io.从官网我们可以大概了解到：
  • Spring能做什么：用以开发web、微服务以及分布式系统等,光这三块就已经占了JavaEE开发的九成多。
  • Spring并不是单一的一个技术，而是一个大家族，可以从官网的Projects中查看其包含的所有技术。
• Spring发展到今天已经形成了一种开发的生态圈,Spring提供了若干个项目,每个项目用于完成特定的功能。
  • Spring已形成了完整的生态圈，也就是说我们可以完全使用Spring技术完成整个项目的构建、设计与开发。
  • Spring有若干个项目，可以根据需要自行选择，把这些个项目组合起来，起了一个名称叫全家桶，如下图所示
    
    
  • Spring Framework：Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。
  • SpringBoot：Spring是来简化开发，而SpringBoot是来帮助Spring在简化的基础上能更快速进行开发。
  • SpringCloud：这个是用来做分布式之微服务架构的相关开发。
• 除了上面的这三个技术外，还有很多其他的技术，也比较流行，如SpringData,SpringSecurity等，这些都可以被应用在我们的项目中。我们今天所学习的Spring其实指的是Spring Framework。

1.2 了解Spring发展史

• IBM(IT公司-国际商业机器公司)在1997年提出了EJB思想,早期的JAVAEE开发大都基于该思想。
• Rod Johnson(Java和J2EE开发领域的专家)在2002年出版的Expert One-on-One J2EE Design and Development ,书中有阐述在开发中使用EJB该如何做。
• Rod Johnson在2004年出版的Expert One-on-One J2EE Development without EJB ,书中提
  出了比EJB思想更高效的实现方案，并且在同年将方案进行了具体的落地实现，这个实现就是
  Spring1.0。
• 随着时间推移，版本不断更新维护，目前最新的是Spring5
  • Spring1.0是纯配置文件开发
  • Spring2.0为了简化开发引入了注解开发，此时是配置文件加注解的开发方式
  • Spring3.0已经可以进行纯注解开发，使开发效率大幅提升
  • Spring4.0根据JDK的版本升级对个别API进行了调整
  • Spring5.0已经全面支持JDK8，现在Spring最新的是5系列所以建议大家把JDK安装成1.8版

2. Spring系统架构

• 核心层
  • Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块
• AOP层
  • AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
  • Aspects:AOP是思想，Aspects是对AOP思想的具体实现
• 数据层
  • Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
  • Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
  • Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容
• Web层
  • 这一层的内容将在SpringMVC框架具体学习
• Test层
  • Spring主要整合了Junit来完成单元测试和集成测试
    

3. Spring核心概念

3.1 目前项目中的问题

• 要想解答这个问题，就需要先分析下目前咱们代码在编写过程中遇到的问题:
  
• 业务层需要调用数据层的方法，就需要在业务层new数据层的对象
• 如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署
• 所以，现在代码在编写的过程中存在的问题是：耦合度偏高
• 针对这个问题，该如何解决呢?
  
• 我们就想，如果能把框中的内容给去掉，不就可以降低依赖了么，但是又会引入新的问题，去掉以后程序能运行么?
• 答案肯定是不行，因为bookDao没有赋值为Null，强行运行就会出空指针异常。
• 所以现在的问题就是，业务层不想new对象，运行的时候又需要这个对象，该咋办呢?
• 针对这个问题，Spring就提出了一个解决方案:
  • 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
• 这种实现思想就是Spring的一个核心概念

3.2 IOC、IOC容器、Bean、DI

3.2.1 IOC（Inversion of Control）控制反转

• 什么是控制反转呢？
  • 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。
    • 业务层要用数据层的类对象，以前是自己new的
    • 现在自己不new了，交给别人[外部]来创建对象
    • 别人[外部]就反转控制了数据层对象的创建权
    • 这种思想就是控制反转
    • 别人[外部]指定是什么呢?继续往下学
• Spring和IOC之间的关系是什么呢?
  • Spring技术对IOC思想进行了实现
  • Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"
  • IOC思想中的别人[外部]指的就是Spring的IOC容器
• IOC容器的作用以及内部存放的是什么?
  • IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
  • 被创建或被管理的对象在IOC容器中统称为Bean
  • IOC容器中放的就是一个个的Bean对象
• 当IOC容器中创建好service和dao对象后，程序能正确执行么?
  • 不行，因为service运行需要依赖dao对象
  • IOC容器中虽然有service和dao对象
  • 但是service对象和dao对象没有任何关系
  • 需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系
  • 像这种在容器中建立对象与对象之间的绑定关系就要用到DI

3.2.2 DI（Dependency Injection）依赖注入

• 什么是依赖注入呢?
  • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
    • 业务层要用数据层的类对象，以前是自己new的
    • 现在自己不new了，靠别人[外部其实指的就是IOC容器]来给注入进来
    • 这种思想就是依赖注入
• IOC容器中哪些bean之间要建立依赖关系呢?
  • 这个需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系

3.2.3 总结

• 介绍完Spring的IOC和DI的概念后，我们会发现这两个概念的最终目标就是:充分解耦，具体实现靠:
  • 使用IOC容器管理bean（IOC)
  • 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.

3.3 核心概念小结

• 什么是IOC/DI思想?
  • IOC:控制反转，控制反转的是对象的创建权
  • DI:依赖注入，绑定对象与对象之间的依赖关系
• 什么是IOC容器?
  • Spring创建了一个容器用来存放所创建的对象，这个容器就叫IOC容器
• 什么是Bean?
  • 容器中所存放的一个个对象就叫Bean或Bean对象

二、入门案例

1. IOC入门案例

1.1 入门案例思路分析

• Spring是使用容器来管理bean对象的，那么管什么?
  • 主要管理项目中所使用到的类对象，比如(Service和Dao)
• 如何将被管理的对象告知IOC容器?
  • 使用配置文件
• 被管理的对象交给IOC容器，要想从容器中获取对象，就先得思考如何获取到IOC容器?
  • Spring框架提供相应的接口
• IOC容器得到后，如何从容器中获取bean?
  • 调用Spring框架提供对应接口中的方法
• 使用Spring导入哪些坐标?
  • 用别人的东西，就需要在pom.xml添加对应的依赖

1.2 入门案例代码实现

需求分析:将BookServiceImpl和BookDaoImpl交给Spring管理，并从容器中获取对应的bean
对象进行方法调用。
1.创建Maven的java项目
2.pom.xml添加Spring的依赖jar包
3.创建BookService,BookServiceImpl,BookDao和BookDaoImpl四个类
4.resources下添加spring配置文件，并完成bean的配置
5.使用Spring提供的接口完成IOC容器的创建
6.从容器中获取对象进行方法调用

• 步骤1:创建Maven项目
  
• 步骤2:添加Spring的依赖jar包

<!-- pom.xml -->
<dependencies> 
	<dependency> 
		<groupId>org.springframework</groupId> 	
		<artifactId>spring-context</artifactId> 
		<version>5.2.10.RELEASE</version> 
	</dependency> 
	<dependency> 
		<groupId>junit</groupId> 
		<artifactId>junit</artifactId> 
		<version>4.12</version> 
		<scope>test</scope> 
	</dependency> 
</dependencies> 

• 步骤3:添加案例中需要的类

// 创建BookService,BookServiceImpl，BookDao和BookDaoImpl四个类
public interface BookDao { 
	public void save(); 
}
public class BookDaoImpl implements BookDao { 
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}
public interface BookService { 
	public void save(); 
}
public class BookServiceImpl implements BookService { 
	private BookDao bookDao = new BookDaoImpl(); 
	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	} 
} 

• 步骤4:添加spring配置文件
  • resources下添加spring配置文件applicationContext.xml，并完成bean的配置
    
• 步骤5:在配置文件中完成bean的配置

<?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标签标示配置bean 
		id属性标示给bean起名字 
		class属性表示给bean定义类型 
	--> 
	<bean id="bookDao" class="com.alex.dao.impl.BookDaoImpl"/> 
	<bean id="bookService" class="com.alex.service.impl.BookServiceImpl"/> 
</beans>
<!-- 注意事项：bean定义时id属性在同一个上下文中(配置文件)不能重复 -->

• 步骤6:获取IOC容器
  • 使用Spring提供的接口完成IOC容器的创建，创建App类，编写main方法
• 步骤7:从容器中获取对象进行方法调用

public class App { 
	public static void main(String[] args) { 
		//获取IOC容器 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		// BookDao bookDao = (BookDao) ctx.getBean("bookDao"); 
		// bookDao.save(); 
		BookService bookService = (BookService) ctx.getBean("bookService"); 
		bookService.save(); 
	} 
}

• 步骤8:运行程序
  • 测试结果为：
    
• Spring的IOC入门案例已经完成，但是在BookServiceImpl的类中依然存在BookDaoImpl对象的new操作，它们之间的耦合度还是比较高，这块该如何解决，就需要用到下面的DI:依赖注入。

2. DI入门案例

2.1 入门案例思路分析

• 要想实现依赖注入，必须要基于IOC管理Bean
  • DI的入门案例要依赖于前面IOC的入门案例
• Service中使用new形式创建的Dao对象是否保留?
  • 需要删除掉，最终要使用IOC容器中的bean对象
• Service中需要的Dao对象如何进入到Service中?
  • 在Service中提供方法，让Spring的IOC容器可以通过该方法传入bean对象
• Service与Dao间的关系如何描述?
  • 使用配置文件

2.2 入门案例代码实现

需求:基于IOC入门案例，在BookServiceImpl类中删除new对象的方式，使用Spring的DI完成
Dao层的注入
1.删除业务层中使用new的方式创建的dao对象
2.在业务层提供BookDao的setter方法
3.在配置文件中添加依赖注入的配置
4.运行程序调用方法

• 步骤1: 去除代码中的new
  • 在BookServiceImpl类中，删除业务层中使用new的方式创建的dao对象

public class BookServiceImpl implements BookService { 
	//删除业务层中使用new的方式创建的dao对象 
	private BookDao bookDao; 

	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	} 
}

• 步骤2:为属性提供setter方法
  • 在BookServiceImpl类中,为BookDao提供setter方法

public class BookServiceImpl implements BookService { 
	//删除业务层中使用new的方式创建的dao对象 
	private BookDao bookDao; 

	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	}
	//提供对应的set方法 
	public void setBookDao(BookDao bookDao) { 
		this.bookDao = bookDao; 
	} 
}

• 步骤3:修改配置完成注入
  • 在配置文件中添加依赖注入的配置

  <?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标签标示配置bean 
  	 id属性标示给bean起名字 
  	 class属性表示给bean定义类型 
  --> 
  	<bean id="bookDao" class="com.alex.dao.impl.BookDaoImpl"/> 
  	<bean id="bookService" class="com.alex.service.impl.BookServiceImpl"> 
  		<!--配置server与dao的关系--> 
  		<!--property标签表示配置当前bean的属性 
  			name属性表示配置哪一个具体的属性 
  			ref属性表示参照哪一个bean 
  		--> 
  		<property name="bookDao" ref="bookDao"/> 
  	</bean> 
  </beans>
  

  • 注意:配置中的两个bookDao的含义是不一样的
    • name="bookDao"中bookDao的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前面加set找对应的setBookDao()方法进行对象注入
    • ref="bookDao"中bookDao的作用是让Spring能在IOC容器中找到id为bookDao的Bean对象给bookService进行注入
  • 综上所述，对应关系如下:
    
• 步骤4:运行程序
  • 运行，测试结果为：
    

三、IOC相关内容

1. bean基础配置

1.1 bean基础配置(id与class)

<bean id="" class=""/>

• 思考：
  • class属性能不能写接口如BookDao的类全名呢?
    • 答案肯定是不行，因为接口是没办法创建对象的。
  • 前面提过为bean设置id时，id必须唯一，但是如果由于命名习惯而产生了分歧后，该如何解决?

1.2 bean的name属性

• 步骤1：配置别名
  • 打开spring的配置文件applicationContext.xml

<?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"> 

	<!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔--> 
	<bean id="bookService" name="service service4 bookEbi" class="com.alex.service.impl.BookServiceImpl"> 
		<property name="bookDao" ref="bookDao"/> 
	</bean> 

	<!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype--> 
	<bean id="bookDao" name="dao" class="com.alex.dao.impl.BookDaoImpl"/> 
</beans>

• 步骤2:根据名称容器中获取bean对象

public class AppForName { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		//此处根据bean标签的id属性和name属性的任意一个值来获取bean对象 
		BookService bookService = (BookService) ctx.getBean("service4"); 
		bookService.save(); 
	} 
}

• 步骤3:运行程序
  • 测试结果为：
    
• 注意事项:
  • bean依赖注入的ref属性指定bean，必须在容器中存在
    
  • 如果不存在,则会报错，如下:
    
    
• 获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常 NoSuchBeanDefinitionException

1.3 bean作用范围scope配置

1.3.1 验证IOC容器中对象是否为单例

• 验证思路
  • 同一个bean获取两次，将对象打印到控制台，看打印出的地址值是否一致。
• 具体实现
  • 创建一个AppForScope的类，在其main方法中来验证

  public class AppForScope { 
  	public static void main(String[] args) { 
  		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
  		BookDao bookDao1 = (BookDao) ctx.getBean("bookDao"); 
  		BookDao bookDao2 = (BookDao) ctx.getBean("bookDao"); 
  		System.out.println(bookDao1); 
  		System.out.println(bookDao2); 
  	}
  } 
  

  • 打印，观察控制台的打印结果
    
  • 结论:默认情况下，Spring创建的bean对象都是单例的
• 获取到结论后，问题就来了，那如果我想创建出来非单例的bean对象，该如何实现呢?

1.3.2 配置bean为非单例

• 在Spring配置文件中，配置scope属性来实现bean的非单例创建
  • 在Spring的配置文件中，修改<bean>的scope属性

  <bean id="bookDao" name="dao" class="com.alex.dao.impl.BookDaoImpl" scope=""/>
  

  • 将scope设置为singleton

  <bean id="bookDao" name="dao" class="com.alex.dao.impl.BookDaoImpl" scope="singleton"/>
  

  
  • 将scope设置为prototype

  <bean id="bookDao" name="dao" class="com.alex.dao.impl.BookDaoImpl" scope="prototype"/>
  

  
• 结论，使用bean的scope属性可以控制bean的创建是否为单例：
  • singleton默认为单例
  • prototype为非单例

1.3.3 scope使用后续思考

• 为什么bean默认为单例?
  • bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
  • bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
• bean在容器中是单例的，会不会产生线程安全问题?
  • 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的
  • 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
  • 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的
  • 因为方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
• 哪些bean对象适合交给容器进行管理?
  • 表现层对象
  • 业务层对象
  • 数据层对象
  • 工具对象
• 哪些bean对象不适合交给容器进行管理?
  • 封装实例的域对象，因为会引发线程安全问题，所以不适合。

1.4 bean基础配置小结

2. bean实例化

• 对象已经能交给Spring的IOC容器来创建了，但是容器是如何来创建对象的呢?
• 就需要研究下bean的实例化过程，在这块内容中主要解决两部分内容，分别是
  • bean是如何创建的
  • 实例化bean的三种方式，构造方法,静态工厂和实例工厂
• 在讲解这三种创建方式之前，我们需要先确认一件事:
• bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。
• 基于这个知识点出发，我们来验证spring中bean的三种创建方式

2.1 构造方法实例化

• 步骤1:准备需要被创建的类
  • 准备一个BookDao和BookDaoImpl类

public interface BookDao { 
	public void save(); 
}

public class BookDaoImpl implements BookDao { 
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}

• 步骤2:将类配置到Spring容器

<?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 id="bookDao" class="com.alex.dao.impl.BookDaoImpl"/> 
</beans>

• 步骤3:编写运行程序

public class AppForInstanceBook { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		BookDao bookDao = (BookDao) ctx.getBean("bookDao"); 
		bookDao.save(); 
	} 
}

• 步骤4:类中提供构造函数测试

  • 在BookDaoImpl类中添加一个无参构造函数，并打印一句话，方便观察结果。

  public class BookDaoImpl implements BookDao { 
  	public BookDaoImpl() { 
  		System.out.println("book dao constructor is running ...."); 
  	}
  	public void save() { 
  		System.out.println("book dao save ..."); 
  	} 
  }
  

  • 运行程序，如果控制台有打印构造函数中的输出，说明Spring容器在创建对象的时候也走的是构造函数
    

• 步骤5:将构造函数改成private测试

  public class BookDaoImpl implements BookDao { 
  	private BookDaoImpl() { 
  		System.out.println("book dao constructor is running ...."); 
  	}
  	public void save() { 
  		System.out.println("book dao save ..."); 
  	} 
  }
  

  • 运行程序，能执行成功，说明内部走的依然是构造函数，能访问到类中的私有构造方法，显而易见Spring底层用的是反射
    

• 步骤6:构造函数中添加一个参数测试

  public class BookDaoImpl implements BookDao { 
  	private BookDaoImpl(int i) { 
  		System.out.println("book dao constructor is running ...."); 
  	}
  	public void save() { 
  		System.out.println("book dao save ..."); 
  	} 
  }
  

  • 运行程序，
  • 程序会报错，说明Spring底层使用的是类的无参构造方法。
    

2.2 静态工厂实例化

2.2.1 工厂方式创建bean

• 准备一个OrderDao和OrderDaoImpl类

public interface OrderDao { 
	public void save(); 
}
public class OrderDaoImpl implements OrderDao { 
	public void save() { 
		System.out.println("order dao save ..."); 
	} 
}

• 创建一个工厂类OrderDaoFactory并提供一个静态方法

//静态工厂创建对象 
public class OrderDaoFactory { 
	public static OrderDao getOrderDao(){ 
		return new OrderDaoImpl(); 
	} 
}

• 编写AppForInstanceOrder运行类，在类中通过工厂获取对象

public class AppForInstanceOrder { 
	public static void main(String[] args) { 
		//通过静态工厂创建对象 
		OrderDao orderDao = OrderDaoFactory.getOrderDao(); 
		orderDao.save(); 
	} 
}

• 运行后，可以查看到结果
  
• 如果代码中对象是通过上面的这种方式来创建的，如何将其交给Spring来管理呢?

2.2.2 静态工厂实例化

• 在spring的配置文件application.properties中添加以下内容:

  <bean id="orderDao" class="com.alex.factory.OrderDaoFactory" factory- method="getOrderDao"/>
  

  • class:工厂类的类全名
  • factory-mehod:具体工厂类中创建对象的方法名
  • 对应关系如下图:
    
• 在AppForInstanceOrder运行类，使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceOrder { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		OrderDao orderDao = (OrderDao) ctx.getBean("orderDao"); 
		orderDao.save(); 
	} 
}

• 运行后，可以查看到结果
  
• 看到这，可能有人会问了，你这种方式在工厂类中不也是直接new对象的，和我自己直接new没什么太大的区别，而且静态工厂的方式反而更复杂，这种方式的意义是什么?
• 主要的原因是:
  • 在工厂的静态方法中，我们除了new对象还可以做其他的一些业务操作，这些操作必不可少,如:

public class OrderDaoFactory { 
	public static OrderDao getOrderDao(){ 
		System.out.println("factory setup....");//模拟必要的业务操作 
		return new OrderDaoImpl(); 
	} 
}

• 之前new对象的方式就无法添加其他的业务内容，重新运行，查看结果:
  

2.3 实例工厂与FactoryBean

2.3.1 环境准备

• 准备一个UserDao和UserDaoImpl类

public interface UserDao { 
	public void save(); 
}
public class UserDaoImpl implements UserDao { 
	public void save() { 
		System.out.println("user dao save ..."); 
	} 
}

• 创建一个工厂类OrderDaoFactory并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

public class UserDaoFactory { 
	public UserDao getUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

• 编写AppForInstanceUser运行类，在类中通过工厂获取对象

public class AppForInstanceUser { 
	public static void main(String[] args) { 
		//创建实例工厂对象 
		UserDaoFactory userDaoFactory = new UserDaoFactory(); 
		//通过实例工厂对象创建对象 
		UserDao userDao = userDaoFactory.getUserDao(); 
		userDao.save(); 
	}
}

• 运行后，可以查看到结果
  
• 对于上面这种实例工厂的方式如何交给Spring管理呢?

2.3.2 实例工厂实例化

• 在spring的配置文件中添加以下内容:

  <bean id="userFactory" class="com.alex.factory.UserDaoFactory"/> 
  <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
  

  • 实例化工厂运行的顺序是:
    • 创建实例化工厂对象,对应的是第一行配置
    • 调用对象中的方法来创建bean，对应的是第二行配置
      • factory-bean:工厂的实例对象
      • factory-method:工厂对象中的具体创建对象的方法名,对应关系如下:
        
• 在AppForInstanceUser运行类，使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceUser { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		UserDao userDao = (UserDao) ctx.getBean("userDao"); 
		userDao.save(); 
	} 
}

• 运行后，可以查看到结果
  
• 实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

2.3.3 FactoryBean的使用

• 创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法

public class UserDaoFactoryBean implements FactoryBean<UserDao> { 
	//代替原始实例工厂中创建对象的方法 
	public UserDao getObject() throws Exception { 
		return new UserDaoImpl(); 
	}
	//返回所创建类的Class对象 
	public Class<?> getObjectType() { 
		return UserDao.class; 
	} 
}

• 在Spring的配置文件中进行配置

<bean id="userDao" class="com.alex.factory.UserDaoFactoryBean"/>

• AppForInstanceUser运行类不用做任何修改，直接运行
  
• 这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。查看源码会发现，FactoryBean接口其实会有三个方法，分别是:

T getObject() throws Exception; 
Class<?> getObjectType(); 
default boolean isSingleton() { return true; }

// 方法一:getObject()，被重写后，在方法中进行对象的创建并返回
// 方法二:getObjectType(),被重写后，主要返回的是被创建类的Class对象
// 方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，false为非单例
// 一般情况下我们都会采用单例，也就是采用默认即可。所以isSingleton()方法一般不需要进行重写。

2.4 bean实例化小结

• bean是如何创建的呢? 构造方法
• Spring的IOC实例化对象的三种方式分别是:
  • 构造方法(常用)
  • 静态工厂(了解)
  • 实例工厂(了解)
    • FactoryBean(实用)
• 这些方式中，重点掌握构造方法和FactoryBean即可。
• 需要注意的一点是，构造方法在类中默认会提供，但是如果重写了构造方法，默认的就会消失，在使用的过程中需要注意，如果需要重写构造方法，最好把默认的构造方法也重写下。