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

時間 2019-11-06

標籤 core spring boot 編寫控制檯程序應有優雅欄目 Spring 简体版

原文原文鏈接

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

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

先來講說.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控制檯程序有什麼區別。web

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

代碼以下：apache

//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>

View Code

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

1.由於通常應用程序都會有config文件，故咱們須要先經過new ConfigurationBuilder來設置config文件的方式及路徑；api

2.由於要使用.NET CORE默認的IOC框架，故new ServiceCollection，而後將相關的依賴服務組件註冊到IOC容器中；springboot

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>

View Code

如上代碼所示，寫過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>

View Code

而後採起自定義註解類(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>

View Code

而後建立相關的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的控制檯程序，由於寫得更少，作得更多。