1.springboot教程菜鸟(springboot入门教程)
2.pyc文件是免费码免怎么创建的？
3.springboot安装及配置？

springboot教程菜鸟(springboot入门教程)

       学妹想学SpringBoot，连夜整理一篇SpringBoot入门最详细教程笔记

       凭借开箱即用，栗源远离繁琐的费版配置等特性，SpringBoot已经成为Java开发者人人必学必会的小栗开源项目。那么开发者该如何快速上手SpringBoot呢？

       那请问SpringBoot到底是源码啥？SpringBoot是Spring框架的扩展和自动化，它消除了在Spring中需要进行的免费码免生日祝福app源码XML（EXtensibleMarkupLanguage）文件配置（若习惯XML配置，则依然可以使用），栗源使得开发变得更快、费版更高效、小栗更自动化。源码

       微服务：每一个功能元素最终都是免费码免一个可独立替换和独立升级的软件单元。

       在maven的栗源settings.xml配置文件的profiles标签添加以下配置：

       把maven整合到idea。

       项目目录：

       HelloWorldMainApplication：

       HelloController：

       运行结果：

       打开浏览器访问：

       1、费版我们在pom.xml文件中假如以下代码：

       2、小栗然后，源码我们将应用打包

       3、然后再target文件夹下就可以看到spring-boot--helloworld-1.0-SNAPSHOT.jar

       4、复制到桌面（随便哪，个人选择），打开cmd窗口，切换到jar包所在位置，我的是桌面，然后输入：java-jarspring-boot--helloworld-1.0-SNAPSHOT.jar，运行效果如下。

       5、打开浏览器访问：，同样可以看到HelloWord

       这样的部署就变得十分简单了。

       小伙伴们，帮忙一键三连呀

       题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

       我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在Java学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升

       故此将并将重要的Java进阶资料包括并发编程、JVM调优、小说apk源码SSM、设计模式、spring等知识技术、阿里面试题精编汇总、常见源码分析等录播视频免费分享出来，需要领取的麻烦评论区领取

从零开始学SpringBoot之SpringBootWebSocket原理篇

       前言：

这节我们介绍下WebSocket的原理。

       一、websocket与umber和创建时间，只是一个整数//在写入的时候，使用char[4]来保存charbuf[4];//声明一个WFILE类型变量wfWFILEwf;//内存初始化memset(&wf,0,sizeof(wf));//初始化内部成员wf.fp=fp;wf.ptr=wf.buf=buf;wf.end=wf.ptr+sizeof(buf);wf.error=WFERR_OK;wf.version=version;//调用w_long将x、也就是版本信息或者时间写到wf里面去w_long(x,&wf);//刷到磁盘上w_flush(&wf);}

       所以该函数只是初始化了一个WFILE对象，真正写入则是调用的w_long。

staticvoidw_long(longx,WFILE*p){ w_byte((char)(x&0xff),p);w_byte((char)((x>>8)&0xff),p);w_byte((char)((x>>)&0xff),p);w_byte((char)((x>>)&0xff),p);}

       w_long则是调用 w_byte 将 x 逐个字节地写到文件里面去。

       而写入PyCodeObject对象则是调用了PyMarshal_WriteObjectToFile，我们也来看看长什么样子。

voidPyMarshal_WriteObjectToFile(PyObject*x,FILE*fp,intversion){ charbuf[BUFSIZ];WFILEwf;memset(&wf,0,sizeof(wf));wf.fp=fp;wf.ptr=wf.buf=buf;wf.end=wf.ptr+sizeof(buf);wf.error=WFERR_OK;wf.version=version;if(w_init_refs(&wf,version))return;/*callermushcheckPyErr_Occurred()*/w_object(x,&wf);w_clear_refs(&wf);w_flush(&wf);}

       可以看到和PyMarshal_WriteLongToFile基本是类似的，只不过在实际写入的时候，PyMarshal_WriteLongToFile调用的是w_long，而PyMarshal_WriteObjectToFile调用的是w_object。

staticvoidw_object(PyObject*v,WFILE*p){ charflag='\0';p->depth++;if(p->depth>MAX_MARSHAL_STACK_DEPTH){ p->error=WFERR_NESTEDTOODEEP;}elseif(v==NULL){ w_byte(TYPE_NULL,p);}elseif(v==Py_None){ w_byte(TYPE_NONE,p);}elseif(v==PyExc_StopIteration){ w_byte(TYPE_STOPITER,p);}elseif(v==Py_Ellipsis){ w_byte(TYPE_ELLIPSIS,p);}elseif(v==Py_False){ w_byte(TYPE_FALSE,p);}elseif(v==Py_True){ w_byte(TYPE_TRUE,p);}elseif(!w_ref(v,&flag,p))w_complex_object(v,flag,p);p->depth--;}

       可以看到本质上还是调用了w_byte，但这仅仅是一些特殊的对象。如果是列表、字典之类的数据，那么会调用w_complex_object，也就是代码中的最后一个else if分支。

       w_complex_object这个函数的源代码很长，我们看一下整体结构，具体逻辑就不贴了，我们后面会单独截取一部分进行分析。

staticvoidw_complex_object(PyObject*v,charflag,WFILE*p){ Py_ssize_ti,n;//如果是整数的话，执行整数的写入逻辑if(PyLong_CheckExact(v)){ //......}//如果是浮点数的话，执行浮点数的写入逻辑elseif(PyFloat_CheckExact(v)){ if(p->version>1){ //......}else{ //......}}//如果是复数的话，执行复数的写入逻辑elseif(PyComplex_CheckExact(v)){ if(p->version>1){ //......}else{ //......}}//如果是字节序列的话，执行字节序列的写入逻辑elseif(PyBytes_CheckExact(v)){ //......}//如果是字符串的话，执行字符串的写入逻辑elseif(PyUnicode_CheckExact(v)){ if(p->version>=4&&PyUnicode_IS_ASCII(v)){ //......}else{ //......}}else{ //......}}//如果是元组的话，执行元组的写入逻辑elseif(PyTuple_CheckExact(v)){ //......}//如果是列表的话，执行列表的源码完整破解写入逻辑elseif(PyList_CheckExact(v)){ //......}//如果是字典的话，执行字典的写入逻辑elseif(PyDict_CheckExact(v)){ //......}//如果是集合的话，执行集合的写入逻辑elseif(PyAnySet_CheckExact(v)){ //......}//如果是PyCodeObject对象的话//执行PyCodeObject对象的写入逻辑elseif(PyCode_Check(v)){ //......}//如果是Buffer的话，执行Buffer的写入逻辑elseif(PyObject_CheckBuffer(v)){ //......}else{ W_TYPE(TYPE_UNKNOWN,p);p->error=WFERR_UNMARSHALLABLE;}}

       源代码虽然长，但是逻辑非常单纯，就是对不同的对象、执行不同的写动作，然而其最终目的都是通过w_byte写到pyc文件中。了解完函数的整体结构之后，我们再看一下具体细节，看看它在写入对象的时候到底写入了哪些内容？

staticvoidw_complex_object(PyObject*v,charflag,WFILE*p){ //......elseif(PyList_CheckExact(v)){ W_TYPE(TYPE_LIST,p);n=PyList_GET_SIZE(v);W_SIZE(n,p);for(i=0;i<n;i++){ w_object(PyList_GET_ITEM(v,i),p);}}elseif(PyDict_CheckExact(v)){ Py_ssize_tpos;PyObject*key,*value;W_TYPE(TYPE_DICT,p);/*ThisoneisNULLobjectterminated!*/pos=0;while(PyDict_Next(v,&pos,&key,&value)){ w_object(key,p);w_object(value,p);}w_object((PyObject*)NULL,p);}//......}

       以列表和字典为例，它们在写入的时候实际上写的是内部的元素，其它对象也是类似的。

deffoo():lst=[1,2,3]#把列表内的元素写进去了print(foo.__code__.co_consts)#(None,1,2,3)

       但问题来了，如果只是写入元素的话，那么Python在加载的时候怎么知道它是一个列表呢？所以在写入的时候不能光写数据，类型信息也要写进去。我们再看一下上面列表和字典的写入逻辑，里面都调用了W_TYPE，它负责将类型信息写进去。

       因此无论对于哪种对象，在写入具体数据之前，都会先调用W_TYPE将类型信息写进去。如果没有类型信息，那么当Python加载pyc文件的时候，只会得到一坨字节流，而无法解析字节流中隐藏的结构和蕴含的信息。

       所以在往pyc文件里写入数据之前，必须先写入一个标识，诸如TYPE_LIST、TYPE_TUPLE、TYPE_DICT等等，这些标识正是对应的类型信息。

       如果解释器在pyc文件中发现了这样的标识，则预示着上一个对象结束，新的对象开始，并且也知道新对象是什么样的对象，从而也知道该执行什么样的app小车源码构建动作。当然，这些标识也是可以看到的，在底层已经定义好了。

//marshal.c#defineTYPE_NULL'0'#defineTYPE_NONE'N'#defineTYPE_FALSE'F'#defineTYPE_TRUE'T'#defineTYPE_STOPITER'S'#defineTYPE_ELLIPSIS'.'#defineTYPE_INT'i'/*TYPE_INTisnotgeneratedanymore.Supportedforbackwardcompatibilityonly.*/#defineTYPE_INT'I'#defineTYPE_FLOAT'f'#defineTYPE_BINARY_FLOAT'g'#defineTYPE_COMPLEX'x'#defineTYPE_BINARY_COMPLEX'y'#defineTYPE_LONG'l'#defineTYPE_STRING's'#defineTYPE_INTERNED't'#defineTYPE_REF'r'#defineTYPE_TUPLE'('#defineTYPE_LIST'['#defineTYPE_DICT'{ '#defineTYPE_CODE'c'#defineTYPE_UNICODE'u'#defineTYPE_UNKNOWN'?'#defineTYPE_SET'<'#defineTYPE_FROZENSET'>'

       到了这里可以看到，其实Python对PyCodeObject对象的导出实际上是不复杂的。因为不管什么对象，最后都为归结为两种简单的形式，一种是数值写入，一种是字符串写入。

       上面都是对数值的写入，比较简单，仅仅需要按照字节依次写入pyc即可。然而在写入字符串的时候，Python设计了一种比较复杂的机制，有兴趣可以自己阅读源码，这里不再介绍。

PyCodeObject的包含关系

       有下面一个文件：

//位置：Python/marshal.c//FILE是C自带的文件句柄//可以把WFILE看成是FILE的包装typedefstruct{ FILE*fp;//文件句柄//下面的字段在写入信息的时候会看到interror;intdepth;PyObject*str;char*ptr;char*end;char*buf;_Py_hashtable_t*hashtable;intversion;}WFILE;0

       显然编译之后会创建三个PyCodeObject对象，但是有两个PyCodeObject对象是位于另一个PyCodeObject对象当中的。

       也就是foo和A对应的PyCodeObject对象，位于模块对应的PyCodeObject对象当中，准确的说是位于co_consts指向的常量池当中。举个栗子：

//位置：Python/marshal.c//FILE是C自带的文件句柄//可以把WFILE看成是FILE的包装typedefstruct{ FILE*fp;//文件句柄//下面的字段在写入信息的时候会看到interror;intdepth;PyObject*str;char*ptr;char*end;char*buf;_Py_hashtable_t*hashtable;intversion;}WFILE;1

       我们看到f2对应的PyCodeObject确实位于f1的常量池当中，准确的说是f1的常量池中有一个指针指向f2对应的PyCodeObject。

       不过这都不是重点，重点是PyCodeObject对象是可以嵌套的。当在一个作用域内部发现了一个新的作用域，那么新的作用域对应的PyCodeObject对象会位于外层作用域的PyCodeObject对象的常量池中，或者说被常量池中的一个指针指向。

       而在写入pyc的时候会从最外层、也就是模块的PyCodeObject对象开始写入。如果碰到了包含的另一个PyCodeObject对象，那么就会递归地执行写入新的PyCodeObject对象。

       如此下去，最终所有的PyCodeObject对象都会写入到pyc文件当中。因此pyc文件里的PyCodeObject对象也是以一种嵌套的关系联系在一起的，和代码块之间的关系是保持一致的。

//位置：Python/marshal.c//FILE是类似917 源码C自带的文件句柄//可以把WFILE看成是FILE的包装typedefstruct{ FILE*fp;//文件句柄//下面的字段在写入信息的时候会看到interror;intdepth;PyObject*str;char*ptr;char*end;char*buf;_Py_hashtable_t*hashtable;intversion;}WFILE;2

       这里问一下，上面那段代码中创建了几个PyCodeObject对象呢？

       答案是6个，首先模块是一个，foo函数一个，bar函数一个，类A一个，类A里面的foo函数一个，类A里面的bar函数一个，所以一共是6个。

       而且这里的PyCodeObject对象是层层嵌套的，一开始是对整个全局模块创建PyCodeObject对象，然后遇到了函数foo，那么再为函数foo创建PyCodeObject对象，依次往下。

       所以，如果是常量值，则相当于是静态信息，直接存储起来便可。可如果是函数、类，那么会为其创建新的PyCodeObject对象，然后再收集起来。

小结

       以上就是pyc文件相关的内容，源文件在编译之后会得到pyc文件。因此我们不光可以手动导入 pyc，用Python直接执行pyc文件也是可以的。

       以上就是本次分享的所有内容，想要了解更多欢迎前往公众号：Python编程学习圈，每日干货分享

springboot安装及配置？

       SpringBoot教程第篇：整合elk，搭建实时日志平台

       这篇文章主要介绍springboot整合elk.

       elk简介

       elk下载安装

       elk下载地址：

       建议在linux上运行，elk在windows上支持得不好，另外需要jdk1.8的支持，需要提前安装好jdk.

       下载完之后：安装，以logstash为栗子：

       配置、启动Elasticsearch

       打开Elasticsearch的配置文件：

       修改配置:

       network.host=localhost

       network.port=

       它默认就是这个配置，没有特殊要求，在本地不需要修改。

       启动Elasticsearch

       启动成功，访问localhost:,网页显示：

       配置、启动logstash

       在logstash的主目录下：

       修改log4j_to_es.conf如下：

       input{

       log4j{

       mode="server"

       host="localhost"

       port=

       }

       }

       filter{

       #Onlymatcheddataaresendtooutput.

       }

       output{

       elasticsearch{

       action="index"#TheoperationonES

       hosts="localhost:"#ElasticSearchhost,canbearray.

       index="applog"#Theindextowritedatato.

       }

       }

       修改完配置后启动：

       ./bin/logstash-fconfig/log4j_to_es.conf

       终端显示如下：

       访问localhost:

       证明logstash启动成功。

       配置、启动kibana

       到kibana的安装目录：

       默认配置即可。

       访问localhost:，网页显示：

       证明启动成功。

       创建springboot工程

       起步依赖如下：

       log4j的配置，／src/resources/log4j.properties如下：

       log4j.rootLogger=INFO,console

       #forpackagecom.demo.elk,logwouldbesenttosocketappender.

       log4j.logger.com.forezp=DEBUG,socket

       #appendersocket

       log4j.appender.socket=org.apache.log4j.net.SocketAppender

       log4j.appender.socket.Port=

       log4j.appender.socket.RemoteHost=localhost

       log4j.appender.socket.layout=org.apache.log4j.PatternLayout

       log4j.appender.socket.layout.ConversionPattern=%d[%-5p][%l]%m%n

       log4j.appender.socket.ReconnectionDelay=

       #appenderconsole

       log4j.appender.console=org.apache.log4j.ConsoleAppender

       log4j.appender.console.target=System.out

       log4j.appender.console.layout=org.apache.log4j.PatternLayout

       log4j.appender.console.layout.ConversionPattern=%d[%-5p][%l]%m%n

       打印log测试：

       在kibana实时监控日志

       打开localhost::

       Management=indexpattrns=addnew:

       点击discovery:

       springboot配置文件总结

       springboot本身支持多种灵活的配置方式，为开发springboot程序带来了很大的灵活性和扩展性，但是同时由于太灵活，经常会导致明明配置了相关属性，却没有生效。

       本文总结了springboot配置文件的原理以及多个配置文件生效的顺序。

       springboot配置文件支持灵活的路径，以及灵活的文件名，用一个变量表达式总结如下：

       部分源码如下：

       当满足上述变量表达式的配置文件有多个时，会有一个配置的优先级。假设

       上面每个条件组合起来，则最多有配置文件如下，且顺序从上到下：

       获取属性时，按从上到下的顺序遍历由上述文件生成的属性资源对象PropertySource，如果遇到匹配的key直接返回。

       总结一下：就是如果同一个key的属性只出现一次，则直接取该值即可。如果同一个key的属性出现多次，则取顺序靠前的属性资源对象。另外其中每个文件都是可选的。

       需要注意的一点是：如果在同一个location下配置了多个文件名一样的文件，则只会取一个，比如在classpath:/，有如下两个文件application.yml：

       则只会根据classloader的classpath列表，选取第一个出现的文件。因为springboot加载配置文件时最底层是使用的下面的方法：

       这两个方法只会获取classloader类的ucp属性里面第一个匹配到的值。如果对springboot自身的机制不满意，想获取所有的classpath:/路径下面的applicaiton.yml文件，可以使用下面的方法：

       本文总结了springboot配置文件的原理以及多个配置文件生效的顺序。如果存在增加了配置文件或者在配置文件里面增加了属性却没有生效，可以参考上面的springboot配置文件表达式和配置文件生效顺序进行排查。

       后面还会有一篇文章讨论基于springboot配置原理如何实现自定义的配置读取方式。

springboot插件安装（JBLSpringBootAppGen）

       插件安装

       在应用springboot工程的时候；一般情况下都需要创建启动引导类Application.java和application.yml配置文件，而且内容都是一样的；为了便捷可以安装一个IDEA的插件JBLSpringBootAppGen在项目上右击之后可以自动生成启动引导类Application.java和application.yml配置文件。

       使用

       新建任意一个maven工程，右击工程，选择JBLSpringBootAppGen

       是否添加application.properties文件

       点击OK，工具会自动帮忙创建

SpringBoot配置文件详解（告别XML）

       快速学会和掌握SpringBoot的核心配置文件的使用。

       SpringBoot提供了丰富的外部配置，常见的有：

       其中核心配置文件我们并不陌生，主要以Key-Value的形式进行配置，其中属性Key主要分为两种：

       在application.properties添加配置如下：

       ①添加数据源信息

       在application.propertis添加配置如下：

       ①添加认证信息，其中socks.indentity.*是自定义的属性前缀。

       ②添加随机值，其中spring.test.*是自定义的属性前缀。

       使用方法：@ConfigurationProperties(prefix="spring.datasource")

       使用说明：提供Setter方法和标记组件Component

       如何验证是否成功读取配置？答：这里可以简单做个验证，注入MyDataSource，使用Debug模式可以看到如下信息：

       使用方法：@Value("spring.datasource.*")

       使用说明：提供Setter方法和标记组件Component

       注意事项：@Value不支持注入静态变量，可间接通过Setter注入来实现。

       关于两者的简单功能对比：

       显然，前者支持松绑定的特性更强大，所以在实际开发中建议使用@ConfigurationProperties来读取自定义属性。

       SpringBoot默认会加载这些路径加载核心配置文件，按优先级从高到低进行排列：具体规则详见ConfigFileApplicationListener

       如果存在多个配置文件，则严格按照优先级进行覆盖，最高者胜出：

       举个简单的例子，例如再上述位置都有一个application.properties，并且每个文件都写入了server.port=xx（xx分别是，，，），在启动成功之后，最终应用的端口为：。图例：

       如果想修改默认的加载路径或者调改默认的配置文件名，我们可以借助命令行参数进行指定，例如：

       YAML是JSON的一个超集，是一种可轻松定义层次结构的数据格式。

       答：因为配置文件这东西，结构化越早接触越规范越好。这里推荐阅读阮一峰老师写的YAML语言教程，写的很简单明了。

       引入依赖：在POM文件引入snakeyaml的依赖。

       使用说明：直接在类路径添加application.yml即可。

       例如下面这两段配置是完全等价的：

       ①在application.yml配置数据源:

       ②在application.properties配置数据源：

       在项目的实际开发中，我们往往需要根据不同的环境来加载不同的配置文件。例如生产环境，测试环境和开发环境等。此时，我们可以借助Profiles来指定加载哪些配置文件。例如：

       温馨提示：如果spring.profiles.active指定了多个配置文件，则按顺序加载，其中最后的优先级最高，也就是最后的会覆盖前者。

       使用方法：

       使用Maven插件打包好项目，然后在当前路径，执行DOS命令：java-jardemo.jar--server.port=，在控制台可看到应用端口变成了。

       实现原理：

       默认情况下，SpringBoot会将这些命令行参数转化成一个Property，并将其添加到Environment上下文。

       温馨提示：

       由于命令行参数优先级非常之高，基本高于所有常见的外部配置，所以使用的时候要谨慎。详见PropertySource执行顺序。

       关闭方法：

       如果想禁用命令行属性，可以设置如下操作：springApplication.setAddCommandLineProperties(false)

Springboot配置logback

       因为logback其他配置尚好理解，本文只说明比较少用，但是却起关键作用的两个子节点。

       1、依赖：

       实际开发中我们不需要直接添加该依赖，你会发现spring-boot-starter其中包含了spring-boot-starter-logging，SpringBoot为我们提供了很多默认的日志配置，所以，只要将spring-boot-starter-logging作为依赖加入到当前应用的classpath，则“开箱即用”。

       2、日记的等级

       日志级别从低到高分为TRACEDEBUGINFOWARNERRORFATAL

       3、配置

       这里对日志框架的支持有两种配置方式，一般来讲我们倘若不是要较复杂的需求，可以直接在?application.yml?配置文件配置下即可：

       application.properties或?application.yml?（系统层面）

       参考网站：

       logback-spring.xml（自定义文件方式）

       参考网站：

       4、彩色打印

       参考：

       5、@Slf4j注解

       安装lombok插件，在需要打印的类名上加上该注解即可

       替代下面语句的编写

       privateLoggerlogger=LoggerFactory.getLogger(this.getClass());

       6、打印不出json的问题

       不是打印不出而是正确的要加一个占位符{ }，如下

       log.info("hospital{ }",JSON.toJSONString(hospitalEntity2));

       7、log存放文件路径定义

       最关键的两个节点，你可以理解之前的property、appender嵌套property只是一些定义好的变量，真正定义方法怎么去运用这些变量是这两个节点所要做的。

       1、子节点--root

       root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性，不区分大小写，默认是DEBUG。

       可以包含零个或多个元素，标识这个appender将会添加到这个loger（理解root为一个全局的loger）。

       举例子：

       上图这是我定义好的文件输出的appender节点，对应下图的appender-ref节点，ref对应appender的name属性，上面说到root节点好比一个方法，所以现在这个方法的意思是全局打印等级为INFO，而且四个appender变量都执行，即正常的控制台输出和warn、info、error的三个文件输出，可以到对应的控制台和日志文件里面看到的确有日志。反之倘若我们level定为Debug，或者去除name为“WARN”的appender则是输出Debug以上等级的日志，WARN.log日志文件也不会再有日志打印进去。

       2、子节点--loger

       loger用来设置某一个包或者具体的某一个类的日志打印级别、以及指定appender，也就是只管辖指定的区域的日志输出规则。loger仅有一个name属性，一个可选的level和一个可选的addtivity属性。

       注意：这里说的上级就是root节点

       name:用来指定受此loger约束的某一个包或者具体的某一个类。

       level:用来设置打印级别，大小写无关：TRACE,DEBUG,INFO,WARN,ERROR,ALL和OFF，还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。如果未设置此属性，那么当前loger将会继承上级的级别。

       addtivity:是否向上级loger传递打印信息。默认是true。

       举例子：

       控制com.dudu.controller.LearnController类的日志打印，打印级别为“WARN”;

       additivity属性为false，表示此loger的打印信息不再向上级传递;

       指定了名字为“console”的appender;

       这时候执行com.dudu.controller.LearnController类的login方法时，先执行loggername="com.dudu.controller.LearnController"level="WARN"additivity="false",

       将级别为“WARN”及大于“WARN”的日志信息交给此loger指定的名为“console”的appender处理，在控制台中打出日志，不再向上级root传递打印信息。

       注意：

       当然如果你把additivity=”false”改成additivity=”true”的话，就会打印两次，因为打印信息向上级传递，logger本身打印一次，root接到后又打印一次。

       四、配合多环境

       据不同环境（prod:生产环境，test:测试环境，dev:开发环境）来定义不同的日志输出，在logback-spring.xml中使用springProfile节点来定义，方法如下：

       文件名称不是logback.xml，想使用spring扩展profile支持，要以logback-spring.xml命名

       可以启动服务的时候指定profile（如不指定使用默认），如指定prod的方式为：

       java-jarxxx.jar–spring.profiles.active=prod

       关于多环境配置可以参考

       SpringBoot干货系列：（二）配置文件解析