Spring 6月 5,2019

《精通Spring》（一）

第1章 Spring启程

本章内容将给出若干个基于Spring开发的相关实例，使得开发者能够了解Spring基础知识，从而为深入了解Spring其他内容奠定基础。

1.1 背景知识

作为Open Source框架，Spring是很令人振奋的。Spring从一开始，直到现在，而且包括以后，将持续获得更多开发者的青睐，因为它是优秀的、是为开发者设计的实用框架。现在的Open Source框架很多，但是属于Java/J2EE架构级的优秀框架不多，包括现有流行的Struts、Tapestry等都不是。研究Spring的过程，是很有意义的一件事情，因为它将业界的各种开发经验（包括Open Source的和非Open Source领域的）融入到其中。

Spring提供的控制反转（Inversion of Control，IoC）和面向方面编程（Aspect-Oriented Programming，AOP）插件式架构降低了应用组件之间的依赖性。借助于XML定义文件，开发者能够在运行时连接不同的应用组件。这对于单元测试特别有用，特别是那些需要针对不同客户实施不同配置的应用而言。

目前，存在的依赖注入类型有3种：基于设值（setter-based）方法、基于构建器（constructor-based）以及基于接口（interface-based）注入。Spring IoC支持前两种，即借助于Spring开发者可以通过构建器，或者设值方法创建对象，并对对象的状态进行管理。

其中，依赖注入是Spring框架的基础。Spring在基于依赖注入的基础之上，同时还提供了其他大量的功能，比如Spring MVC框架、事务管理框架、DAO支持、支持主流O/R Mapping工具、支持各种标准J2EE组件技术的基础（JMS/JavaMail/EJB/Web服务器）、集成各种视图（Web视图和非Web视图）技术。这也是使用Spring IoC容器优于其他IoC容器的理由。

1.2 运行Spring实例应用

为阐述清楚Spring IoC框架帮助开发者完成了哪些工作，本章给出的运行实例起到了很重要的作用，即开发者通过代码能够很清楚地看到Spring的具体内容。

1.2.1 实例1：example1

example1（所有的源代码位于example1项目中）并没有使用Spring框架。本章将通过一系列重构步骤，并最终借助于Spring提供的IoC框架来实现实例应用。接下来，给出大体步骤（详细内容，请参考example1项目）。

首先，开发者需要实现FileHelloStr.java类。

package com.openv.spring;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 基于文件形式，读取HelloWorld所需的字符串
 *
 * @author shenhuanjie
 * @date 2019/6/5 10:49
 */
public class FileHelloStr {
    protected static final Log log = LogFactory.getLog(FileHelloStr.class);
    private String propFileName;

    public FileHelloStr(String propFileName) {
        this.propFileName = propFileName;
    }

    public String getContent() {
        String helloWorld = "";

        try {
            Properties properties = new Properties();
            InputStream is = getClass().getClassLoader().getResourceAsStream(propFileName);
            properties.load(is);
            is.close();
            helloWorld = properties.getProperty("hellWorld");
        } catch (FileNotFoundException ex) {
            log.error(ex);
        } catch (IOException ex) {
            log.error(ex);
        }
        return helloWorld;
    }
}

上述类实现了对传入的、名为propFileName的属性文件的读取工作，并能够打印出异常信息。

其次，开发者还需要实现HelloWorld.java类。

package com.openv.spring;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 获得HelloWorld字符串
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:14
 */
public class HelloWorld {
    protected static final Log log = LogFactory.getLog(HelloWorld.class);

    public String getContent() {
        FileHelloStr fhStr = new FileHelloStr("helloWorld.properties");
        String helloWorld = fhStr.getContent();

        return helloWorld;
    }
}

上述类调用了FileHelloStr。

第三部，开发者需要实现HelloWorldClient.java类，从而实现对HelloWorld类的调用。

package com.openv.spring;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * HelloWorld客户应用
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:16
 */
public class HelloWorldClient {
    protected static final Log log = LogFactory.getLog(HelloWorld.class);

    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();
        log.info(hw.getContent());
    }
}

第四步，开发者还需要编写helloWorld.properties文件，内容如下：

hellWorld="Hello World!"

最后，运行example1应用。

通过上述过程，开发者可以看出：HelloWorld明显依赖于FileHelloStr。如果开发者需要通过其他途径获得“Hello World！”信息，则需要重构现有的FileHelloStr类，即通过更通用的HelloStr接口形式给出。一种较好的实现方式是将创建FileHelloStr对象的职责委派给HelloWorldClient客户。example2实现了这种需求。

1.2.2 实例2：example2

example2所有的源代码位于example2项目中。为实现上述需求，开发者需要对example1完成如下几方面的重构（请开发者特别注意粗体内容）。

首先，创建HelloStr接口。

package com.openv.spring;

/**
 * HelloStr接口
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:32
 */
public interface HelloStr {
    public String getContent();
}

其次，声明FileHelloStr实现了HelloStr接口。

package com.openv.spring;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 基于文件形式，读取HelloWorld所需的字符串
 *
 * @author shenhuanjie
 * @date 2019/6/5 10:49
 */
public class FileHelloStr implements HelloStr {
    protected static final Log log = LogFactory.getLog(FileHelloStr.class);
    private String propFileName;

    public FileHelloStr(String propFileName) {
        this.propFileName = propFileName;
    }

    public String getContent() {
        String helloWorld = "";

        try {
            Properties properties = new Properties();
            InputStream is = getClass().getClassLoader().getResourceAsStream(propFileName);
            properties.load(is);
            is.close();
            helloWorld = properties.getProperty("hellWorld");
        } catch (FileNotFoundException ex) {
            log.error(ex);
        } catch (IOException ex) {
            log.error(ex);
        }
        return helloWorld;
    }
}

FileHelloStr.java的其他内容同example1。

第三，重构HelloWorld类。

package com.openv.spring;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 获得HelloWorld字符串
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:14
 */
public class HelloWorld {
    protected static final Log log = LogFactory.getLog(HelloWorld.class);
    private HelloStr hStr;

    public HelloWorld(HelloStr hStr) {
        this.hStr = hStr;
    }

    public String getContent() {
        return hStr.getContent();
    }
}

最后，开发者需要重构HelloWorldClient客户应用。

package com.openv.spring;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * HelloWorld客户应用
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:16
 */
public class HelloWorldClient {
    protected static final Log log = LogFactory.getLog(HelloWorld.class);

    public static void main(String[] args) {
        FileHelloStr fhStr = new FileHelloStr("helloWorld.properties");
        HelloWorld hw = new HelloWorld(fhStr);
        log.info(hw.getContent());
    }
}

至此，开发者可以运行客户应用了。具体输出结果同example1，这里不再给出。

开发者应该注意到：HelloWorld不再操作FileHelloStr了，而是对FileHelloStr实现的HelloStr接口进行操作。从而，现在的HelloWorld更加通用了。但是，现有的应用还是存在一个问题，即开发者必须在其实现的客户代码中创建FileHelloStr对象，并连接到HelloWorld中。因此，开发者需要借助于工厂类，以注入HelloWorld和FileHelloStr的依赖性。这正是example3需要解决的问题。

1.2.3 实例3：example3

example3所有的源代码位于example3项目中。为实现上述需求，开发者需要对example2完成如下几个方面的重构（请开发者特别注意粗体内容）。

首先，创建HelloWorldFactory.java工厂。

package com.openv.spring;

/**
 * 注入HelloWorld和HelloStr依赖性
 *
 * @author shenhuanjie
 * @date 2019/6/5 12:20
 */
public class HelloWorldFactory {
    public static HelloWorld getFileHelloWorld() {
        HelloStr hStr = new FileHelloStr("helloWorld.properties");
        HelloWorld hw = new HelloWorld(hStr);

        return hw;
    }
}

其次，重构客户代码。

package com.openv.spring;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * HelloWorld客户应用
 *
 * @author shenhuanjie
 * @date 2019/6/5 11:16
 */
public class HelloWorldClient {
    protected static final Log log = LogFactory.getLog(HelloWorld.class);

    public static void main(String[] args) {
        HelloWorld hw = HelloWorldFactory.getFileHelloWorld();
        log.info(hw.getContent());
    }
}

最后，运行客户代码，结果同上。

其中，HelloWorldFactory负责创建和集成客户应用所需的对象。至此，开发者终于借助于依赖注入（HelloWorldFactory类）实现了反转控制。

注意上述example1、example2、example3都没有使用到Spring。借助于Spring提供的核心工厂模式，开发者能够消除手工编写工厂类的需要。基于Spring的example4解决了这个问题，即将创建对象的工作交由Spring负责，从而消除了对工厂类、方法的需要。

1.2.4 实例4：example4

对于开发过大型应用系统的开发者而言，他们都熟知：应用系统越大，相应的工厂类越多。一般情况下，工厂类都是简单的、仅提供静态方法和变量的单实例。它们将创建对象，并将这些对象绑定在一起。显而易见，这将存在大量的重复代码。

Spring框架最基本的一项功能就是，充当创建对象的工厂。其具体工作步骤如下：

读取并分析Spring配置文件（比如，基于XML文件格式）。
通过Java反射机制，创建并集成上述配置文件中定义的对象。
将创建的对象传回给开发者的应用代码。因此，开发者不用编写工厂类，其前提是需要使用Spring框架。

至于重构example3，即开发example4（所有的源代码位于example4项目中）的步骤如下。

首先，编写Spring配置文件，即appcontext.xml（开发者也可以基于其他格式编写Spring配置文件，本书其他部分将讨论到相关内容）。

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
        "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean name="fileHelloWorld"
          class="com.openv.spring.HelloWorld">
        <constructor-arg>
            <ref bean="fileHello"/>
        </constructor-arg>
    </bean>

    <bean name="fileHello"
          class="com.openv.spring.FileHelloStr">
        <constructor-arg>
            <value>helloWorld.properties</value>
        </constructor-arg>
    </bean>
</beans>

上述Spring配置文件的根元素为beans，它含有一个或多个bean元素。其中，bean元素用于描述应用代码中的JavaBean对象。

通过name属性能够唯一标识某JavaBean。比如，在上述代码中，通过传入“fileHelloWorld”字符串能够访问到HelloWorld对象。另外，class属性能够确定待实例化的类，比如上述代码中的“class=”com.openv.spring.FileHelloStr”“。当Spring创建JavaBean实例时，bean的constructor-arg子元素值将传入到其构建器中，比如上述代码中的helloWorld.properties。如果构建器存在多个参数，则开发者可以使用index属性（或者type属性）指定对应的参数取值。

通过ref元素能够引用Spring配置文件中的其他已定义的JavaBean。比如，上述代码中的fileHelloWorld引用了fileHello。为将取值传递给构建器（或者设置方法），开发者需要使用value元素。其中，Spring能够将value元素取值转换为相应的Java类型。

其次，重构HelloWorldClient客户代码。

六月 05, 2019 12:47:08 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
六月 05, 2019 12:47:08 下午 com.openv.spring.HelloWorld <init>
信息: "Hello World!"

开发者应该注意到，上述输出结果同前面3个实例有所不同，即除了应用本身的输出信息外，还包含了Spring的输出信息。

通过输出信息，可以获悉：创建了两个单实例的HelloWorld和FileHelloStr，即Spring默认时仅创建单实例的JavaBean，通过Spring配置文件中bean元素的singleton属性能够控制创建Java实例的方式。

至于本实例中的HelloWorldClient客户应用的具体解释，本书将在第3章给出。

1.2.5 pom文件： 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>com.openv.spring</groupId>
    <artifactId>example</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>2.5.6</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.3 Spring I/O实用类

开发者在example4中实用了ClassPathResource类装载applicationContext.xml文件。Spring在整个框架中提供了org.springframework.core.io包，供方便装载相关资源使用。当然，无论是XML，还是文件，还是URL，core.io包都提供了很好的支持。图1-1展示了其中的主要类。

其中，提供了Resource接口的不同实现。比如，基于URL的UrlResource、基于输入流的InputStreamResource、基于文件系统的FileSystemResource、基于应用classpath的ClassPathResource。从图1-1可以看出，开发者可以从不同位置、以不同方式装载Spring配置文件。这对于基于Spring或非Spring的应用的单元测试、集成测试而言，特别有意义。

Resource接口的具体内容见图1-2所示。

1.4 小结

本章通过4个实例，研究了Spring提供的IoC初步内容，Spring提供的功能远不止这些。至此，开发者应该对Spring有了初步认识，并且能够根据本章内容，开发一些简单的Java应用。

另外，本章还介绍了org.springframework.core.io包。它为装载Spring配置文件提供了最直接的支持。借助于core.io，开发者能够顺利地完成应用的单元测试和集成测试。

在深入Spring开发Java/J2EE应用之前，开发者应该掌握Spring的安装和构建。这正是第2章的研究内容。

作者 shenhuanjie

Spring Boot, 读书笔记 11月 21,2018

深入实践Spring Boot（三）

第3章 Spring Boot界面设计

用Spring Boot框架设计Web显示界面，我们还是使用MVC（Model View Controller，模型-视图-控制器）的概念，将数据管理、事件控制和界面显示进行分层处理，实现多层结构设计。界面设计，即视图的设计，主要是组织和处理显示的内容，界面上的事件响应最终交给了控制器进行处理，由控制器决定是否调用模型进行数据的存取操作，然后再将结果返回给合适的视图显示。

本章的实例工程使用分模块管理，如表3-1所示，即将数据管理独立成为一个工程模块，专门负责数据库方面的功能呢。而界面设计模块主要负责控制器和视图设计方面的功能。

项目	工程	功能
数据管理模块	data	实现使用Neo4j数据库
界面设计模块	webui	控制器和视图设计

作者 shenhuanjie

Spring Boot, 读书笔记 11月 20,2018

深入实践Spring Boot（二）

第2章在Spring Boot中使用数据库

使用数据库是开发基本应用的基础。借助于开发框架，我们已经不用编写原始的访问数据库的代码，也不用调用JDBC（Java Data Base Connectivity）或者连接池等诸如此类的被称作底层的代码，我们将在高级的层次上访问数据库。而Spring Boot更是突破了以前所有开发框架访问数据库的方法，在前所未有的更加高级的层次上访问数据库。因为Spring Boot包含一个功能强大的资源库，为使用Spring Boot的开发者提供了更加简便的接口进行访问。

提示： 可以将Maven的中央仓库修改为阿里云的仓库地址，加快jar包的加载速度。参考博文：Maven将中央仓库修改为阿里云的仓库地址

本章将介绍怎样使用传统的关系型数据库，以及近期一段时间异军突起的NoSQL（Not Only SQL）数据库。

本章的实例工程使用了分模块的方式构建，各模块的定义如表2-1所示。

项目	工程	功能
MySQL模块	mysql	使用MySQL
Redis模块	redis	使用Redis
MongoDB模块	mongodb	使用MongoDB
Neo4j模块	meo4j	使用Neo4j

提示：运行此实例需要从GitHub获取源码：https://github.com/shenhuanjie/spring-boot-db，并导入IDEA。

作者 shenhuanjie

Spring Boot, 读书笔记 11月 19,2018

深入实践Spring Boot（一）

第1章 Spring Boot入门

在使用Spring Boot框架进行各种开发体验之前，要先配置好开发环境。首先安装JDK，然后选择一个开发工具，如Eclipse IDE和IntelliJ IDEA（以下简称IDEA）都是不错的选择。对于开发工具的选择，本书极力推荐使用IDEA，因为它为Spring Boot提供了许多更好和更贴切的支持，本书的实例都是使用IDEA创建的。同时，还需要安装Apache Maven和Git客户端。所有这些都准备好之后，我们就能开始使用Spring Boot了。
阅读更多

作者 shenhuanjie

Spring Boot, 读书笔记 11月 19,2018

深入实践Spring Boot

第一部分基础应用开发

第1章 Spring Boot入门
第2章在Spring Boot中使用数据库
第3章 Spring Boot界面设计
第4章提高数据库访问性能
第5章 Spring Boot安全设计

这一部分从搭建开发环境，简单入门，到使用数据库、界面设计、安全管理等一系列内容，介绍了使用Spring Boot框架进行基础应用开发的方法。

第1章介绍了开发环境的搭建和开发工具的选择和安装，并以一个非常简单的实例，演示了如何使用Spring Boot框架创建工程和发布应用。
第2章介绍了如何用Spring Boot特有的方式，使用当前流行的数据库：MySQL、Redis、MongoDB、Neo4j等。
第3章介绍如何使用Thymeleaf模板结合一些流行的JavaScript插件，设计应用界面。
第4章使用Druid数据连接池和Redis做缓存来尝试提升关系型数据库的访问性能，并扩展了JPA的资源库功能。
第5章在Spring Boot中使用Spring Security为应用系统进行安全设计，实现了登录认证和权限管理方面的功能。

作者 shenhuanjie

日	一	二	三	四	五	六
« 8月
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30

Tag Spring