Spring 框架概念

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个模块集合中。

1. 核心容器：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，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。

2. Spring-AOP：Spring-aop是Spring的另一个核心模块, 在Spring中，他是以JVM的动态代理技术为基础，然后设计出了一系列的Aop横切实现，比如前置通知、返回通知、异常通知等。通过其配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。

3. 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 等。

4. Web 模块：由Spring-web、Spring-webmvc、Spring-websocket和Spring-webmvc-portlet 4个模块组成，Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

5. 报文发送：即Spring-messaging模块。

   Spring-messaging是Spring4 新加入的一个模块，主要职责是为Spring 框架集成一些基础的报文传送应用。

6. 单元测试：即Spring-test模块。Spring-test模块主要为测试提供支持

Spring 框架环境搭建

环境要求

JDK 版本：

JDK 1.7 及以上版本

Spring版本：

Spring 5.x版本

新建 Maven 项目

1. 创建 Maven 的普通 Java 项目

2. 设置项目的坐标

3. 设置项目的 Maven 环境

4. 设置项目的名称和存放的工作空间

调整项目环境

1. 修改 JDK 版本

   
    UTF-8
    1.8
    1.8
    

2. 修改单元测试 JUnit 版本

   
    junit
    junit
    4.12
    test
    

3. 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 配置文件

1. 在项目的src下创建文件夹 resources（Alt+insert）

2. 将 resources 标记为资源目录

3. 在 src\main\resources 目录下新建 spring.xml 文件，并拷贝官网文档提供的模板内容到 xml 中。

   配置 bean 到 xml 中，把对应 bean 纳入到 Spring 容器来管理

   spring.xml

   
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">
    ​
    
   
    ​
    

4. 在 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 对象实例化模拟

思路:

1. 定义Bean 工厂接口，提供获取bean方法

2. 定义Bean工厂接口实现类，解析配置文件，实例化Bean对象

3. 实现获取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;
 }
 }