《C语言程序设计：现代方法（第2版）》 8月 27,2019

第1章 C语言概述

如果有人说“我想要一种语言，只需对它说我要干什么就行”，给他一支棒棒糖好了。“

什么是C语言？它是20世纪70年代初期在贝尔实验室开发出来的一种广为使用的编程语言。这一简单回答显然没能传达出C语言的特别之处。不过别急，在深入学习这门语言之前，让我们先来回顾一下C语言的起源、设计目标和这么多年来的发展（1.1节）。我们还将讨论C语言的优缺点，以及如何高效地使用C语言（1.2节）。
阅读更多

作者 shenhuanjie

Spring 6月 5,2019

第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

POI 5月 21,2019

Java web中使用POI实现excel文件的导入和导出

文件导出

package com.shenhuanjie.apache.poi.excel.demo;

import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import java.io.IOException;

public class exportXls {
    //导入excle表
    public String exportXls() throws IOException {
        //1.查询所有需要的数据
        List<Subarea> list = subareaService.findAll();
        //2.使用POI将数据写进excel表中
        //2.1在内存中创建一个excel文件
        HSSFWorkbook workbook = new HSSFWorkbook();
        //2.2创建一个标签页
        HSSFSheet sheet = workbook.createSheet("分区数据");
        //2.3创建标题行
        HSSFRow headRow = sheet.createRow(0);
        headRow.createCell(0).setCellValue("分区编号");
        headRow.createCell(1).setCellValue("开始编号");
        headRow.createCell(2).setCellValue("结束编号");
        headRow.createCell(3).setCellValue("位置信息");
        headRow.createCell(4).setCellValue("省市区");
        //2.4将需要的数据放入excel表中
        for (Subarea subarea : list) {
            HSSFRow dataRow = sheet.createRow(sheet.getLastRowNum()+1);
            headRow.createCell(0).setCellValue(subarea.getId());
            headRow.createCell(1).setCellValue(subarea.getStartnum());
            headRow.createCell(2).setCellValue(subarea.getEndnum());
            headRow.createCell(3).setCellValue(subarea.getPosition());
            headRow.createCell(4).setCellValue(subarea.getRegion().getName());
        }

        //3.输出流进行文件下载
        String filename = "分区信息表.xls";
        String mimeType = ServletActionContext.getServletContext().getMimeType(filename);
        ServletOutputStream outs = ServletActionContext.getResponse().getOutputStream();


        //获取客户端的浏览器类型
        String agent = ServletActionContext.getRequest().getHeader("User-Agent");
        filename =  FileUtils.encodeDownloadFilename(filename, agent);
        ServletActionContext.getResponse().setHeader("content-disposition",
                "attachment;filename"+filename);

        workbook.write(outs);
        return NONE;
    }
}

作者 shenhuanjie

Spring Boot 5月 21,2019

《深入实践SpringBoot》（一）

第1章 Spring Boot入门

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

1.1 配置开发环境

下面的开发环境配置主要以使用Windows操作系统为例，如果你使用的是其他操作系统，请对照其相关配置进行操作。

1.1.1 安装JDK

JDK（Java SE Development Kit）需要1.8及以上版本，可以从Java的官网https://www.oracle.com/techetwork/java/javase/downloads/下载安装包。如果访问官网速度慢的话，也可以通过百度搜索JDK，然后在百度软件中心下载符合你的Windows版本和配置的JDK1.8安装包。

安装完成后，配置环境变量JAVA_HOME，例如，使用路径D:\Program Files\Java\jdk1.8.0_25（如果你安装的是这个目录的话）。JAVA_HOME配置好之后，将%JAVA_HOMT%\bin加入系统的环境变量path中。完成后，打开一个命令行窗口，输入命令java-version，如果能正确输出版本号则说明安装成功了。输出版本的信息如下：

java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) Client VM (build 25.201-b09, mixed mode)

1.1.2 安装InterlliJ IDEA

IDEA需要14.0以上的版本，可以从其官网http://www.jetbrains.com/下载免费版，本书的实例是使用IDEA14.1.15版本开发的。IDEA已经包含Maven插件，版本是3.0.5，这已经能够适用我们开发的要求。安装完成后，打开IDEA，将显示如图1-1所示的欢迎界面，在这里可以看到IDEA的版本号。

1.1.3 安装Apache Maven

为了能够在命令行窗口中使用Maven来管理工程，可以安装一个Maven管理工具。通过Maven的官网http://maven.apache.org/download.cgi下载3.0.5以上的版本，下载完后解压缩即可，例如，解压到D：盘上是不错的做法，然后将Maven的安装路径（如D:\apache-maven-3.2.3\bin）也加入Windows的环境变量path中。安装完成后，在命令行窗口中执行指令：mvn-v，将输出如下的版本信息以及系统的一些环境信息。

C:\Users\shenh>mvn -v
Apache Maven 3.5.3 (3383c37e1f9e9b3bc3df5050c29c8aff9f295297; 2018-02-25T03:49:05+08:00)
Maven home: C:\Program Files\Maven\bin\..
Java version: 1.8.0_161, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.8.0_161\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

建议更改IDEA中Maven资源库的存放路径，可以先在Maven安装路径中创建一个资源库目录，如repository。然后打开Maven的配置文件，即安装目录conf中的settings.xml，找到下列代码，将路径更改为repository所在的位置，并保存在注释符下面。

例如找到下列代码行：

复制出来改为如下所示：

改好后可以拷贝一份setings.xml放置在${user.home}/.m2/下面，这样做可以不用修改IDEA的Maven这个配置。在图1-2所示的Maven配置界面中，User Settings File保存了默认位置，Local Repository使用了上面设置的路径D:\apache-maven-3.2.3\repository，而Maven程序还是使用了IDEA自带的版本。

1.1.4 安装Git客户端

由于本书的实例工程都存在GitHub（https://github.com/）中，所以还需要在GitHub中免费注册一个用户（可以通过E-mail直接注册免费用户，以方便在IDEA中从GitHub检出本书的实例工程。当然，如果不想注册，通过普通下载的方法也能取得实例工程的源代码。GitHub是世界级的代码库服务器，如果你愿意，也可以将它作为你的代码服务器。在这里还可以搜索到全世界的开发者分享出来的源程序。图1-3是打开GitHub的首页。

IDEA还需要Git客户端程序的支持。可以从其官网https://git-scm.com/download/下载Git客户端安装包。安装非常简单，按提示单击”下一步“并选择好安装路径即可。安装完成后，在Windows的资源管理器中，单击鼠标右键弹出的菜单中将会多出如下几个选择菜单：

Git Init Here
Git Gui
Git Bash

其中Git Bash是一个带有UNIX指令的命令行窗口，在这里可以执行一些Git指令，用来提交或者检出项目。

在IDEA中对Git的设置，只要指定git.exe执行文件的位置即可。图1-4是IDEA中Git客户端的配置，其中Git的路径被配置在D:\Program Files\Git\bin\git.exe中，这主要由安装Git客户端的位置而定。

如果已经在GitHub中注册了用户，即可以打开如图1-5所示的GitHub配置，输入用户名和密码，然后单击Test按钮，如果设置正确的话将会返回连接成功的提示。

提示： 上面IDEA的一些设置界面都可以单击工具栏上的Settings按钮打开，打开File菜单，选择Settings同样也可以打开。

1.2 创建项目工程

现在，可以尝试使用IDEA来创建一个项目工程。如果是第一次打开IDEA，可以选择Create New Project创建一个新工程。如果已经打开了IDEA，在File菜单中选择New Project，也能打开New Project对话框，如图1-6所示。使用IDEA创建一个Spring Boot项目有很多方法，这里只介绍使用Maven和Spring Initializr这两种方法来创建一个新项目。一般使用Maven来新建一个项目，因为这样更容易按我们的要求配置一个项目。

1.2.1 使用Maven新建项目

使用Maven新建一个项目主要有以下三个步骤。

1、选择项目类型

在图1-6中的ProjectSDK下拉列表框中选择当前安装的Java 1.8，如果下拉列表框中不存在Java 1.8，可以单击New按钮，找到安装Java的位置，选择它。然后在左面侧边栏的项目类型中，选择Maven项目，即可使用Maven作为项目的管理工具。至于Maven中的archetype，因为我们并不打算使用其中任何一种类型，所以不用勾选，然后单击Next进入下一步。

2、输入GroupId和ArtifactId

在GroupId输入框中输入“spring.example”，在ArtifactId输入框中输入”spring-boot-hello”，Version输入框中保持默认值，如图1-7所示，单击Next进入下一步。

3、指定项目名称和存放路径

在Project location编辑框中选择和更改存放路径，在Project name输入框中输入与ArtifactId相同项目名称：“spring-boot-hello”，如图1-8所示。

单击Finish，完成项目创建，这样将在当前窗口中打开一个新项目，如图1-9所示。其中，在工程根目录中生成了一个pom.xml，即Maven的项目对象模型（Project Object Model），并生成了源代码目录java、资源目录resources和测试目录test等，即生成了一个项目的一些初始配置和目录结构。

下一节将使用这个项目工程来创建第一个使用Spring Boot开发框架的应用实例。

1.2.2 使用Spring Initializr新建项目

1.3.2 一个简单的实例

Spring Boot的官方文档中提供了一个最简单的Web实例程序，这个实例只使用了几行代码，如代码清单1-3所示。虽然简单，但实际上这已经可以算作是一个完整的Web项目了。


package spring.boot.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


/**
 * Application
 */
@SpringBootApplication
@RestController
public class Application {

    /**
     * home
     *
     * @return
     */
    @RequestMapping("/")
    String home() {
        return "hello";
    }

    /**
     * main
     *
     * @param args
     */
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

这个简单实例，首先是一个Spring Boot应用的程序入口，或者叫作主程序，其中使用了一个注解@SpringBootApplication来标注它是一个Spring Boot应用，main方法使它成为一个主程序，将在应用启动时首先被执行。其次，注解@RestController同时标注这个程序还是一个控制器，如果在浏览器中访问应用的根目录，它将调用home方法，并输出字符串：hello。

1.4.2 将应用打包发布

上面操作演示了在IDEA环境中如何运行一个应用。如果我们想把应用发布出去，需要怎么做呢？可以将代码清单1-1中的Maven配置增加一个发布插件来实现。如代码清单1-4所示，增加了一个打包插件：spring-boot-maven-plugin，并增加了一行打包的配置：<packageing>jar</packagin>，这行配置指定将应用工程打包成jar文件。

<?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>spring.boot.example</groupId>
    <artifactId>spring-boot-hello</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.2.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

这样就可以在IDEA中增加一个打包的配置，打开Run/Debug Configurations对话框，选择增加配置一个Maven打包项目，在工作目录中选择工程所在根目录，在命令行中输入package，并将配置保存为mvn，如图1-17所示。

运行mvn打包项目，就可以将实例工程打包，打包的文件将输出在工程target目录中。

如果已经按照1.1.3节的说明安装了Maven，也可以直接使用Maven的命令打包。打开一个命令行窗口，将路径切换到工程根目录中，直接在命令行输入mvn package，同样也能将项目打包成jar文件。执行结果如下：

[INFO] Scanning for projects...
[INFO] 
[INFO] ---------------< spring.boot.example:spring-boot-hello >----------------
[INFO] Building spring-boot-hello 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ spring-boot-hello ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 0 resource
[INFO] Copying 0 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ spring-boot-hello ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to ..\spring-boot-hello\target\classes
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ spring-boot-hello ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory ..\spring-boot-hello\src\test\resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ spring-boot-hello ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-surefire-plugin:2.18.1:test (default-test) @ spring-boot-hello ---
[INFO] No tests to run.
[INFO] 
[INFO] --- maven-jar-plugin:2.5:jar (default-jar) @ spring-boot-hello ---
[INFO] Building jar: ..\spring-boot-hello\target\spring-boot-hello-1.0-SNAPSHOT.jar
[INFO] 
[INFO] --- spring-boot-maven-plugin:1.3.2.RELEASE:repackage (default) @ spring-boot-hello ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.658 s
[INFO] Finished at: 2019-05-06T16:26:05+08:00
[INFO] ------------------------------------------------------------------------

打包成功后，在工程的target目录中将会生成jar文件spring-boot-hello-1.0-SNAPSHOT.jar。在命令行窗口中切换到target目录中，运行如下指令，就能启动应用。

java -jar spring-boot-hello-1.0-SNAPSHOT.jar

1.5 关于Spring Boot配置

关于Spring Boot配置，可以在工程的resources文件夹中创建一个application.properties或application.yml文件，这个文件会被发布在classpath中，并且被Spring Boot自动读取。这里推荐使用application.yml文件，因为它提供了结构化及其嵌套的格式，例如，可以按如下所示配置上面的工程，将默认端口改为80，并且将Tomcat的字符集定义为UTF-8。

server:
  port: 80
  tomcat:
    uri-encoding: UTF-8

1.6 小结

本节主要介绍了Spring Boot开发环境的搭建，以及一些开发工具的安装配置，内容难免有点枯燥。然后创建并运行一个非常简单的实例工程，让性急的读者一睹Spring Boot的芳容。

本章实例工程只是使用Spring Boot进行开发的非常简单的入门指引。因为Spring Boot开发框架是一个非常轻量级的开发框架，所以也有人把它叫作微框架，从入门指引中可以看出，使用Spring Boot框架开发应用不但入门容易，而且其蕴藏的无比强大的功能，使开发过程也变得更加容易。

下面，让我们使用Spring Boot框架进行一些更加有趣的开发吧。这一章只是小试牛刀而已，在后续章节中将使用Spring Boot框架来开始一些真正的开发。

作者 shenhuanjie

2020年一月
日	一	二	三	四	五	六
« 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	31

世界，您好！