黄俊勇基于spring框架的研究与设计参考文献格式

1 Spring概述

1.1 什么是Spring

Rod Johnson(http://baike.baidu.com/item/Rod Johnson)在2002年编著的《Expert one on one J2EE design and development》一书中，对Java EE 系统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破J2EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-on-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson成为一个改变Java世界的大师级人物。

传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务、事务处理等。

Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。

1.2 Spring框架的结构体系

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图所示：

组成Spring框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

1. 内核容器（Core Container）

内核容器是由spring-core、spring-beans、spring-context、spring-context-sup和spring-expression（Spring Expression Language）模块组成。 Spring-core和spring-beans模块提供了框架的基本功能，包括IoC和依赖注入特性。BeanFactory是工场模式的精美实现。它不需要单独的编程逻辑就可以把所依赖的配置和规范从程序的实际逻辑中分离开。

Context（spring-context）模块是在Core和Beans模块的基础之上构建的。Context模块继承了Beans模块的特性，并添加了国际化(i18n)（使用资源绑定的方式）、事件传播、资源加载、以及通过Servlet容器透明创建的上下文环境。Context模块也支持*Java EE*特性，如EJB、JMX和基本的远程调用。ApplicationContext接口是Context模块的入口.

spring-context-support提供了把常用的第三方类库（如缓存（EhCache、Guava、JCache）、邮件（JavaMail）、计划（CommonJ、Quartz）、以及模板引擎（FreeMarker、JasperReports、Velocity））集成到Spring应用场景中的支持。
spring-expression模块提供了可用于运行时查询和操作对象的强大的表达式语言。它是JSP2.1规范中指定的统一表达式语言的一个扩展。它支持设置和获取属性值、属性匹配、方法调用、访问数组内容、集合和索引、逻辑和算术运算、命名变量、以及使用对象名从Spring容器中检索对象等功能。它还支持列表的投射和选择以及常用的列表聚合。

2. AOP和监测器（Instrumentation）

spring-aop提供了可定义的符合AOP联盟标准的面向切面编程的实现。例如，应该把拦截器和切入点的方法与实现功能的代码进行清晰的解耦分离。使用代码级的元数据功能，也可以像.NET的属性那样把行为信息合并到代码中。

独立的spring-aspects模块提供AspectJ的集成。

spring-instrument模块提供了类的检测支持，并且类的加载器实现可以被用于特定应用服务中。spring-instrument-tomcat模块包含了Spring给Tomcat提供的监测代理。

3. 消息传递
   Spring 框架包含的spring-messaging模块带有一些来自诸如Message、MessageChannel、MessageHandler等Spring Integration对象的关键抽象，它们被用于基于消息传递应用的服务基础。这个模块映射包含了一组用于消息映射的方法注释，类似于基于编程模式的Spring MVC注释。
4. 数据访问/集成
   数据访问/集成层是由JDBC、ORM、OXM、JMS和事务模块组成。
   spring-jdbc模块提供了一个JDBC抽象层，它剔除了繁琐的JDBC编码和数据库供应商指定的错误代码的解析。
   对于实现指定接口的类和所有的POJO对象，spring-tx模块提供的编程和声明式事务的支持。
   spring-orm模块提供了通用的对象-关系映射API的集成层，包括对JPA、JDO和*hibernate*集成。使用spring-orm模块可以使用跟Spring提供的其他功能合并到一起的所有的O/R映射框架，例如前面提到的简单的声明式事务管理功能。
   spring-oxm提供了一个支持Object/XML映射实现带的抽象层，如JAXB、Castor、XMLBeans、JiBX和XStream等。
   spring-jms模块（Java消息服务）包含了制造和使用消息的功能，从 Spring框架4.1开始，它就集成了spring-messaging模块。
5. Web
   Web层由spring-web、spring-webmvc、spring-websocket和spring-webmvc-portlet模块组成。
   spring-web模块提供了基本的面向web的基础功能，例如分段上传文件功能、使用Servlet监听器来初始化IoC容器，以及面向web的应用程序环境。它还包含了一个HTTP客户端和Spring远程支持的web相关的部分。
   spring-webmvc模块（也被叫做Web-Servlet模块）包含了Spring的MVC框架和用于web应用程序的REST web服务的实现。Spring的MVC框架在域模型代码和web表达之间提供了清晰的边界，并且还集成了Spring框架的所有其他功能。
   spring-webmvc-portlet模块（也被叫做Web-Portlet模块）提供了用于Portlet环境和映射spring-webmvc模块功能的MVC实现。
6. 测试
   spring-test模块支持使用带有JUnit或TestNG的Spring 组件进行单元测试和集成测试。它提供了固定的Spring的ApplicationContests加载以及这些环境的缓存。它还提供了mock对象，可以让你使用隔离的方式来测试你的代码。

1.3 Spring的核心

• IoC （Inverse of control ）反转控制 或者DI (Dependency Injection，依赖注入
• AOP （Aspect Oriented Programming）面向切面编程

Spring的官网:http://spring.io

2.Spring的IoC之Hello World

我们创建一个maven项目,导入Spring的依赖

添加spring相关依赖,对应的pom.xml文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <spring.version>5.2.15.RELEASE</spring.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring-test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
		<!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>
</project>

编写IHello接口:

package com.suke.hello;

public interface IHello {
    public String sayHello(String word);
}

编写IHello的实现类:

package com.suke.hello.impl;

import com.suke.hello.IHello;

public class HelloImpl implements IHello {
    public String sayHello(String word) {
        return "hello:"+word;
    }
}

在src/main/resources目录下创建一个spring的配置文件:

在applicationContext.xml文件中,把HelloImpl交给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 class="com.suke.hello.impl.HelloImpl" id="hello"></bean>
</beans>

编写测试类,测试IHello的sayHello()方法

package com.suke.hello;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.Assert.*;

public class IHelloTest {
    
    @Test
    public void sayHello() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        IHello hello = applicationContext.getBean("hello", IHello.class);
        System.out.println(hello.sayHello("spring"));
    }
}

ApplicationContext的继承体系

**applicationContext：**接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象

ApplicationContext的实现类

1）ClassPathXmlApplicationContext

它是从类的根路径下加载配置文件 推荐使用这种

2）FileSystemXmlApplicationContext

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext

当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

测试结果:

如果想看到Spring运行的日志,我们可以添加log4j日志框架,并在src/main/resources目录添加log4j的配置文件:

<!--log4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.36</version>
</dependency>

log4j.properties

log4j.rootCategory=DEBUG, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n

IOC的理解

1996年，Michael Mattson(迈克尔·马特森)在一篇有关探讨面向对象框架的文章中，首先提出了IOC 这个概念。

IoC(Inversion of Control，即“控制反转”)不是什么技术，而是一种设计思想。在Java开发中，IoC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好IoC呢？理解好IoC的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由IoC容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

用图例说明一下，传统程序设计如图，都是主动去创建相关对象然后再组合起来：

图 传统应用程序示意图

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了，如图所示:

图: IoC/DI容器后程序结构示意图

**IoC(控制反转)就是将程序中原来 new 对象，交给spring创建，从spring工厂获取对象,使用spring来负责控制对象的生命周期和对象间的关系.**这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像范冰冰，身材像林熙雷，唱歌像张学友，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。

Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

3. Spring的DI入门程序

在前面的案例中,我们再创建UserDao接口和UserDaoImpl的实现类:

package com.suke.dao;

public interface UserDao {
    public void insert();
    public void delete();
}

---

package com.suke.dao.impl;

import com.suke.dao.UserDao;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserDaoImpl implements UserDao {
    @Override
    public void insert() {
        log.info("保存用户成功...");
    }

    @Override
    public void delete() {
        log.info("删除用户成功...");
    }
}

接下来我们来创建UserService接口和对应的实现类, 然后调用UserDao的方法完成相关的业务功能:

package com.suke.service;

public interface UserService {
    public void addUser();

    public void deleteUser();
}

---

package com.suke.service.impl;

import com.suke.dao.UserDao;
import com.suke.service.UserService;

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void addUser() {
        userDao.insert();

    }

    @Override
    public void deleteUser() {
        userDao.delete();
    }
}

在applicationContext.xml文件中配置UserDao和UserService的bean:

<bean class="com.suke.dao.impl.UserDaoImpl" id="userDao"></bean>
<bean class="com.suke.service.impl.UserServiceImpl" id="userService">
    <property name="userDao" ref="userDao"></property>
</bean>

编写对应的测试类:

package com.suke.service;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.Assert.*;

public class UserServiceTest {
    private  UserService userService;

    @Before
    public void setUp(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        userService = applicationContext.getBean("userService",UserService.class);
    }
    @Test
    public void addUser() {
        userService.addUser();
    }

    @Test
    public void deleteUser() {
        userService.deleteUser();
    }
}

测试结果:

DI的理解

DI(Dependency Injection)即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 谁依赖于谁：当然是应用程序依赖于IoC容器；
• 为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
• 谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
• 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（依赖注入）来实现的**。**比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

IoC和DI是什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），2004年，Martin Fowler探讨了同一个问题，既然IOC是控制反转，那么到底是“哪些方面的控制被反转了呢？”，经过详细地分析和论证后，他得出了答案：“获得依赖对象的过程被反转了”。控制被反转之后，获得依赖对象的过程由自身管理变为了由IOC容器主动注入。于是，他给“控制反转”取了一个更合适的名字叫做“依赖注入（Dependency Injection）”。他的这个答案，实际上给出了实现IOC的方法：注入。所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。 理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在spring的框架中堆积木而已。