Spring Boot 教程:构建系统

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_build_systems.htm

    对于 Spring Boot,选择构建系统是一项重要任务。我们推荐使用 Maven 或 Gradle,因为它们对于依赖管理有良好的支持。Spring对于其他构建系统支持得不是很好。

依赖管理

    Spring Boot 团队在每次发布时都提供一支持 Spring Boot 版本的依赖列表。你不需要在构建配置文件中提供依赖的版本。Spring Boot 根据发布自动配置依赖版本。记住你更新 Spring Boot 版本时,会自动更新相关依赖。注意:如果你想指定依赖的版本,可以在配置文件中指定。然而,Spring Boot 团队强烈推荐没必要指定依赖版本。

Maven 依赖

    对于 Maven 配置,我们应当继承 Spring Boot 启动器父项目管理 Spring Boot 启动器依赖。我们的 pom.xml 如下所示:

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

    我们应用指定 Spring Boot 父启动器依赖的版本号。之后对于其他启动器依赖,我们就没必要再指定 Spring Boot 版本号了。示例如下:

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

Gradle 依赖

    我们可以在 build.gradle 文件中直接引入 Spring Boot 启动器依赖。没必要象Maven 一样指定Spring Boot 父启动器依赖,如下所示:

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

    同样,在 Gradle 中,我们也没必要指定所依赖的 Spring Boot 版本号。Spring Boot 自动配置依赖版本。

dependencies {
  compile('org.springframework.boot:spring-boot-starter-web')
}

Spring Boot 教程:Tomcat 部署

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_tomcat_deployment.htm

    使用 Spring Boot 应用,我们可以创建一个 war 文件部署到 web 服务器中。本文讲解如何创建 war 文件并将 Spring Boot 应用部署到 Tomcat web 服务器中。

Spring Boot Servlet 初始化器

    传统的部署方式是将 Spring Boot 应用中 @SpringBootApplication 注解的类扩展自 SpringBootServletInitializer 类。Spring Boot Servlet Initializer 类文件允许你在使用 Servlet 窗口启动时配置应用。    用于 JAR 文件部署的 Spring Boot 应用类文件示例如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

    我们需要扩展类 SpringBootServletInitializer 以支持 WAR 文件部署。对应的 Spring Boot 应用类文件如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

设置主类

    在 Spring Boot 中,我们需要在构件文件中指定主类。可使用下面的代码片段:

    对于 Maven,在 pom.xml 中增加启动类属性,如下所示:

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

    对于Gradle,在 build.gradle 中加入主类名,如下所示:

mainClassName="com.tutorialspoint.demo.DemoApplication"

更新 JAR 包到 WAR 中

    我们还要用下面的代码片段更新 JAR 包到 WAR 中:

    对于 Maven,pom.xml 中打包 WAR 的插件如下:

<packaging>war</packaging>

    对于 Gradle,在 build.gradle 中加上 应用和 war 插件,如下所示:

apply plugin: ‘war’
apply plugin: ‘application’

   现在,让我们编写一个简单的 Rest 端点,返回 “Hello World from Tomcat” 字符串。要编写 Rest Endpoint,我们要在构建文件中加上 Spring Boot web starter 依赖。

   对于 Maven,在 pom.xml 中加上 Spring Boot starter 依赖,如下所示:

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

   对于 Gradle,在 build.gradle 中加上 Spring Boot starter 依赖,如下所示:

dependencies {
  compile('org.springframework.boot:spring-boot-starter-web')
}

   现在,在 Spring Boot 应用类文件中编写 Rest 端点,示例代码如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

打包应用

   如下所示,使用Maven 或 Gradle 命令将应用打包成 WAR 文件以部署到 Tomcat 服务器:

   对于 Maven,用 mvn package 来打包应用。之后,会创建一个 WAR 文件,可以在 target 目录下找到它,如下图:

   对于 Gradle,用 gradle clean build 来打包应用。之后,会创建一个 WAR 文件,可以在 build/libs 目录下找到它,如下图:

部署到 Tomcat

   现在,运行 Tomcat 服务器,在 webapps 目录下部署 WAR 文件,如下图所示:

   部署成功之后,在web 浏览器中敲入 http://localhost:8080/demo-0.0.1-SNAPSHOT/,屏幕截图如下:

全部代码如下:

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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </properties>

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

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

    build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

    主 Spring Boot 应用类文件如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Spring Boot 教程:自启(Bootstrapping)

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_bootstrapping.htm

    本文讲解Spring Boot应用如何执行自启( bootstrapping)。

Spring 初始化器(Intializer)

    自启Spring Boot应用的一个方式是使用Spring 初始化器(Intializer)。使用Spring初始化器,要访问网页 www.start.spring.io 选择所要用到的 Spring Boot 版本和平台。还要提供运行应用的组(Group)、工件(Artifact ) 和所需的依赖等信息。    下面的截图展示了添加 spring-boot-starter-web 依赖,编写 REST 端点的界面:

    输入组、工件、依赖、构件项目、平台和版本之后,单击 Generate Project 按钮,相应的 zip 文件就会被下载下来并解压到本地目录。    下面讲解如何使用 Maven 和 Gradle。

Maven

    在你下载项目、解压文件之后,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.tutorialspoint</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Gradle

    下载项目、解压文件后,build.gradle 文件看起来是这个样子的:

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'


group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8


repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

类路径依赖

    Spring Boot提供了一系列 Starters 会加到你的类路径中。例如:写一个 Rest 端点,你要在类路径中加上 spring-boot-starter-web 依赖。代码如下:

Maven 依赖

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

Gradle 依赖

dependencies {
  compile('org.springframework.boot:spring-boot-starter-web')
}

主方法

    在 Spring Boot 应用类中应当加入主方法。这个类要加上 @SpringBootApplication 注解这是spring boot 应用启动的入口点。你可以在默认包的 src/java/main 目录下找到主类文件。    在这个例子中,主类文件位于 src/java/main 目录下,默认包名是 com.tutorialspoint.demo。代码如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplicationpublic class DemoApplication {
    public static void main(String[] args) {
       SpringApplication.run(DemoApplication.class, args);
    }
}

写一个 Rest 端点(Endpoint)

    要在Spring Boot 应用的主类自身的文件中写一个简单的 Hello World Rest 端点,要做下面几步:

  • 首先,在类上面加上 @RestController 注解。
  • 现在,通过 @RequestMapping 注解标明请求 URI 方法。
  • 接下来,请求 URI 方法应当返回 Hello World 字符串.

    现在,主 Spring Boot Application 类文件看起来是这个样子:

package com.tutorialspoint.demo;

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;

@SpringBootApplication
@RestController
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

创建可执行的 JAR

    让我们在命令窗口用Maven和Gradle命令创建一个可执行的 JAR 文件来运行 Spring Boot 应用,如下所示:    使用 Maven 命令 mvn clean install,如下所示:

    执行命令后,你会看到如下所示的 BUILD SUCCESS 的消息:

    使用 Gradle 命令 gradle clean build,如下所示:

    执行命令后,你会看到 BUILD SUCCESSFUL 的消息,如下所示:

以Java方式运行 Hello World

    你可以在下面的目录下找到所创建的 JAR 文件。    对于 Maven,你可以在 target 目录下找到 JAR 文件,如下所示:

    对于Gradle,你可以在 build/libs目录下找到 JAR 文件,如下所示:

    下面,输入 java –jar <JARFILE> 命令运行 JAR 文件。对于上面的示例,JAR 文件名是 demo-0.0.1-SNAPSHOT.jar

    运行 jar 文件,你会在控制台窗口看到相应的输出,如下所示:

    现在,看一下控制台,Tomcat 启动了,端口是 8080 (http)。现在打开 web 浏览器敲入 URL http://localhost:8080/ 会看到下面的输出:

Spring Boot 教程:快速开始

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_quick_start.htm

    本文将教你如何利用 Maven 和 Gradle创建Spring Boot 应用。

先决条件

    要创建 Spring Boot 应用,你的系统至少需要安装以下软件:

  • Java 7
  • Maven 3.2
  • Gradle 2.5

Spring Boot CLI

    Spring Boot CLI 是一个命令行工具,允许我们运行 Groovy 脚本。使用Spring Boot命令行工作接口是创建Spring Boot应用的便捷方式。你可以在命令窗口下进行创建、运行和测试。    本节解释了手工安装Spring Boot CLI的步骤。要获取进一步帮助,可参考如下链接:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot。你也可以从Spring软件仓库下载Spring CLI的部署包:https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

    手工安装的话,需要用到下面两个文件夹:

     下载后,解压文件并按照install.txt文件中的步骤进行操作。注意不需要任何环境设置。    在Windows系统,在命令窗口切换到Spring Boot CLI bin 目录并运行命令 spring –-version 以确保正确安装了 spring CLI。执行命令后,你可以看到如下所示的 spring CLI 版本信息:

使用Groovy运行Hello World

    创建一个简单的 groovy 文件,包含 Rest 端点脚本并使用运行spring boot CLI运行groovy 文件。代码如下:

@Controller
class Example {
   @RequestMapping("/")
   @ResponseBody
   public String hello() {
      "Hello Spring Boot"
   }
}

  现在保存groovy文件,命名为 hello.groovy。请注意在这个例子中,我们在Spring Boot CLI bin 目录保存了groovy文件。现在使用命令spring run hello.groovy 运行应用,如下图所示:

    一旦你运行groovy文件,所需的依赖会自动下载并以Tomcat 8080端口启动应用,如下图所示:

    一旦Tomca启动,打开 web 浏览器中键入 URL http://localhost:8080/ ,你会看到如下输出:

Spring Boot 教程: 简介

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_introduction.htm

      Spring Boot是一个基于Java的开源框架,可用于创建微服务。 它由Pivotal团队开发,用来构建可在生产环境独立运行的spring应用。 Spring Boot 包含了全面的支持微服务开发的基础设施,并且能够开发可“即时运行”的企业级应用。

受众

      本教程为Java开发者而设计,帮助他们理解如何以最小化配置开发可用于生产的spring应用。本教程揭示了 Spring Boot 的主要特性,譬如:启动者、自动配置、Bean和 Actuator等。通过本教程,你可以获得中等水平的 Spring Boot技能。

先决条件

    学习本教程需要事先有一定的Java、Spring、Maven和Gradle的经验。如果你有这些概念,就可以轻松理解Spring Boot的相关概念。要是你拥有RESTful Web 服务的编写经验,那会更有优势。如果你是一位初学者,建议你在开始学习Spring Boot之前要先对这些方面的知识有所了解。

Spring Boot — 简介

       本文将带你熟悉Spring Boot及其基本概念。

什么是微服务?

      微服务是一个体系结构,允许开发者独立开发和部署服务。每个服务都有其独立的运行进程,并且以轻量机制通信支持业务应用。

优势

     对于开发者而言,微服务有以下优势:

  • 易于部署
  • 便于扩展
  • 与容器兼容
  • 最小化配置
  • 缩短生产时间

什么是Spring Boot?

      Spring Boot为Java开发者提供了一个优秀的平台,可用于开发独立运行的生产级spring应用,并且能够即时运行(just run)。你毋须熟悉整个spring配置,只需以最小化的配置进行开发。

优势

      Spring Boot为开发者提供了以下优势:

  • 易于理解和开发spring应用
  • 提高生产效率
  • 减少开发时间

目标

     Spring Boot的设计目标如下:

  • 避免spring复杂的XML配置
  • 以便捷的方式开发生产级的Spring应用
  • 减少开发和独立运行的时间
  • 提供启动应用的便捷方式

为什么要用Spring Boot?

      之所以要选择Spring Boot,是因为它能够提供以下特性和利益:

  • 提供了灵活的方式来配置Java Beans、XML配置和数据库事务
  • 提供了强大的批处理、管理REST端点
  • 在Spring Boot中,一切皆为自动配置,毋须手工配置
  • 提供了基于注解的spring应用
  • 便捷的依赖管理
  • 引入了嵌入式Servlet容器

工作原理

      Spring Boot 使用@EnableAutoConfiguration注解可自动配置应用。      Spring boot 应用的入口点是包含@SpringBootApplication 的类和其main方法。      Spring Boot 使用@ComponentScan注解自动扫描项目中包含的所有组件。

Spring Boot启动器(Starters)

    对于大型项目而言,依赖管理是一项艰巨的任务。Spring Boot通过为开发者提供一系列便捷的依赖来解决这个难题。比如:要想使用Spring和JPA进行数据库访问,你只要在项目里引入 spring-boot-starter-data-jpa 就可以了。    要注意所有的Spring Boot启动器都有相同的命名范式spring-boot-starter- *,这里 * 指示它是某种的类型类型。

示例

    看看下面解释可以对 Spring Boot 启动器有更好的理解:

    Spring Boot Starter Actuator dependency 用于监控和管理你的应用。代码如下:

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

  Spring Boot Starter Security dependency 用于 Spring 安全。代码如下:

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

  Spring Boot Starter web dependency 用于编写Rest 端点。代码如下:

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

  Spring Boot Starter Thyme Leaf dependency 用于创建 web 应用。代码如下:

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

  Spring Boot Starter Test dependency 用于编写测试案例。代码如下:

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

自动配置

      Spring Boot自动配置通过在项目中添加JAR依赖来自动化配置Spring应用。例如:如果你的classpath里包含 MySQL 数据库,即使没有配置任何数据库连接Spring Boot也会自动配置一个内存数据库。

     出于这个目的,要在主类文件加上 @EnableAutoConfiguration 注解或者 @SpringBootApplication 注解。那么,你的 Spring Boot 应用将会被自动配置。

      看下面的代码会更好理解:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

@EnableAutoConfiguration
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Spring Boot 应用

    Spring Boot 应用的入口点是包含 @SpringBootApplication 的类。这个类应当有运行Spring Boot应用的主方法。@SpringBootApplication 注解包括自动配置、组件扫描和 Spring Boot 配置。

    如果类加上@SpringBootApplication 注解,就不需要再加 @EnableAutoConfiguration、@ComponentScan 和 @SpringBootConfiguration 注解。@SpringBootApplication 注解包括所有其他注解。

    看下面的代码会更好理解:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

组件扫描

    当应用初始化时,Spring Boot 扫描所有声明的bean和包。你要在类文件加上 @ComponentScan 注解来扫描项目中的组件。

    看下面的代码会更好理解:

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

话说软件开发中的规范性

      这个话题要从最近工作中接触到的一些问题说起:大概情况是这样的,公司年前收购了一家公司(以下简称Y公司),虽然行业领域相同,但从业务模式到技术框架都是截然不同的。我们原有采用的是C#、.Net架构,Y公司全栈采用Java,Dubbo微服务架构,本人刚好在公司主导了几个Java项目实践,被分配到接手Y公司的部分项目。几个月下来,感触颇多,简记如下:

  1. 项目模块缺乏整体规划,同一功能出现在项目的多个模块中,重复代码比比皆是;
  2. 与第三方平台接口不规范,比如与X团的API接口中需要获取Token及加密,这样的接口本可以在一个地方统一实现,但却散落在各个地方,且用法不一;最奇葩的是明明对方的结果有返回代码(returnCode)和响应消息(message),却偏偏要自己定义一个枚举类来解释返回代码,最要命的是这个枚举是不完整的,结果就是有些代码找不到就抛出了一个异常”找不到对应的代码“云云,在调试过程中一头雾水……为什么不直接用第三方平台定义的错误代码和消息呢?
  3. 对于底层协议调用没有统一封装,最典型的比如HTTP协议,几乎所有的十几个项目中都有HttpUtil,从Header到PUT/GET/POST都要层层处理,不知道有OkHttp,更有上层封装Retrofit可以直接用吗?还有Json处理,甚至String处理都要写一堆,还各个项目各自为政,结果是出现了一堆无用的代码,臃肿还不能保证效率和正确性。

    上面的问题都可以归结为代码的规范性,如果大家是一个团队,就应该互通有无,有所分工,不要重复造轮子,首先要利用已经有的开源框架,其次要有统一的底层框架;这样既能提高整体效率,也保障了代码的稳定性和可维护性。试想,如果一个地方出了问题,比如第三方接口做了变化,那么上述的编码方式岂不是要改几十个地方?       其实规范性的重要性不言而喻,大家都懂,特别是对于团队开发而言,更是如此。那为什么实际执行下来就这么难呢?其实是一个团队领导力的问题,当今互联网行业,许多是赚快钱,只求快速上线,不出bug就行,至于怎么实现的,什么规范性、复用性,不值一提。但是仔细想想,日积月累,这些东西就变成了“负”能量,时刻在影响着你的产品质量,当然也包括成本。到最后,大家都改不动了,习惯了差,没有了改的动力,到这时候就是整个团队的悲哀了。说到底是一种文化和精神,如果一个公司只求眼前利益,没有对细节和质量的追求,那么永远也成为不了一家伟大的公司,为之工作的员工也只能浑浑噩噩,打更混日子了!

我的前半生(技术人生)

(一)缘起

冬季的北京,有些晴冷、干燥,位于望京的这个科技园有些荒凉,倒是旁边的街道上停得满满当当的车显得不甚协调。好在只在这里呆两天,现在已经坐在回上海的高铁上,窗外飞速飘过一排排光秃的树梢,黄土地上还有一些亮晶晶晶的积雪,心情有些放松。旅途的意义就在于让你能在周而复始的平日生活中得到一丝喘息,换一种方式放空心情。

        回想一天前还彻夜未眠地赶一个上线的项目,直到早上8点多,上车后两个小时、上班前一刻才搞定。这一切只是想在出差的两天能够让上海的两个小伙伴能够继续工作。没人催促,只是凭着一腔热情、卑微的自尊心和责任感自我驱动。这样的情况最近两年,每半年就会出现两三次,就是遇到一个技术问题,就会不眠不休,直到攻克为止。妻在一旁直心疼,总是提醒我注意身体,我也隐约中觉得不妥,可事情总是这样重复发生。有时候会忍不住想是不是年纪大了,珍惜时间?心中总不免泛出一丝的酸楚和无奈,另一方面,却还是有些成就感的。

        写博客的想法一直有,总觉得就这么每天干些和年轻人一样的事,写写代码,攻克一个又一个自己觉得了不起、别人也许不屑一顾的难题,有点蹉跎人生的感觉。加上这段时间同事、上级也鼓励我搞搞副业、做做分享,人生多一种可能,也给自己留点后路,传道授业总是越老越值钱的,这是一个可以做到老的事业。马云退休后不也当了“乡村教师”嘛,于人是一种帮助,于己也是一种慰藉,何乐不为?加上如今无处不在的媒体渠道,各种网红层出不穷,这些东西已经不泛传播渠道了。要写的内容也很多,但主要围绕技术主题,夹杂着一些人生体会,自勉也希望能给他人以启发。

(二)现状

        本人现在年近半百,明年就是本命年,两鬓已然斑白;目前就职一家民企信息技术部,抬头还是资深开发工程师,手下两名刚入行两三年的小伙伴,收入在上海勉强能够在中等水平;名下入门级小车一辆,50多平的蜗居一套附带百万房贷,膝下有一子即将高考;另有小女尚在咿呀学语,甚是喜人,余生唯此而有奋斗之动力。

        此等境况可谓不堪,但比起不写代码、管理不上路、尽是茫然空虚的那些年,重拾技术让我又觉得脚踏实地,找到了失落的自信。

———回到了湿漉漉的上海,闻到了熟悉的味道,暂且分割,回头再续———

(三)新起点

       相隔大半年,终于想起还有这一未完篇。期间见识了旷世未见、影响世界的疫情大战,以及随之而来的中美各种混战,仿佛变了天。所幸还有赖以生存的工作和温馨舒适的家,每日有妻女相伴,小儿也度过高考之役,不算太坏。外面的世界风云变幻,愈发显得小环境的安宁祥和,有生如斯,夫复何求?

       昨日看一个技术视频讲程序员如何做副业,说到公众号、培训等等无不是技术分享,和前期所想的技术博客并无二致,是原创还是转载、主题怎么确定?这些都是问题,但关键是要开始探索,终究会找到适合自己的方向的。

       早上上班途中想起了博客的笔名或者名号,就叫“信码由缰”吧,借用这个成语暗含码农人生、自由不羁之意,内容上也是关于软件行业的各种随想。第一篇是关于最近在工作中看别人的代码引发的规范性、封装性和框架(第三方)方面的感想,以此为起点,开启技术博主的人生旅程吧。