.NET CORE與Spring Boot編寫控制台程序應有的優雅姿勢

本文分別說明.NET CORE與Spring Boot 編寫控制台程序應有的“正確”方法，以便.NET程序員、JAVA程序員可以相互學習與加深了解，注意本文只介紹用法，不會刻意強調哪種語言或哪種框架寫的控制台程序要好。

本文所說的編寫控制台程序應有的“正確”方法，我把正確二字加上引號，因為沒有絕對的正確，因人而異，因系統設計需求而異，我這里所謂的正確方法是指使用面向對象，依賴注入IOC，切面控制AOP等編碼規范來提升程序的性能、整潔度、可讀性、可維護性等，最終達到讓人感覺有點高大上，有點優雅的樣子。

先來說說.NET CORE編寫控制台程序，目前網絡上大把的講解ASP.NET CORE的編寫規范，反而對於.NET CORE控制台程序編寫規范介紹比較少，大多停留在Hello Word 程序中，而本文則來講講.NET CORE控制台的編寫規范（應有的優雅姿勢）^ v ^

 如果說不講什么IOC,DI，AOP等，不講擴展性，規范性，全部面向過程（方法）編程，那估計沒什么好講的，因為無非就是定義一個class，然后在class中定義一堆的method（方法），如果在方法中需要使用到其它第三方組件，則直接單獨引用，引用后進行簡單封裝util工具類的靜態方法，甚至也不用封裝，直接使用原生的方法，總之全部都是方法調方法。而這里所演示的編寫控制台方法均是盡可能的使用.NET CORE所具有的特性，只有這樣才能體現出.NET CORE框架的優勢，否則普通控制台程序與.NET CORE控制台程序有什么區別。

編寫.NET CORE控制台程序優雅姿勢一：（直接使用.NET CORE的 IOC、Logging、Config組件）

代碼如下：

//Program.cs

using Microsoft.Extensions.DependencyInjection;
using System;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Configuration.Json;
using Microsoft.Extensions.Configuration;
using System.IO;

namespace NetCoreConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            //設置config文件
            var config = new ConfigurationBuilder()
                                .SetBasePath(Directory.GetCurrentDirectory())
                                .AddJsonFile("appSettings.json", optional: true, reloadOnChange: true).Build();

            //設置依賴注入
            var provider = new ServiceCollection()
                                    .AddLogging(configLogging => //設置日志組件
                                    {
                                        configLogging.SetMinimumLevel(LogLevel.Information);
                                        configLogging.AddConsole();
                                    })
                                   .AddScoped<IConfiguration>(p => config)
                                   .AddScoped<HostService>()
                                   .BuildServiceProvider();

            var hostService = provider.GetService<HostService>();

            hostService.RunAsync();//統一入口服務

            Console.WriteLine("提示：程序已正常啟動運行，按任意鍵停止運行並關閉程序...");
            Console.ReadLine();

        }
    }
}


//HostService.cs

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace NetCoreConsoleApp
{
    public class HostService
    {
        private readonly IConfiguration config;
        private readonly ILogger<HostService> logger;
        public HostService(IConfiguration config, ILogger<HostService> logger)
        {
            this.config = config;
            this.logger = logger;
        }

        public void RunAsync()
        {
            Task.Run((Action)Execute);
        }

        /// <summary>
        /// 控制台核心執行入口方法
        /// </summary>
        private void Execute()
        {
            //TODO 業務邏輯代碼，如下模擬
            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 1; i <= 100; i++)
            {
                Console.WriteLine("test WriteLine:" + i);
                Thread.Sleep(100);
            }

            stopwatch.Stop();

            logger.LogInformation("Logging - Execute Elapsed Times:{}ms", stopwatch.ElapsedMilliseconds);
        }

    }
}

因為要使用.NET CORE相關核心組件，故需要引用相關的NuGet包（引用包的方式有多種方式），而且默認的.NET CORE控制台只會生成DLL並不會生成EXE啟動程序，故如果僅在WIN系統下使用，還需要設置生成方式等，詳細配置屬性如下：（項目文件csproj）

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.2</TargetFramework>
    <RuntimeIdentifiers>win10-x64</RuntimeIdentifiers>
    <SelfContained>false</SelfContained>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.2.0" />
    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.2.0" />
  </ItemGroup>

</Project>

 如上代碼雖簡單但代碼編寫順序很關鍵，這里進行說明一下：

1.因為一般應用程序都會有config文件，故我們需要先通過new ConfigurationBuilder來設置config文件的方式及路徑；

2.因為要使用.NET CORE默認的IOC框架，故new ServiceCollection，然后將相關的依賴服務組件注冊到IOC容器中；

3.config、logging 均是一個程序最基本的依賴組件，故將其注冊到IOC容器中，注冊logging有專門的擴展方法（AddLogging），而config沒有則直接使用通過的注冊方法（當然也可以基於ServiceCollection寫一個AddConfiguration擴展方法）

4.控制台需要一個核心的入口方法，用於處理核心業務，不要直接在Program中寫方法，這樣就不能使用IOC，同時也沒有做到職責分明，Program僅是程序啟動入口，業務處理應該有專門的入口，故上述代碼中有HostService類（即：核心宿主服務類， 意為存在於控制台中的服務處理類，在這個類的構造涵數中列出所需依賴的服務組件，以便實例化時IOC可以自動注入這個參數），並注冊到IOC容器中，當然也可以先定義一個IHostService接口然后實現這個接口。（如果有多個HostService類實例，建議定義一個IHostService接口，接口中只需要入口方法定義即可，如：RunAsync）

5.當各組件初始化設置OK、IOC注冊到位后，就應該通過IOC解析獲得HostService類實例，並執行入口方法：RunAsync，該方法為異步后台執行，即調用該方法后，會在單獨的后台線程處理核心業務，然后主線程繼續往下面走，輸出關閉提示信息，最后的Console.ReadLine();很關鍵，這個是等待輸入流並掛起當前主線程，目的大家都知道，不要讓控制台程序關閉。

 通過上述的講解及源代碼展示，有沒有感覺優雅呢？如果覺得這樣還算優雅，那下面展示的第二種更優雅的姿勢

編寫.NET CORE控制台程序優雅姿勢二：（使用通用主機也稱泛型主機HostBuilder）

代碼如下：Program.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using NLog.Extensions.Logging;
using Microsoft.Extensions.Configuration;
using System.IO;
using Polly;
using System;

namespace NetCoreConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            var host = new HostBuilder()
                .ConfigureHostConfiguration(configHost =>
                {
                    configHost.SetBasePath(Directory.GetCurrentDirectory());
                })
                .ConfigureAppConfiguration(configApp =>
                {
                    configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
                })
                .ConfigureServices((context, services) =>
                {
                    //添加數據訪問組件示例：services.AddTransient<IDbAccesser>(provider =>
                    //{
                    //    string connStr = context.Configuration.GetConnectionString("ConnDbStr");
                    //    return new SqlDapperEasyUtil(connStr);
                    //});

                    //添加HttpClient封裝類示例：services.AddHttpClient<GitHubApiClient>()
                    //.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(3, t => TimeSpan.FromMilliseconds(800)));

                    services.AddHostedService<DemoHostedService>();
                })
                .ConfigureLogging((context, configLogging) =>
                {
                    configLogging.ClearProviders();
                    configLogging.SetMinimumLevel(LogLevel.Trace);
                    configLogging.AddNLog(context.Configuration);
                })
                .UseConsoleLifetime()
                .Build();

            host.Run();
        }
    }
}

DemoHostedService類代碼：

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace NetCoreConsoleApp
{
    public class DemoHostedService : IHostedService
    {
        private readonly IConfiguration config;
        private readonly ILogger logger;

        public DemoHostedService(IConfiguration config, ILogger<DemoHostedService> logger)
        {
            this.config = config;
            this.logger = logger;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine(nameof(DemoHostedService) + "已開始執行...");

            //TODO 業務邏輯代碼，如下模擬
            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 1; i <= 100; i++)
            {
                Console.WriteLine("test WriteLine:" + i);
                Thread.Sleep(100);
            }

            stopwatch.Stop();

            logger.LogInformation("Logging - Execute Elapsed Times:{}ms", stopwatch.ElapsedMilliseconds);

            return Task.FromResult(0);
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine(nameof(DemoHostedService) + "已被停止");
            return Task.FromResult(0);
        }

    }
}

　

因為要使用HostBuilder類及相關的.NET CORE組件（如上代碼主要使用到了：Host、Dapper、Nlog、Polly等），故仍需引用相關的NuGet包，詳細配置屬性如下：（項目文件csproj）

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.2</TargetFramework>
    <RuntimeIdentifiers>win10-x64</RuntimeIdentifiers>
    <SelfContained>false</SelfContained>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Dapper" Version="1.60.6" />
    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.2.0" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0" />
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="2.2.0" />
    <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="2.2.0" />
    <PackageReference Include="NLog.Extensions.Logging" Version="1.5.1" />
    <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
  </ItemGroup>

  <ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="nlog.config">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

</Project>

 如上代碼所示，寫過ASP.NET CORE程序的人可能比較眼熟，這與ASP.NET CORE的寫法很類似，是的，你沒有看錯，HostBuilder是通用主機，是可以廣泛應用於非HTTP的環境下，而ASP.NET CORE中的WebHostBuilder 主要用於HTTP WEB環境，使用方式基本類似，都是先定義HostBuilder，然后利用擴展方法注冊、配置各種組件（中間件），最后調用Host的Run方法，開啟后台服務執行，不同的是WebHostBuilder多了屬於HTTP專有的一些屬性及方法及其適用的中間件。

由於這種寫法比較通用，適用於已熟悉.NET CORE或ASP.NET CORE的人群，上手也較簡單，故建議采取這種方式來寫.NET CORE控制台程序。需要注意的是HostBuilder中最重要的是：注冊HostedService 服務，如上代碼中的DemoHostedService即是實現了IHostedService接口的宿主后台服務類，可以定義多個，然后都注冊到IOC中，最后Host會按注冊先后順序執行多個HostedService服務的StartAsync方法，當停止時同樣會執行多個HostedService服務的StopAsync方法

下面再來看看使用Spring&Spring Boot框架來優雅的編寫控制台程序 

編寫Spring控制台程序優雅姿勢一：（只引用所必需的spring jar包、logger jar包，追求極簡風）

使用IDEA +MAVEN 創建一個quickstart 控制台項目，在maven POM XML中先引用所必需的spring jar包、logger 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>

    <artifactId>spring-console</artifactId>

    <name>spring-console</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.zuowenjun.cn</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.1.8.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
                <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
                <plugin>
                    <artifactId>maven-site-plugin</artifactId>
                    <version>3.7.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-project-info-reports-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

然后采取自定義注解類(SpringBeansConfig)的方式注冊相關Bean（包含配置映射類Bean：AppProperties），代碼如下：

//app.java

package cn.zuowenjun.spring;

import cn.zuowenjun.spring.cn.zuowenjun.spring.services.HostService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.io.IOException;

/**
 * Hello world!
 */
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringBeansConfig.class);
        HostService hostService = applicationContext.getBean(HostService.class);

        hostService.run();

        applicationContext.registerShutdownHook();

        try {
            System.in.read();
        } catch (IOException e) {
            System.out.println("等待讀取輸入數據報錯：" + e.getMessage() + "，將直接退出程序！");
        }
    }
}


//AppProperties.java

package cn.zuowenjun.spring;

import org.springframework.beans.factory.annotation.Value;


public class AppProperties {

    @Value("${app.name}")
    private String appName;

    @Value("${app.author}")
    private String appAuthor;

    @Value("${app.test.msg}")
    private String testMsg;

    public String getAppName() {
        return appName;
    }

    public void setAppName(String appName) {
        this.appName = appName;
    }

    public String getAppAuthor() {
        return appAuthor;
    }

    public void setAppAuthor(String appAuthor) {
        this.appAuthor = appAuthor;
    }

    public String getTestMsg() {
        return testMsg;
    }

    public void setTestMsg(String testMsg) {
        this.testMsg = testMsg;
    }
}


//SpringBeansConfig.java

package cn.zuowenjun.spring;

import cn.zuowenjun.spring.cn.zuowenjun.spring.services.HostService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;
import org.springframework.core.annotation.Order;

@Configuration
@PropertySource(value = "classpath:app.properties", ignoreResourceNotFound = false)
public class SpringBeansConfig {

    @Bean
    @Order(1)
    public HostService hostService() {
        return new HostService();
    }

    @Bean
    @Order(0)
    @Scope("singleton")
    public AppProperties appProperties() {
        return new AppProperties();
    }

    //注冊其它所需Bean...
}


//HostService.java

package cn.zuowenjun.spring.cn.zuowenjun.spring.services;

import cn.zuowenjun.spring.AppProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StopWatch;

import java.util.Collections;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class HostService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HostService.class);

    @Autowired
    private AppProperties appProperties;

    //可以添加其它屬性注入

    public void run() {
//        ExecutorService pool = Executors.newSingleThreadExecutor();
//        pool.execute(() -> execute());

        new Thread(this::execute).start();
    }

    /// <summary>
    /// 控制台核心執行入口方法
    /// </summary>
    private void execute() {
        //TODO 業務邏輯代碼，如下模擬
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        for (int i = 1; i <= 100; i++) {
            System.out.println("test WriteLine:" + i);
            try {
                Thread.sleep(100);
            } catch (Exception e) {
            }
        }
        stopwatch.stop();

        System.out.println(String.join("", Collections.nCopies(30, "=")));

        System.out.printf("app name is:%s %n", appProperties.getAppName());
        System.out.printf("app author is:%s %n", appProperties.getAppAuthor());
        System.out.printf("app test msg:%s %n", appProperties.getTestMsg());

        LOGGER.info("Logging - Execute Elapsed Times:{}ms", stopwatch.getTotalTimeMillis());
    }
}

　app.properties配置文件內容如下，注意應放在classpth目錄下（即：resources目錄下，沒有需自行創建並設為resources目錄）：

app.name=demo spring console
app.author=zuowenjun
app.test.msg=hello java spring console app!

　如上即上實現一個spring的控制台程序，當然由於是示例，故只引用了logger包，正常還需引用jdbc或ORM框架的相關jar包，　上述代碼關鍵邏輯說明（同樣要注意順序）：

1.new AnnotationConfigApplicationContext類（spring IOC容器），創建一個IOC容器，類似.NET CORE中的ServiceProvider類；

2.定義 SpringBeansConfig bean注冊配置類（注冊相關依賴），這個類中依次注入相關的bean，如果bean之間有依賴順序關系，建議添加@Order並指明序號；該類作為AnnotationConfigApplicationContext的構造函數參數傳入，以便IOC自動解析並完成實際注冊；

3.同樣是定義一個HostService 宿主服務類，並實現run方法邏輯，一般采取后台線程異步執行，為了演示效果與.NET CORE的HostService 類相同，示例邏輯基本相同。另外還定義了AppProperties配置映射類，便於直接讀取配置，.NET CORE同樣也有類似注冊bind到配置類中，然后在服務類中使用：IOptions<配置類>作為構造函數參數實現構造函數注入。只是由於篇幅有限故.NET CORE部份直接采取了注入IConfiguration，大家有興趣可以查看網上相關資料。

4.IOC容器初始化並注冊成功后，即可解析HostService 類獲得實例，執行run方法，run方法會開啟線程在后台處理，並返回到主線程，直至in.read()阻塞掛起主線程，防止程序自動關閉。

編寫Spring boot控制台程序優雅姿勢二：（引用spring boot jar包）

 使用IDEA+Spring Initializr來創建一個spring boot項目，創建過程中按需選擇依賴的框架，我這里是示例，故除了默認spring-boot-starter依賴外，其余什么依賴都不添加，創建后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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.zuowenjun.spring</groupId>
    <artifactId>springboot-console</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-console</name>
    <description>Demo project for Spring Boot</description>
    <url>http://www.zuowenjun.cn</url>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</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>

然后創建相關的Bean類：HostService（宿主服務類，這個與前文定義類均相同）、AppProperties（配置映射類，這個是映射默認的application.properties配置文件，注意這里的映射方式與前文所描述稍有不周，采用：@ConfigurationProperties+屬性映射，無需加@Value注解，映射屬性時如果有-則應寫成駝峰式，如果有.則應定義內部靜態類，呈現層級屬性完成映射，具體的用法可以參見我之前的文章）：

//HostService.java

package cn.zuowenjun.spring.services;

import cn.zuowenjun.spring.AppProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

import java.util.Collections;

@Component
public class HostService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HostService.class);

    @Autowired
    private AppProperties appProperties;

    //可以添加其它屬性注入

    public void run() {
//        ExecutorService pool = Executors.newSingleThreadExecutor();
//        pool.execute(() -> execute());

        new Thread(this::execute).start();
    }

    /// <summary>
    /// 控制台核心執行入口方法
    /// </summary>
    private void execute() {
        //TODO 業務邏輯代碼，如下模擬
        StopWatch stopwatch = new StopWatch();
        stopwatch.start();
        for (int i = 1; i <= 100; i++) {
            System.out.println("test WriteLine:" + i);
            try {
                Thread.sleep(100);
            } catch (Exception e) {
            }
        }
        stopwatch.stop();

        System.out.println(String.join("", Collections.nCopies(30, "=")));

        System.out.printf("app name is:%s %n", appProperties.getName());
        System.out.printf("app author is:%s %n", appProperties.getAuthor());
        System.out.printf("app test msg:%s %n", appProperties.getTestMsg());

        LOGGER.info("Logging - Execute Elapsed Times:{}ms", stopwatch.getTotalTimeMillis());
    }
}


//AppProperties.java

package cn.zuowenjun.spring;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {

    private String name;

    private String author;

    private String testMsg;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getTestMsg() {
        return testMsg;
    }

    public void setTestMsg(String testMsg) {
        this.testMsg = testMsg;
    }
}

application.properties配置文件：(注意app.test.msg此處改為了app.test-msg，因為這樣就可以直接映射到類的屬性中，否則得定義內部類有點麻煩)

app.name=demo spring console
app.author=zuowenjun
app.test-msg=hello java spring console app!

　最后改造spring boot application類，讓SpringbootConsoleApplication類實現ApplicationRunner接口，並在run方法中編寫通過屬性依賴注入獲得HostService類的實例，最后執行HostService的run方法即可，代碼如下：

package cn.zuowenjun.spring;

import cn.zuowenjun.spring.services.HostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootConsoleApplication implements ApplicationRunner {

    @Autowired
    private HostService hostService;

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

    @Override
    public void run(ApplicationArguments args) throws Exception {
        hostService.run();
    }
}

　如上步驟即完成了優雅編寫spring boot控制台程序，關鍵點是ApplicationRunner，這個是給spring boot執行的入口，另一種思路，我們其實還可以把HostService類改造一下，讓其實現ApplicationRunner接口，那么run方法即為spring boot的啟動入口。

總結一下：.

NET CORE控制台程序優雅姿勢一與Spring控制台優雅姿勢一核心思想是一樣的，都是手動創建各個依賴組件及IOC容器的實例，都是通過IOC容器顯式的解析獲得HostService類的實例，最后運行HostService#run方法。

NET CORE控制台程序優雅姿勢二與Spring控制台優雅姿勢二核心思想也是一樣的，都是利用IOC容器來直接管理注冊的各個依賴組件，並由.NET CORE、Spring boot框架自行調度HostService#run方法。

我個人更傾向優雅姿勢二的方法來編寫.NET CORE或Spring Boot的控制台程序，因為寫得更少，做得更多。