Spring IOC
主要内容
Spring 框架
Spring 框架概念
Spring 是众多开源java项目中的一员，基于分层的javaEE应用一站式轻量级开源框架，主要核心是 IOC（控制反转/依赖注入）与 AOP（面向切面）两大技术，实现项目在开发过程中的轻松解耦，提高项目的开发效率。
在项目中引入 Spring 立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。 容器提供单例模式支持，开发人员不再需要自己编写实现代码。 容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
Spring 源码架构
Spring 总共大约有20个模块，由1300多个不同的文件构成。而这些组件被分别整合在核心容器（Core Container）、Aop（Aspect Oriented Programming）和设备支持（Instrmentation）、数据访问及集成（Data Access/Integeration）、Web、报文发送（Messaging）、测试6个模块集合中。
- 核心容器：Spring-beans 和 Spring-core 模块是 Spring 框架的核心模块，包含控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）,核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，工厂模式的实现。BeanFactory 使用控制反转（IOC） 思想将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文Spring Context：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring-Expression 模块是统一表达式语言（unified EL）的扩展模块，可以查询、管理运行中的对象，同时也方便的可以调用对象方法、操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。
- Spring-AOP：Spring-aop是Spring的另一个核心模块, 在Spring中，他是以JVM的动态代理技术为基础，然后设计出了一系列的Aop横切实现，比如前置通知、返回通知、异常通知等。通过其配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。
- Spring Data Access(数据访问)：由Spring-jdbc、Spring-tx、Spring-orm、Spring-jms和Spring-oxm 5个模块组成 Spring-jdbc 模块是 Spring 提供的JDBC抽象框架的主要实现模块，用于简化 Spring JDBC。
Spring-tx 模块是SpringJDBC事务控制实现模块。使用Spring框架，它对事务做了很好的封装，通过它的Aop配置，可以灵活的配置在任何一层。
Spring-Orm 模块是ORM框架支持模块，主要集成 hibernate, Java Persistence API (JPA) 和 Java Data Objects (JDO) 用于资源管理、数据访问对象(DAO)的实现和事务策略。
Spring-Jms 模块（Java Messaging Service）能够发送和接受信息。
Spring-Oxm 模块主要提供一个抽象层以支撑OXM（OXM 是 Object-to-XML-Mapping 的缩写，它是一个O/M-mapper，将java对象映射成 XML 数据，或者将 XML 数据映射成 java 对象），例如：JAXB, Castor, XMLBeans, JiBX 和 XStream 等。
- Web 模块：由Spring-web、Spring-webmvc、Spring-websocket和Spring-webmvc-portlet 4个模块组成，Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
- 报文发送：即Spring-messaging模块。
Spring-messaging是Spring4 新加入的一个模块，主要职责是为Spring 框架集成一些基础的报文传送应用。
- 单元测试：即Spring-test模块。Spring-test模块主要为测试提供支持
Spring 框架环境搭建
环境要求
JDK 版本：
JDK 1.7 及以上版本
Spring版本：
Spring 5.x版本
新建 Maven 项目
- 创建 Maven 的普通 Java 项目
- 设置项目的坐标
- 设置项目的 Maven 环境
- 设置项目的名称和存放的工作空间
调整项目环境
修改 JDK 版本
UTF-8 1.8 1.8 修改单元测试 JUnit 版本
junit junit 4.12 test build标签中的pluginManagement标签
添加 Spring 框架的依赖坐标
Maven仓库：https://mvnrepository.com/
org.springframework
spring-context
5.2.4.RELEASE
编写 Bean 对象
package com.xxxx.service;
public class UserService {
public void test(){
System.out.println("Hello Spring!");
}
} 添加Spring 配置文件
- 在项目的src下创建文件夹 resources（Alt+insert）
- 将 resources 标记为资源目录
在 srcmainresources 目录下新建 spring.xml 文件，并拷贝官网文档提供的模板内容到 xml 中。
配置 bean 到 xml 中，把对应 bean 纳入到 Spring 容器来管理
spring.xml
在 spring.xml 中配置 Bean 对象
加载配置文件，获取实例化对象
package com.xxxx;
import com.xxxx.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) {
// 获取Spring上下文环境 (加载配置文件)
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
// 通过getBean方法得到Spring容器中实例化好的Bean对象 （实例化Bean对象）
// userService代表的是配置文件中bean标签的id属性值
UserService userService = (UserService) ac.getBean("userService");
// 调用方法 （使用实例化对象）
userService.test();
}
} Spring IOC 容器 Bean 对象实例化模拟
思路:
- 定义Bean 工厂接口，提供获取bean方法
- 定义Bean工厂接口实现类，解析配置文件，实例化Bean对象
- 实现获取Bean方法
定义 Bean 属性对象
package com.xxxx.spring;
/**
* bean对象
* 用来接收配置文件中bean标签的id与class属性值
*/
public class MyBean {
private String id; // bean对象的id属性值
private String clazz; // bean对象的类路径
public MyBean() {
}
public MyBean(String id, String clazz) {
this.id = id;
this.clazz = clazz;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
} 添加 dom4j 坐标依赖
dom4j
dom4j
1.6.1
jaxen
jaxen
1.1.6
准备自定义配置文件
spring.xml
定义 Bean 工厂接口
package com.xxxx.spring;
/**
* Bean 工厂接口定义
*/
public interface MyFactory {
// 通过id值获取对象
public Object getBean(String id);
} 定义 Bean 接口的实现类
package com.xxxx.spring;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 模拟Spring的实现
* 1、通过构造器得到相关配置文件
* 2、通过dom4j解析xml文件，得到List 存放id和class
* 3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过Map存储
* 4、得到指定的实例化对象
*/
public class MyClassPathXmlApplicationContext implements BeanFactory {
private Map beans = new HashMap(); // 实例化后的对象放入map
private List myBeans; // 存放已读取bean 配置信息
/* 1、通过构造器得到相关配置文件 */
public MyClassPathXmlApplicationContext(String fileName) {
/* 2、通过dom4j解析xml文件，得到List （存放id和class） */
this.parseXml(fileName);
/* 3、通过反射实例化得到对象Class.forName(类路径).newInstance(); 通过Map存储 */
this.instanceBean();
}
/**
* 通过dom4j解析xml文件，得到List 存放id和class
* 1、获取解析器
* 2、得到配置文件的URL
* 3、通过解析器解析xml文件（spring.xml）
* 4、通过xpath语法，获取beans标签下的所有bean标签
* 5、通过指定语法解析文档对象，返回集合
* 6、判断集合是否为空，遍历集合
* 7、获取标签元素中的属性
* 8、得到Bean对象，将Bean对象设置到集合中
* @param fileName
*/
private void parseXml(String fileName) {
// 1、获取解析器
SAXReader reader = new SAXReader();
// 2、得到配置文件的URL
URL url = this.getClass().getClassLoader().getResource(fileName);
try {
// 3、通过解析器解析xml文件（spring.xml）
Document document = reader.read(url);
// 4、通过xpath语法，获取beans标签下的所有bean标签
XPath xPath = document.createXPath("beans/bean");
// 通过指定语法解析文档对象，返回集合
List list = xPath.selectNodes(document);
// 判断集合是否为空，遍历集合
if (list != null && list.size() > 0) {
myBeans = new ArrayList<>();
for(Element el : list) {
// 获取标签元素中的属性
String id = el.attributeValue("id"); // id 属性值
String clazz = el.attributeValue("class"); // class 属性值
System.out.println(el.attributeValue("id"));
System.out.println(el.attributeValue("class"));
// 得到Bean对象
MyBean bean = new MyBean(id, clazz);
// 将Bean对象设置到集合中
myBeans.add(bean);
}
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
/**
* 通过反射实例化得到对象
* Class.forName(类的全路径).newInstance();
* 通过Map存储
*/
private void instanceBean() {
// 判断bean集合是否为空，不为空遍历得到对应Bean对象
if (myBeans != null && myBeans.size() > 0) {
for (MyBean bean : myBeans){
try {
// 通过类的全路径实例化对象
Object object = Class.forName(bean.getClazz()).newInstance();
// 将id与实例化对象设置到map对象中
beans.put(bean.getId(), object);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
/**
* 通过key获取map中的指定value
* @param id
* @return
*/
@Override
public Object getBean(String id) {
Object object = beans.get(id);
return object;
}
} 测试自定义 IOC 容器
创建与配置文件中对应的Bean对象
UserService.java
package com.xxxx.service; public class UserService { public void test(){ System.out.println("UserService Test..."); } }AccountService.java
package com.xxxx.service; public class AccountService { public void test(){ System.out.println("AccountService Test..."); } }测试是否可以获取实例化的Bean对象
package com.xxxx; import com.xxxx.spring.MyFactory; import com.xxxx.spring.MyClassPathXmlApplicationContext; import com.xxxx.service.AccountService; import com.xxxx.service.UserService; public class App { public static void main(String[] args) { MyFactory factory = new MyClassPathXmlApplicationContext("spring.xml"); // 得到实例化对象 UserService userService = (UserService) factory.getBean("userService"); userService.test(); UserService userService2 = (UserService) factory.getBean("userService"); System.out.println(userService+"=====" + userService2); AccountService accountService = (AccountService)factory.getBean("accountService"); accountService.test(); } } Spring 容器在启动的时候 读取xml配置信息，并对配置的 bean 进行实例化（这里模拟的比较简单，仅用于帮助大家理解），同时通过上下文对象提供的 getBean() 方法拿到我们配置的 bean 对象，从而实现外部容器自动化维护并创建 bean 的效果。
Spring IOC 配置文件加载
Spring 配置文件加载
spring.xml
根据相对路径加载资源
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); 根据绝对路径加载资源（了解）
ApplicationContext ac = new FileSystemXmlApplicationContext("C:/IdeaWorkspace/spring01/src/main/resources/spring.xml"); Spring 多配置文件加载
Spring 框架启动时可以加载多个配置文件到环境中。对于比较复杂的项目，可能对应的配置文件有多个，项目在启动部署时会将多个配置文件同时加载进来。
service.xml
dao.xml
可变参数，传入多个文件名
// 同时加载多个资源文件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml","dao.xml"); 通过总的配置文件import其他配置文件
spring.xml
加载时只需加载总的配置文件即可
// 加载总的资源文件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); Spring IOC 容器 Bean 对象实例化
构造器实例化
注：通过默认构造器创建 空构造方法必须存在 否则创建失败
设置配置文件 spring.xml
获取实例化对象
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (UserService) ac.getBean("userService"); userService.test();
静态工厂实例化（了解）
注：
- 要有该工厂类及工厂方法
- 工厂方法为静态的
定义静态工厂类
package com.xxxx.factory; import com.xxxx.service.UserService; /** * 定义静态工厂类 */ public class StaticFactory { /** * 定义对应的静态方法，返回实例化对象 * @return */ public static UserService createUserService() { return new UserService(); } }设置配置文件 spring.xml
获取实例化对象
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (UserService) ac.getBean("userService"); userService.test(); 当我们指定Spring使用静态工厂方法来创建Bean实例时，Spring将先解析配置文件，并根据配置文件指定的信息，通过反射调用静态工厂类的静态工厂方法，并将该静态工厂方法的返回值作为Bean实例，在这个过程中，Spring不再负责创建Bean实例，Bean实例是由用户提供的静态工厂方法提供的。
实例化工厂实例化（了解）
注：
- 工厂方法为非静态方法
- 需要配置工厂bean，并在业务bean中配置factory-bean，factory-method属性
定义工厂类
package com.xxxx.factory; import com.xxxx.service.UserService; /** * 定义工厂类 */ public class InstanceFactory { /** * 定义方法，返回实例化对象 * @return */ public UserService createUserService() { return new UserService(); } }设置配置文件 spring.xml
获取实例化对象
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (UserService) ac.getBean("userService"); userService.test();
Spring三种实例化Bean的方式比较
- 方式一：通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。
- 方式二：利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。
- 方式三：利用实例化factory方法创建，即将factory方法也作为了业务bean来控制，1可用于集成其他框架的bean创建管理方法，2能够使bean和factory的角色互换。
开发中项目一般使用一种方式实例化bean，项目开发基本采用第一种方式，交给Spring托管，使用时直接拿来使用即可。另外两种了解
Spring IOC 注入
手动实例化与外部引入
图一：
图二：
对比发现：图二中对于 UserDao 对象的创建并没有像图一那样主动的去实例化，而是通过带参方法形式将UserDao 传入过来，从而实现 UserService 对UserDao类 的依赖。
而实际创建对象的幕后对象即是交给了外部来创建。
Spring IOC 手动装配（注入）
Spring 支持的注入方式共有四种：set 注入、构造器注入、静态工厂注入、实例化工厂注入。
set方法注入
注：
- 属性字段需要提供set方法
- 四种方式，推荐使用set方法注入
业务对象 JavaBean
属性字段提供set方法
public class UserService { // 业务对象UserDao set注入（提供set方法） private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } }配置文件的bean标签设置property标签
常用对象和基本类型
属性字段提供set方法
public class UserService { // 常用对象String set注入（提供set方法） private String host; public void setHost(String host) { this.host = host; } // 基本类型Integer set注入（提供set方法） private Integer port; public void setPort(Integer port) { this.port = port; } }配置文件的bean标签设置property标签
集合类型和属性对象
属性字段提供set方法
public class UserService { // List集合 set注入（提供set方法） public Listlist; public void setList(List list) { this.list = list; } // Set集合 set注入（提供set方法） private Set set; public void setSet(Set set) { this.set = set; } // Map set注入（提供set方法） private Map 配置文件的bean标签设置property标签
上海 北京 杭州 上海SH 北京BJ 杭州HZ 东方明珠 天安门 西湖
测试代码
UserService.java
public class UserService {
// 业务对象UserDao set注入（提供set方法）
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
// 常用对象String set注入（提供set方法）
private String host;
public void setHost(String host) {
this.host = host;
}
// 基本类型Integer set注入（提供set方法）
private Integer port;
public void setPort(Integer port) {
this.port = port;
}
// List集合 set注入（提供set方法）
public List list;
public void setList(List list) {
this.list = list;
}
// List集合输出
public void printList() {
list.forEach(s -> System.out.println(s));
}
// Set集合 set注入（提供set方法）
private Set set;
public void setSet(Set set) {
this.set = set;
}
// Set集合输出
public void printSet() {
set.forEach(s -> System.out.println(s));
}
// Map set注入（提供set方法）
private Map map;
public void setMap(Map map) {
this.map = map;
}
// Map输出
public void printMap() {
map.forEach((k,v) -> System.out.println(k + "，" + v));
}
// Properties set注入（提供set方法）
private Properties properties;
public void setProperties(Properties properties) {
this.properties = properties;
}
// Properties输出
public void printProperties(){
properties.forEach((k,v) -> System.out.println(k + "，"+ v ));
}
public void test(){
System.out.println("UserService Test...");
userDao.test();
studentDao.test();
System.out.println("Host：" + host + "，port：" + port);
// List集合
printList();
// Set集合
printSet();
// Map
printMap();
// Properties
printProperties();
}
} spring.xml
上海
北京
杭州
上海SH
北京BJ
杭州HZ
东方明珠
天安门
西湖
构造器注入
注：
- 提供带参构造器
单个Bean对象作为参数
Java 代码
public class UserService {
private UserDao userDao; // JavaBean 对象
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public void test(){
System.out.println("UserService Test...");
userDao.test();
}
} XML配置
多个Bean对象作为参数
Java 代码
public class UserService {
private UserDao userDao; // JavaBean 对象
private AccountDao accountDao // JavaBean 对象
public UserService(UserDao userDao, AccountDao accountDao) {
this.userDao = userDao;
this.accountDao = accountDao;
}
public void test(){
System.out.println("UserService Test...");
userDao.test();
accountDao.test();
}
} XML配置
Bean对象和常用对象作为参数
Java 代码
public class UserService {
private UserDao userDao; // JavaBean 对象
private AccountDao accountDao; // JavaBean 对象
private String uname; // 字符串类型
public UserService(UserDao userDao, AccountDao accountDao, String uname) {
this.userDao = userDao;
this.accountDao = accountDao;
this.uname = uname;
}
public void test(){
System.out.println("UserService Test...");
userDao.test();
accountDao.test();
System.out.println("uname：" + uname);
}
} XML配置
循环依赖问题
循环问题产生的原因：
Bean通过构造器注入，之间彼此相互依赖对方导致bean无法实例化。
问题展示：
Java 代码
public class AccountService { private RoleService roleService; public AccountService(RoleService roleService) { this.roleService = roleService; } public void test() { System.out.println("AccountService Test..."); } } public class RoleService { private AccountService accountService; public RoleService(AccountService accountService) { this.accountService = accountService; } public void test() { System.out.println("RoleService Test..."); } }XML配置
如何解决：将构造器注入改为set方法注入
Java代码
public class AccountService { private RoleService roleService; /* public AccountService(RoleService roleService) { this.roleService = roleService; }*/ public void setRoleService(RoleService roleService) { this.roleService = roleService; } public void test() { System.out.println("AccountService Test..."); } } public class RoleService { private AccountService accountService; /* public RoleService(AccountService accountService) { this.accountService = accountService; }*/ public void setAccountService(AccountService accountService) { this.accountService = accountService; } public void test() { System.out.println("RoleService Test..."); } }XML配置
静态工厂注入
定义静态工厂类
public class StaticFactory { // 定义静态方法 public static TypeDao createTypeDao() { return new TypeDao(); } }Java代码
public class TypeService { private TypeDao typeDao; public void setTypeDao(TypeDao typeDao) { this.typeDao = typeDao; } public void test() { System.out.println("TypeService Test..."); } }XML配置
在配置文件中设置bean标签，指定工厂对象并设置对应的方法
实例化工厂注入
定义工厂类
public class InstanceFactory { public TypeDao createTypeDao() { return new TypeDao(); } }Java代码
public class TypeService { private TypeDao typeDao; public void setTypeDao(TypeDao typeDao) { this.typeDao = typeDao; } public void test() { System.out.println("TypeService Test..."); } }XML配置
声明工厂bean标签，声明bean对象，指明工厂对象和工厂方法
重点掌握set注入和构造器注入，工厂方式了解即可。实际开发中基本使用set方式注入bean。
注入方式的选择
开发项目中set方式注入首选
使用构造注入可以在构建对象的同时一并完成依赖关系的建立，对象一建立则所有的一切也就准备好了，但如果要建立的对象关系很多，使用构造器注入会在构建函数上留下一长串的参数,且不易记忆,这时使用Set注入会是个不错的选择。
使用Set注入可以有明确的名称，可以了解注入的对象会是什么，像setXXX()这样的名称会比记忆Constructor上某个参数的位置代表某个对象更好。
p名称空间的使用
spring2.5以后，为了简化setter方法属性注入，引用p名称空间的概念，可以将 子元素，简化为元素属性配置。
属性字段提供 set 方法
public class UserService { // 业务对象UserDao set注入（提供set方法） private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } // 常用对象String set注入（提供set方法） private String host; public void setHost(String host) { this.host = host; } }在配置文件 spring.xml 引入 p 名称空间
xmlns:p="http://www.springframework.org/schema/p"
Spring IOC 自动装配（注入）
注解方式注入 Bean
对于 bean 的注入，除了使用 xml 配置以外，可以使用注解配置。注解的配置，可以简化配置文件，提高开发的速度，使程序看上去更简洁。对于注解的解释，Spring对于注解有专门的解释器，对定义的注解进行解析，实现对应bean对象的注入。通过反射技术实现。
准备环境
修改配置文件
开启自动化注入
- 给注入的bean对象添加注解
@Resource注解
@Resource注解实现自动注入（反射）
- 默认根据属性字段名称查找对应的bean对象 （属性字段的名称与bean标签的id属性值相等）
- 如果属性字段名称未找到，则会通过类型（Class类型）查找
- 属性可以提供set方法，也可以不提供set方法
- 注解可以声明在属性级别 或 set方法级别
- 可以设置name属性，name属性值必须与bean标签的id属性值一致；如果设置了name属性值，就只会按照name属性值查找bean对象
- 当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象
代码示例
默认根据属性字段名称查找对应的bean对象 （属性字段的名称与bean标签的id属性值相等）
/** * @Resource注解实现自动注入（反射） * 默认根据属性字段名称查找对应的bean对象 （属性字段的名称与bean标签的id属性值相等） */ public class UserService { @Resource private UserDao userDao; // 属性字段的名称与bean标签的id属性值相等 public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void test() { // 调用UserDao的方法 userDao.test(); } }如果属性字段名称未找到，则会通过类型（Class类型）查找
/** * @Resource注解实现自动注入（反射） * 如果属性字段名称未找到，则会通过类型（Class类型）查找 */ public class UserService { @Resource private UserDao ud; // 当在配置文件中属性字段名（ud）未找到，则会查找对应的class（UserDao类型） public void setUd(UserDao ud) { this.ud = ud; } public void test() { // 调用UserDao的方法 ud.test(); } }属性可以提供set方法，也可以不提供set方法
/** * @Resource注解实现自动注入（反射） * 属性可以提供set方法，也可以不提供set方法 */ public class UserService { @Resource private UserDao userDao; // 不提供set方法 public void test() { // 调用UserDao的方法 userDao.test(); } }注解可以声明在属性级别 或 set方法级别
/** * @Resource注解实现自动注入（反射） * 注解可以声明在属性级别 或 set方法级别 */ public class UserService { private UserDao userDao; @Resource // 注解也可设置在set方法上 public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void test() { // 调用UserDao的方法 userDao.test(); } }可以设置name属性，name属性值必须与bean标签的id属性值一致；如果设置了name属性值，就只会按照name属性值查找bean对象
/** * @Resource注解实现自动注入（反射） * 可以设置name属性，name属性值必须与bean的id属性值一致； * 如果设置了name属性值，就只会按照name属性值查找bean对象 */ public class UserService { @Resource(name = "userDao") // name属性值与配置文件中bean标签的id属性值一致 private UserDao ud; public void test() { // 调用UserDao的方法 ud.test(); } }当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象
定义接口类 IUserDao.java
package com.xxxx.dao; /** * 定义接口类 */ public interface IUserDao { public void test(); }定义接口实现类 UserDao01.java
package com.xxxx.dao; /** * 接口实现类 */ public class UserDao01 implements IUserDao { @Override public void test(){ System.out.println("UserDao01..."); } }定义接口实现类 UserDao02.java
package com.xxxx.dao; /** * 接口实现类 */ public class UserDao02 implements IUserDao { @Override public void test(){ System.out.println("UserDao02..."); } }XML配置文件
使用注解 UserService.java
/** * @Resource注解实现自动注入（反射） * 当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象 */ public class UserService { @Resource(name = "userDao01") // name属性值与其中一个实现类的bean标签的id属性值一致 private IUserDao iUserDao; // 注入接口（接口存在多个实现） public void test() { iUserDao.test(); } }
@Autowired注解
@Autowired注解实现自动化注入：
- 默认通过类型（Class类型）查找bean对象 与属性字段的名称无关
- 属性可以提供set方法，也可以不提供set方法
- 注解可以声明在属性级别 或 set方法级别
- 可以添加@Qualifier结合使用，通过value属性值查找bean对象（value属性值必须要设置，且值要与bean标签的id属性值对应）
默认通过类型（Class类型）查找bean对象 与属性字段的名称无关
/** * @Autowired注解实现自动化注入 * 默认通过类型（Class类型）查找bean对象 与属性字段的名称无关 */ public class UserService { @Autowired private UserDao userDao; // 默认通过类型（Class类型）查找bean对象 与属性字段的名称无关 public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void test() { // 调用UserDao的方法 userDao.test(); } }属性可以提供set方法，也可以不提供set方法
/** * @Autowired注解实现自动化注入 * 属性可以提供set方法，也可以不提供set方法 */ public class UserService { @Autowired private UserDao userDao; // 不提供set方法 public void test() { // 调用UserDao的方法 userDao.test(); } }注解可以声明在属性级别 或 set方法级别
/** * @Autowired注解实现自动化注入 * 注解可以声明在属性级别 或 set方法级别 */ public class UserService { private UserDao userDao; @Autowired// 注解可以声明在set方法级别 public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void test() { // 调用UserDao的方法 userDao.test(); } }可以添加@Qualifier结合使用，通过value属性值查找bean对象（value属性值必须要设置，且值要与bean标签的id属性值对应）
/** * @Autowired注解实现自动化注入 * 可以添加@Qualifier结合使用，通过value属性值查找bean对象 value属性值必须要设置，且值要与bean标签的id属性值对应 */ public class UserService { @Autowired @Qualifier(value="userDao") // value属性值必须要设置，且值要与bean标签的id属性值对应 private UserDao userDao; public void test() { userDao.test(); } }推荐使用@Resource 注解是属于J2EE的，减少了与Spring的耦合。
Spring IOC 扫描器
实际的开发中，bean的数量非常多，采用手动配置bean的方式已无法满足生产需要，Spring这时候同样提供了扫描的方式，对扫描到的bean对象统一进行管理，简化开发配置，提高开发效率。
Spring IOC 扫描器的配置
Spring IOC 扫描器
作用：bean对象统一进行管理，简化开发配置，提高开发效率
1、设置自动化扫描的范围
如果bean对象未在指定包范围，即使声明了注解，也无法实例化
2、使用指定的注解（声明在类级别） bean对象的id属性默认是 类的首字母小写
Dao层：
@Repository
Service层：
@Service
Controller层：
@Controller
任意类：
@Component
注：开发过程中建议按照指定规则声明注解 设置自动化扫描范围
使用特定的注解
@Repository （Dao层）
@Repository public class ResourceDao { public void test() { System.out.println("ResourceDao..."); } }@Service（Service层 ）
@Service public class ResourceService { @Resource private ResourceDao resourceDao; // service层注入dao层的bean对象 public void test() { System.out.println("ResourceService..."); resourceDao.test(); } }@Controller （Controller 层 ）
@Controller public class ResourceController { @Autowired private ResourceService resourceService; // Controller层注入service层的bean对象 public void test() { System.out.println("ResourceController..."); resourceService.test(); } }@Component （任意层）
@Component public class PropertyUtils { public void test(){ System.out.println("PropertyUtils..."); } }
Spring 模拟用户登录流程
Dao层 （查询用户记录）
定义JavaBean User.java
package com.xxxx.po; /** * User 用户实体类 */ public class User { private String userName; // 用户名称 private String userPwd; // 用户密码 public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getUserPwd() { return userPwd; } public void setUserPwd(String userPwd) { this.userPwd = userPwd; } }编写Dao层 UserDao.java
package com.xxxx.dao; import com.xxxx.po.User; import org.springframework.stereotype.Repository; @Repository public class UserDao { private final String USERNAME = "admin"; private final String USERPWD = "admin"; /** * 通过用户名称查询用户对象 * @param userName * @return */ public User queryUserByUserName(String userName){ User user = null; // 判断用户名称是否正确 if(!USERNAME.equals(userName)){ // 如果不正确，返回null return null; } // 如果正确，将用户名称和密码设置到user对象中 user = new User(); user.setUserName(USERNAME); user.setUserPwd(USERPWD); return user; } }
Service层 （业务逻辑处理）
定义业务处理返回消息模型 MessageModel.java
package com.xxxx.po.vo; /** * 定义业务处理返回消息模型 * 封装返回结果 */ public class MessageModel { private Integer resultCode = 1; // 结果状态码 1=成功，0=失败 private String resultMsg = "操作成功！"; // 结果提示信息 public Integer getResultCode() { return resultCode; } public void setResultCode(Integer resultCode) { this.resultCode = resultCode; } public String getResultMsg() { return resultMsg; } public void setResultMsg(String resultMsg) { this.resultMsg = resultMsg; } }编写Service层 UserService.java
package com.xxxx.service; import com.xxxx.dao.UserDao1; import com.xxxx.po.User; import com.xxxx.po.vo.MessageModel; import org.springframework.stereotype.Service; import javax.annotation.Resource; @Service public class UserService { @Resource private UserDao userDao; /** * 验证用户登录 * @param userName * @param userPwd * @return */ public MessageModel userLoginCheck(String userName, String userPwd){ // 定义业务处理返回消息模型 MessageModel messageModel = new MessageModel(); // 判断用户名称是否非空 if(null == userName || "".equals(userName.trim())){ messageModel.setResultCode(0); messageModel.setResultMsg("用户名不能为空！"); return messageModel; } // 判断用户密码是否为空 if(null == userPwd || "".equals(userPwd.trim())){ messageModel.setResultCode(0); messageModel.setResultMsg("密码不能为空！"); return messageModel; } // 通过用户名称查询用户对象 User user = userDao.queryUserByUserName(userName); // 判断用户对象是否为空 if(null == user){ messageModel.setResultCode(0); messageModel.setResultMsg("该用户不存在！"); return messageModel; } // 如果用户对象不为空，判断密码是否正确 if(!user.getUserPwd().equals(userPwd)){ messageModel.setResultCode(0); messageModel.setResultMsg("用户密码不正确！"); return messageModel; } // 登录成功 messageModel.setResultMsg("登录成功！"); return messageModel; } }
Controller层 （接收请求）
编写Controller层 UserController.java
package com.xxxx.controller; import com.xxxx.po.vo.MessageModel; import com.xxxx.service.UserService1; import org.springframework.stereotype.Controller; import javax.annotation.Resource; @Controller public class UserController { @Resource private UserService userService; /** * 用户登录 * @param userName * @param userPwd * @return */ public MessageModel login(String userName, String userPwd){ // 调用Dao层判断用户登录操作，返回结果 MessageModel messageModel = userService.userLoginCheck(userName, userPwd); return messageModel; } }
通过 JUnit 进行测试
package com.xxxx;
import com.xxxx.controller.UserController;
import com.xxxx.po.vo.MessageModel;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestLogin {
@Test
public void test() {
// 得到Spring容器上下文环境
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
// 得到UserController实例化对象
UserController userController = (UserController) ac.getBean("userController");
// 传入参数调用UserController的方法，返回封装类
MessageModel messageModel= userController.login("admin", "admin");
System.out.println("状态码：" + messageModel.getResultCode() + "，提示信息：" + messageModel.getResultMsg());
}
} Bean的作用域与生命周期
Bean的作用域
默认情况下，我们从Spring容器中拿到的对象均是单例的，对于bean的作用域类型如下：
singleton 作用域
注意: lazy-init是懒加载, 如果等于true时作用是指Spring容器启动的时候不会去实例化这个bean, 而是在程序调用时才去实例化. 默认是false即Spring容器启动时实例化.
默认情况下，被管理的bean只会IOC容器中存在一个实例，对于所有获取该Bean的操作Spring容器将只返回同一个Bean。
容器在启动的情况下就实例化所有singleton 的 bean对象，并缓存与容器中
lazy-init属性（懒加载）
如果为false，则在IOC容器启动时会实例化bean对象，默认false
如果为true，则IOC容器启动时不会实例化Bean对象，在使用bean对象时才会实例化
lazy-init设置为false有什么好处？
1）可以提前发现潜在的配置问题
2）Bean 对象存在于缓存中，使用时不用再去实例化bean，加快程序运行效率
什么对象适合作为单例对象？
一般来说对于无状态或状态不可改变的对象适合使用单例模式。（不存在会改变对象状态的成员变量）
比如：controller层、service层、dao层
什么是无状态或状态不可改变的对象？
实际上对象状态的变化往往均是由于属性值得变化而引起的，比如user类 姓名属性会有变化，属性姓名的变化一般会引起user对象状态的变化。对于我们的程序来说，无状态对象没有实例变量的存在，保证了线程的安全性，service 层业务对象即是无状态对象。线程安全的。
prototype 作用域
通过scope=“prototype” 设置bean的类型 ，每次向Spring容器请求获取Bean都返回一个全新的Bean，相对于"singleton"来说就是不缓存Bean，每次都是一个根据Bean定义创建的全新Bean。
Web应用中的作用域
- request作用域
表示每个请求需要容器创建一个全新Bean。比如提交表单的数据必须是对每次请求新建一个Bean来保持这些表单数据，请求结束释放这些数据。
- session作用域
表示每个会话需要容器创建一个全新Bean。比如对于每个用户一般会有一个会话，该用户的用户信息需要存储到会话中，此时可以将该Bean作用域配置为session级别。
- globalSession作用域
类似于session作用域，其用于portlet(Portlet是基于Java的Web组件，由Portlet容器管理，并由容器处理请求，生产动态内容)环境的web应用。如果在非portlet环境将视为session作用域。
配置方式和基本的作用域相同，只是必须要有web环境支持，并配置相应的容器监听器或拦截器从而能应用这些作用域，目前先熟悉概念，后续集成web时讲解具体使用，大家只需要知道有这些作用域就可以了。
Bean的生命周期
对比已经学过的servlet 生命周期（容器启动装载并实例化servlet类，初始化servlet，调用service方法，销毁servlet）。
同样对于Spring容器管理的bean也存在生命周期的概念
在Spring中，Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段
Bean的定义
在Spring中，通常是通过配置文档的方式来定义Bean的。
在一个配置文档中，可以定义多个Bean。
Bean 的初始化
默认在IOC容器加载时，实例化对象。
Spring bean 初始化有两种方式：
方式一：在配置文档中通过指定 init-method 属性来完成。
public class RoleService {
// 定义初始化时需要被调用的方法
public void init() {
System.out.println("RoleService init...");
}
}
方式二： 实现 org.springframework.beans.factory.InitializingBean 接口。
public class RoleService implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("RoleService init...");
}
} Bean对象实例化过程是在Spring容器初始化时被实例化的，但也不是不可改变的，可以通过 lazy-init=“true” 属性延迟bean对象的初始化操作，此时再调用getBean 方法时才会进行bean的初始化操作
Bean 的使用
方式一：使用 BeanFactory
// 得到Spring的上下文环境
BeanFactory factory = new ClassPathXmlApplicationContext("spring.xml");
RoleService roleService = (RoleService) factory.getBean("roleService"); 方式二：使用 ApplicationContext
// 得到Spring的上下文环境
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
RoleService roleService = (RoleService) ac.getBean("roleService"); Bean的销毁
实现销毁方式(Spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)。
步骤一：实现销毁方式(Spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)
**步骤二：**通过 AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程 AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("spring.xml");
ctx.close(); IOC/DI-控制反转和依赖注入
将对象实例化的创建过程转交给外部容器（IOC容器 充当工厂角色）去负