精华内容
下载资源
问答
  • sourceinsight全局配置文件 下载

    热门讨论 2017-04-29 10:40:20
    用于sourceinsight的全局导入,比较适合C语言,其他语言没尝试过。
  • 纯c读写ini配置文件

    千次下载 热门讨论 2015-10-14 11:40:56
    纯c读写ini配置文件 用c/c++读写ini配置文件有不少第三方的开源库,如iniparser、libini、rwini、UltraLightINIParser等,但都不理想,往往代码较大、功能较弱、 接口使用不方便。尤其在大小写处理、前后空格、各种...
  • Emacs配置文件

    千次下载 热门讨论 2011-11-19 00:06:14
    这是我的emacs配置文件,和我的blog相对应的
  • rabbitmq配置文件 rabbitmq.config

    热门讨论 2014-11-04 14:42:06
    rabbitmq配置文件,用于rabbitmq管理
  • 详细SpringBoot教程之配置文件(一)

    万次阅读 多人点赞 2020-02-22 18:40:29
    我这里打算写一个SpringBoot系列的相关博文,目标呢是想让看了这一系列博文的同学呢,能够对SpringBoot略窥门径,这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合...

    写在前面

    鉴于有人留言说想要学习SpringBoot相关的知识,我这里打算写一个SpringBoot系列的相关博文,目标呢是想让看了这一系列博文的同学呢,能够对SpringBoot略窥门径,这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合docker、缓存、消息队列、检索、任务安全、分布式等等一系列的博文,工作量很大,是个漫长的过程,每一步我都尽量详细,配上截图说明,也希望对看的同学真的有用。
    单纯就是想分享技术博文,还想说一句就是,如果觉得有用,请点个关注、给个赞吧,也算对我来说是个宽慰,毕竟也得掉不少头发,嘿嘿嘿

    系列文章传送条

    详细SpringBoot教程之入门(一)
    详细SpringBoot教程之入门(二)
    详细SpringBoot教程之配置文件(一)
    详细SpringBoot教程之配置文件(二)
    详细SpringBoot教程之日志框架
    详细SpringBoot教程之Web开发(一)
    详细SpringBoot教程之Web开发(二)
    详细SpringBoot教程之Web开发(三)
    详细SpringBoot教程之数据访问
    详细SpringBoot教程之启动配置原理
    详细SpringBoot教程之缓存开发

    配置文件

    SpringBoot可以使用全局配置或者其他配置文件,并且我们在SpringBoot开发中会经常需要去配置某些模块的配置,这样有利于我们业务分离,理清逻辑关系。这个时候可能会说了,不是说SpringBoot的优点之一就是省去了繁琐的配置,为什么这里又要学配置呢?哈哈哈,省去了繁琐的配置是因为SpringBoot帮我们把所有配置弄好了默认,如果我们需要更改一些默认配置,当然需要我们自己手动更改呀。对于一些分布式大型项目,我们需要分各种端口,分各种环境,这些都需要我们修改。而且我们可能需要对可以重复利用的模块进行封装,然后在新项目中作为默认配置进新项目的时候,也需要知道如何进行SpringBoot的配置,所以还是很重要的。

    说了这么多,我们开始来将SpringBoot的配置文件吧,在SpringBoot中配置文件有两种,一种是application.properties,另一种是application.yml,其中yml配置文件是在properties之后才有的。配置文件放在src/main/resources 目录或者类路径/config下,配置文件的作用,就是修改SpringBoot自动配置的默认值,SpringBoot底层都给我们自动配置好了很多默认值,我们就需要通过灵活的使用properties和yml来进行修改默认配置。

    我们通过Idea向导帮我们创建的新项目,在Resources目录下面会帮我们自动生成一个properties配置文件,如下图
    在这里插入图片描述
    在resources目录下我们可以暂时手动再创建一个application.yml文件,为了比较学习他们的区别(说明一下的就是,二者可以同时存在,不过最终只会运行一个,一般默认运行application.properties,不过我们可以通过配置,在application.properties中同时应用yml,达到多个配置文件的目的),依旧在resources目录下,直接右键new->File,创建一个名为application.yml的文件,如下图
    在这里插入图片描述
    YAML 是 “YAML Ain’t a Markup Language”(YAML 不是一种标记语言)。在开发的这种语言时,YAML 的意思其实是:“Yet Another Markup Language”(仍是一种标记语言)。它使用空白符号缩进和大量依赖外观的特色,特别适合用来表达或编辑数据结构、各种配置文件,即以数据为中心,比json、xml等更加适合做配置文件,以前的项目大都是使用xml作为配置文件的。在全局配置文件中,可以对一些默认配置值进行修改,比如我们修改默认的端口号,我们如果使用xml作为配置文件,配置端口可能会是如下

    <server>
    	<port>8090</port>
    </server>
    

    发现了没有,xml会浪费大量的内容给标签的开闭上,那如果我们在SpringBoot项目中使用properties和yml设置端口,又该如何呢,如下,左边是yml,右边是properties,两者看起来是不是都很简略
    在这里插入图片描述

    YAML语法

    properties我们常见,我这里说一下YAML的一些基本语法,想要深入的可以直接到网上查,应该有很多详细的文档,我这里只是说一下基本语法,方便我们后面的讲解。

    基本语法

    • 大小写敏感
    • 使用缩进表示层级关系
    • 缩进不允许使用tab,只允许空格
    • 缩进的空格数不重要,只要相同层级的元素左对齐即可
    • '#'表示注释

    数据类型

    YAML 支持以下几种数据类型:

    • 对象:键值对的集合,又称为映射/ 哈希 / 字典
    • 数组:一组按次序排列的值,又称为序列 / 列表
    • 字面量:单个的、不可再分的值

    字面量写法

    字面量是最基本的,不可再分的值,包括:字符串、布尔值、整数、浮点数、时间、Null、日期。使用一个例子来快速了解字面量的基本使用:

    boolean: 
        - TRUE  #true,True都可以
        - FALSE  #false,False都可以
    #例子:isEmpty: false
    float:
        - 3.14
        - 6.8523015e+5  #可以使用科学计数法
    #例子:value: 3.14
    int:
        - 123
        - 0b1010_0111_0100_1010_1110    #二进制表示
    #例子:value: 123
    null:
        nodeName: 'node'
        parent: ~  #使用~表示null
    #例子:value: ~
    string:
        - 哈哈
        - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
        - newline
          newline2    #字符串可以拆成多行,每一行会被转化成一个空格
    #例子:value: 哈哈
    date:
        - 2018-02-17    #日期必须使用ISO 8601格式,即yyyy-MM-dd
    #例子:value: 2018-02-17
    datetime: 
        -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式,时间和
                                  #日期之间使用T连接,最后使用+代表时区
    

    这里多说一些字符串,字符串默认不用加上单引号或者双引号。其中,双引号不会转移字符串里面的特殊字符,特殊字符会作为本身祥表示的意思,比如
    name: “I am \n dbc” 输出 I am 换行 dbc
    而单引号则会转义字符串里面的特殊字符,特殊字符最终只是一个普通的字符串数据,比如
    name: “I am \n dbc” 输出 I am \n dbc

    YAML 数组

    以 - 开头的行表示构成一个数组:

    num:
     - A
     - B
     - C
    

    YAML 支持多维数组,可以使用行内表示:key: [value1, value2, …]

    YAML 对象

    对象键值对使用冒号结构表示 key: value,冒号后面要加一个空格。
    也可以使用 key:{key1: value1, key2: value2, …}。还可以使用缩进表示层级关系,如下:

    key: 
        child-key: value
        child-key2: value2
    

    较为复杂的对象格式,可以使用问号加一个空格代表一个复杂的 key,配合一个冒号加一个空格代表一个 value:

    ?  
        - complexkey1
        - complexkey2
    :
        - complexvalue1
        - complexvalue2
    

    意思即对象的属性是一个数组 [complexkey1,complexkey2],对应的值也是一个数组 [complexvalue1,complexvalue2]
    YMAL基本语法先讲到这里,需要深入了解的自行查阅其他教程。

    配置文件注入简单案例

    这里我们在application.yml中写入一些数据,就是写一个类的属性值以及对应的数值,如下
    在这里插入图片描述
    为了方便,我也把内容粘贴出来

    person:
      lastName: dbc
      age: 22
      boss: false
      birth: 2017/12/12
      maps: {k1: v2,k2: ;2}
      lists:
       - lisi
       - dbc
      dog:
       name: 小狗
       age: 12
    

    写好了之后,我们创建一个Person类和一个Dog类,类中的属性值和配置文件中的属性值要一一对应,并在Person的类上加上@ConfigurationProperties注解,注解中的前缀填写我们在配置文件中的person,如下
    在这里插入图片描述
    在这里插入图片描述
    因为我们需要将配置文件中配置的每一个属性值,映射到组件中,所以我们在Person类上添加一个@ConfigurationProperties,意思是告诉SpringBoot将本类中所有属性和配置文件中相关的配置进行绑定,prefix意思就是配置映射关系。这个时候发现编辑器提示如下
    在这里插入图片描述
    我这里直接把依赖粘贴出来,然后把这段依赖粘贴进pom.xml文件中,Idea会自动加载依赖,加载完依赖之后,原本红色的提示,变成 了绿色即可,如下

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    

    在这里插入图片描述
    现在,完成了依赖的导入,也完成了配置文件的映射(即将配置文件和类进行了关联映射),映射之后,我们成这个映射为组件,不过现在我们只是完成了组件映射,我们还需要将这个组件注入到Spring容器中,因为只有这个组件是容器中的组件,才能容器提供的@ConfigurationProperties功能获取,所以我们还需要添加@Component,把类组件加到容器中,如图
    在这里插入图片描述

    测试案例

    这样就完成了一个组件的注入,我们可以在容器中使用这个组件了,接下来我们进行单元测试了,细心的人会发现,我们使用Idea创建的SpringBoot项目中,在test目录下有一个java文件夹,被Idea标为绿色(如下),这个文件夹就是单元测试用的,当然我们手动创建的Maven项目,也可以手动配置,很简单,创建项目属性就可以了。接下来我们讲一下单元测试中的内容,如何使用
    在这里插入图片描述
    SpringBoot 的单元测试 ,可以在测试期间很方便的通过类似编码一样的方式,进行自动注入容器的功能,我们进入到那个DemoApplicationTests里面,其中有一个注解@SpringBootTest ,它标注是SpringBoot的单元测试。接着我们只需要在测试类中注入我们刚刚编写好的Person类,然后在方法中输出一下就可以了,毕竟我们只是检查一下我们编写的配置文件有没有成功配置好。执行之后在下方的日志中我们可以检查输出,测试类的内容和输出的日志结果如下图
    在这里插入图片描述
    在这里插入图片描述

    使用properties完成案例

    我们前面完成了使用yml类型的配置文件,进行映射注入,现在我们来试试使用properties类型的配置文件进行映射注入,其实不难,我们可以先将yml配置文件中的内容注释掉(当然不注释也可以,因为默认是读取properties)。我们开始编写properties里面的内容,会发现我们在properties中编写的时候,已经有person的提示了,是因为我们已经建类组件注入容器了,现在我们在里面编写内容如下
    在这里插入图片描述
    流程和yml中写的一样,获取配置文件值注入,导入处理器,注入写一个类,然后使用@ConfigurationProperties注解,注意了还得把类注入容器组件@Component
    (在这里我们只要把内容写进properties就可以了,类、映射和注入在测试yml的时候已经写好了)。编写好之后运行测试,发现依旧能够读取到,结果如下
    在这里插入图片描述
    细心的人会发现,我们输出的结果出现了乱码,而出现乱码的原因是因为我们Idea默认的是utf-8编码,而properties用的是ASCII码,我们只要在Idea中将文件编码设置成Utf-8就可以了,如下
    在这里插入图片描述
    在这里插入图片描述

    下一篇

    写到这里篇幅有点长了,关于配置的剩下内容,我将在下一篇博文中进行讲解,可以先把上面学习的进行消化,加油,奥利给。

    展开全文
  • 详细SpringBoot教程之配置文件(二)

    万次阅读 多人点赞 2020-02-22 23:55:32
    我这里打算写一个SpringBoot系列的相关博文,目标呢是想让看了这一系列博文的同学呢,能够对SpringBoot略窥门径,这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合...

    写在前面

    鉴于有人留言说想要学习SpringBoot相关的知识,我这里打算写一个SpringBoot系列的相关博文,目标呢是想让看了这一系列博文的同学呢,能够对SpringBoot略窥门径,这一系列的博文初步都定下来包括SpringBoot介绍、入门、配置、日志相关、web开发、数据访问、结合docker、缓存、消息队列、检索、任务安全、分布式等等一系列的博文,工作量很大,是个漫长的过程,每一步我都尽量详细,配上截图说明,也希望对看的同学真的有用。
    单纯就是想分享技术博文,还想说一句就是,如果觉得有用,请点个关注、给个赞吧,也算对我来说是个宽慰,毕竟也得掉不少头发,嘿嘿嘿

    系列文章传送条

    详细SpringBoot教程之入门(一)
    详细SpringBoot教程之入门(二)
    详细SpringBoot教程之配置文件(一)
    详细SpringBoot教程之配置文件(二)
    详细SpringBoot教程之日志框架
    详细SpringBoot教程之Web开发(一)
    详细SpringBoot教程之Web开发(二)
    详细SpringBoot教程之Web开发(三)
    详细SpringBoot教程之数据访问
    详细SpringBoot教程之启动配置原理
    详细SpringBoot教程之缓存开发

    配置映射的另一种方式

    上一篇博文我们进行了配置文件的编写,映射,注入以及如何进行测试相关的操作,在这里我们再来介绍另一种配置文件的映射注入,即使用其他注解的方式进行注入,我们这里要使用的注解是@Value,@Value是Spring的底层注解。

    我们回想一下我们以前写SpringMvc的配置文件的时候,我们在配置文件中使用bean进行配置,然后进行相关映射,还记得不,不记得我这里写出一个bean配置回忆一下,内容如下:

    <bean class="Person">
    	<property name="lastName" value="字面量/环境变量/#{获取值}等等"></property>
    <bean/>
    

    发现没有,以前的方式是我们通过一个一个给属性赋值,比如这里我们给lastName赋值,值就是value指定的。可能你已经意识到了,没错,@Value的作用其实和这里的value一样,相当于Spring帮我们简化了,只需要通过一个注解就能赋值,不过也是一个一个赋值哦,如何使用以及运行结果如下
    在这里插入图片描述
    发现没有,结果依旧可以获取值,所以以为这我们依旧配置成功。

    @ConfigurationProperties和@Value比较

    我们上一篇博文使用的是@ConfigurationProperties映射yml或者properties配置文件,这篇博文前面我们举例使用@Value进行配置,那么这两者有什么区别呢?首先我这里给一个比较官方的区别

    @ConfigurationProperties@Value
    功能批量注入配置文件中的属性一个个指定
    松散绑定支持不支持
    SpELl不支持支持
    JSR30数据校验支持不支持
    复杂类型封装支持不支持

    那么这里来解释一下什么是松散绑定呢?其实我们前面已经接触过了,只是不知道那是松散语法而已。比如我们有一个属性时lastName,按道理我们在配置文件中的属性名和Person类中的属性名需要一直对不对,不然没办法映射,但是在松散语法中,lastName和last-name是认为同一个,这种写法就是松散写法,也就是说,我们在配置文件中,person.lastName和person.last-name两种写法都可以,但是@Value是不支持松散写法的,属性名必须一致。

    还有就是JSR30数据校验,其实我们以前写Spring项目的时候基本都用过,就是校验器,比如对属性是否符合邮箱格式进行校验,不符合提示错误等,而配置文件注入值数据校验,只能使用ConfigurationProperties,如下
    在这里插入图片描述
    所以如果说我们只是在某个业务逻辑中需要获取一下配置文件中的某项值,可以使用@Value比较简洁。而如果说我们专门编写一个javaBean来和配置文件进行映射,我们就直接使用ConfigurationProperties。

    @PropertySource和@ImportResource比较

    @PropertySource

    我们前面在Person类上直接使用@ConfigurationProperties或者@Value进行映射,SpringBoot都是默认到主配置文件中寻找。而@PropertySource就是用来加载指定的配置文件。

    怎么理解呢?比如我们的application.properties和application.Yml是全局配置文件,我们原先把配置内容都是写到全局配置文件中的,然后我们使用@ConfigurationProperties或者@Value进行映射,也就是说@ConfigurationProperties或者@Value是默认映射全局配置文件的,那么如果项目一旦很大,我们不可能所有配置都写到全局配置文件中,所以这个时候我们需要创建一些其他的配置文件,然后指定映射。

    可能直接讲不容易理解,下面我举个例子,我们在resources下面创建一个person.properties,然后把application.properties里面的内容粘贴到person.properties中,这个时候我们通过@PropertySource,将Person类和person.properties进行映射,如下图。
    在这里插入图片描述

    @ImportResource

    @ImportResource是用来导入原先Spring的配置文件,让配置文件里面的内容生效,也就是说,如果想按照以前SpringMVC的那种出入配置,我们可以使用这个注解来完成。

    为了更好的理解,我们先在resourcs下创建一个bean.xml(就是以前Spring的配置文件),然后按照以前的方式写一个bean,如下内容
    在这里插入图片描述
    然后我们新写一个测试类,使用ApplicationContext容器,判断容器中是否注入了helloService,内容如下
    在这里插入图片描述
    然后启动测试类,运行之后查看发现helloService没有被注入,日志输出如下
    在这里插入图片描述
    这个时候就可以用到我们的ImportResource了,SpringBoot里面没有Spring的配置文件,我们自己编写的Spring配置文件也不能自动识别,想让Spring的配置文件生效,加载进容器,就可以使用@ImportResource标注在一个配置类上,这里我们在主配置类上标注如下,再次运行测试类
    在这里插入图片描述
    在这里插入图片描述
    当然我们实际开发中不可能像这样使用注解一个一个导入,而我们SpringBoot推荐给容器中添加组件的方式,也就是使用全注解的方式。怎么理解呢?就是我们专门创建一些配置类,用来同意管理项目中所有的配置注入。举个例子,我们专门创建一个配置类,如下创建一个config包,然后创建一个MyAppConfig类,内容如下
    在这里插入图片描述
    我们现在来测试一下,注意了,测试之前先把主配置类里面的@ImportResource去掉,我不使用@ImportResource注解,启动测试类,helloService注入依旧成功。

    配置文件占位符

    RandomValuePropertySource:配置文件中可以使用随机数如

    ${random.value}
    ${random.int}
    ${random.long}
    ${random.int(10)}
    ${random.int[1024,65536]}
    
    

    还有属性配置占位符

    app.name=MyApp
    app.description=${app.name} is a Spring Boot application
    

    可以在配置文件中引用前面配置过的属性(优先级前面配置过的这里都能使用)而可以通过${app.name:默认值}来指定找不到属性时的默认值,还是一样,我在配置文件中举个例子帮助理解
    在这里插入图片描述

    profile快速切换配置

    profile是Spring对不同环境提供不同配置功能的支持,可以通过激活、指定参数等方式快速切换环境,通俗点理解就是,开发环境的配置,生产环境的配置,测试环境的配置分开,使用profile可以进行快速切换

    激活方式(即切换方式)

    • 命令行: --spring.profiles.active=dev (打包之后,使用命令行执行的时候,指定参数)
    • 配置文件:spring.profiles.active=dev
    • Jvm参数 -Dspring.profiles.active=dev (在Idea修改参数)

    多profile文件形式

    有了激活方式,我们来看怎么使用,首先我们创建三种配置(包括原来的application.properties在内的三个),一般的配置文件格式:application-{profile}.properties。比如application-dev.properties、application-prod.properties。创建之后,我们可以在另外两个配置文件中配置我们想要的配置,然后在主配置文件中进行激活即可,如下
    在这里插入图片描述

    多profile文档块模式

    上面是通过properties进行多profile的配置,我们也可以使用yml来进行多profile的配置,yml的配置更简洁,不需要额外创建像application-dev.properties、application-prod.properties这样的配置文件,只需要在主yml配置文件中,使用“—”的文档块模式,如下图
    在这里插入图片描述

    配置文件加载位置

    SpringBoot启动会扫描以下位置的application.properties或者application.yml文件作为SpringBoot的默认配置文件,也就是说我们可以更改这两个配置文件的位置

    • file:./config/
    • file:./
    • classpath:/config/
    • classpath:/
      说明一下classpath是在resources目录位置,file是在项目根目录的位置,以上是按照优先级从高到低的顺序,所有位置的文件都会被加载,高优先级配置内容会覆盖低优先级配置内容,配置文件的内容是互补的,也就是说高优先级中没有的配置,如果低优先级有的话一样会生效,但是如果高优先级的配置中已经有了一项配置,低优先级中相同的配置就会被覆盖掉。

    我们也可以通过配置spring.config.location来改变默认配置,也就是说配置文件可以放在任意的位置,网络上或者电脑桌面任意位置,把位置路径赋给location就可以了,这样对于打包后的项目,使用命令行做运维

    外部配置的加载顺序

    • SpringBoot支持多种外部配置方式
    • 命令行参数
    • 来自java:comp/env的JNDI属性
    • Java系统属性(System.getProperties)
    • 操作系统环境变量
    • RandomValuePropertySource配置的random.*属性值
    • Jar包外的application-{profile}.properties或application.yml(带spring.profile)配置文件
    • Jar包内的application-{profile}.properties或application.yml(带spring.profile)配置文件
    • Jar包外的application.properties或application.yml(不带spring.profile)配置文件
    • Jar包外的application.properties或application.yml(不带spring.profile)配置文件
    • @Configuration注解类上的@PropertySource
    • 通过SpringApplication.setDefaultProperties指定的默认属性

    也就是说,除了我们项目运行配置的文件,我们可以在任何外部环境中,继续配置相关文件进行运行,及时项目已经被打包了,我们也可以使用相关命令行指令,运行在某个位置我们的配置文件,从而启动项目,非常方便运维对项目进行维护而不需要重新打包项目。

    自动配置原理

    前面我们其实有提高过自动配置类,即@EnableAutoConfiguration,不过只是带过了他的作用,没有深入讨论,这里我们进行深入讨论,首先先放出所有自动配置文件属性的参考,官网文档位置

    然后,我们这里通过观察HttpEncodingAutoConfiguration的这个自动配置来讲解,可以在如下位置中找到
    在这里插入图片描述
    打开HttpEncodingAutoConfiguration,进入到里面,我们逐个进行分析
    在这里插入图片描述
    点进HttpProperties.class我们会惊奇的发现,里面也是使用@ConfigurationProperties(prefix = “spring.http”)进行配置,这和我们之前在application.properties中手动配置相关组件的时候,使用的是一样的方式,所以能不能体会到,其实我们可以自行配置更多组件,并进行封装
    在这里插入图片描述
    在这里插入图片描述
    这里我们就可以总结一下自动配置文件的通用模式(即通过命名分辨)

    • xxxAutoConfiguration:自动配置类
    • xxxProperties:属性配置类
      也就是说,我们yml/properties文件中能配置的值就来源于属性配置类

    @EnableAutoConfiguration 的作用是利用AutoConfigurationImportSelector给容器中导入一些组件,详细的可以查看SpringFactoriesLoader.loadFactoryNames
    意思是扫描所有jar包类路径下,META-INF/spring.factories。把扫描到的这些文件的内容装成properties对象,然后从properties中获取到EnableAutoConfiguration.class类对应的值,然后把它们添加到容器中,也就是将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到容器中,类似下面这些自动配置类

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveRestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
    
    

    所有在配置文件中能配置的属性都是在xxxProperties类中封装这,配置文件能配置什么就可以参照某个功能对应的这个属性类,根据当前不同条件判断,决定这个配置是否生效。SpringBoot启动会加载大量的自动配置类,如果我们需要的功能有没有SpringBoot默认写好的自动配置类,那我们就手动引入或配置,在开发中,我们看这个自动配置类中到底配置了哪些组件,只要我们要用的组件存在,我们就不需要再来配置了。给容器中自动配置类添加组件的时候,会从properties类中获取某些属性,我们就可以在配置文件中指定配置属性的值。

    细节

    • @Conditional由Spring提供,而在Spring Boot中衍生出了以下相关的注解:
    • @ConditionalOnBean:当容器中有指定Bean的条件下。
    • @ConditionalOnClass:当classpath类路径下有指定类的条件下。
    • @ConditionalOnCloudPlatform:当指定的云平台处于active状态时。
    • @ConditionalOnExpression:基于SpEL表达式的条件判断。
    • @ConditionalOnJava:基于JVM版本作为判断条件。
    • @ConditionalOnJndi:在JNDI存在的条件下查找指定的位置。
    • @ConditionalOnMissingBean:当容器里没有指定Bean的条件。
    • @ConditionalOnMissingClass:当类路径下没有指定类的条件下。
    • @ConditionalOnNotWebApplication:当项目不是一个Web项目的条件下。
    • @ConditionalOnProperty:当指定的属性有指定的值的条件下。
    • @ConditionalOnResource:类路径是否有指定的值。
    • @ConditionalOnSingleCandidate:当指定的Bean在容器中只有一个,或者有多个但是指定了首选的Bean。
    • @ConditionalOnWebApplication:当项目是一个Web项目的条件下。
      以上组合注解均位于spring-boot-autoconfigure jar包下的org.springframework.boot.autoconfigure.condition包

    Debug查看详细的自动配置报告

    SpringBoot的debug功能还是非常有帮助的,比如它可以帮助我们查看项目加载注入了哪些自动配置类,从而使得我们不用一个类一个类点入查看。SpringBoot启动的时候,加载主配置类,进而开启了自动配置功能@EnableAutoConfiguration。

    因此,我们可以在配置文件中开启debug=true,来控制打印自动配置报告,这样我们就可以很方便的知道自动配置类生效

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • redis.conf Redis配置文件下载

    热门讨论 2015-01-06 17:43:06
    redis.conf Redis配置文件 下载 redis.conf 配置详解 Redis配置文件redis.conf 详解1.基本配置内存单位的表示# 1k => 1000 bytes# ...Redis 的详细介绍Redis 的下载地址
  • hadoop-windows下配置文件

    热门讨论 2016-12-09 11:50:26
    hadoop-windows下配置文件,用于在windows环境下安装hadoop使用,直接可以使用,省去自己编译的麻烦,支持当前最新的2.7.3版本。
  • SpringBoot配置文件&YAML配置注入(详解)

    千次阅读 多人点赞 2020-09-20 14:36:50
    目录一、SpringBoot配置文件1. SpringBoot默认配置文件2. 配置文件的作用3. 配置文件的位置4. 多环境切换方式一:多配置文件方式二:一个配置文件(yaml的多文档块)二、YAML配置注入1. YAML入门1、什么是YAML?2、...


    一、SpringBoot配置文件

    1. SpringBoot默认配置文件

    • SpringBoot使用默认的全局的配置文件:application.properties/application.yml

    • 配置文件名固定是是application

    `application.properties`
    	语法结构: key=value
    
    `application.yml`
    	语法结构: key:空格 value
    

    2. 配置文件的作用

    SpringBoot在底层给我们自动做了一些配置,所以springboot项目不编写配置文件也可以正常运行,但是根据我们的具体开发我们需要修改SpringBoot自动配置的默认值;

    比如我们可以更改默认启动的端口号

    application.properties中添加

    #更改项目端口号
    server.port=8081
    

    然后重新启动,可以看到启动的端口号变更
    image-20200918004521582
    然后访问localhost:8081即可
    image-20200918004714066

    3. 配置文件的位置

    springboot启动会扫描以下位置的application.properties/application.yml文件作为其默认配置文件:

    优先级1:项目路径下的config文件夹配置文件
    优先级2:项目路径下配置文件
    优先级3:资源路径下的config文件夹配置文件
    优先级4:资源路径下配置文件
    

    可以发现:springboot项目生成时的默认配置文件优先级是最低的
    image-20200920122317741

    • 优先级由高到底,高优先级的配置会覆盖低优先级的配置;

    • SpringBoot会从这四个位置全部加载主配置文件;互补配置;

    我们在最低级的两个配置文件中设置项目访问路径和端口号的配置来测试互补问题

    在默认位置(第四加载位置)的propertiesyaml两个配置文件中添加以下代码测试

    #配置项目的访问路径
    server.servlet.context-path=/zsr
    
    server:
      servlet:
        context-path: /zzz #配置项目的访问路径
      port: 8081 #配置端口号
    

    然后启动项目测试,可以看到,最终配置的项目访问路径是/zsr,且访问端口为8081
    image-20201008200955906
    因此:当两个配置文件同时存在的时候,相同的配置会优先加载properties配置文件,多余的配置的会互补配置;


    4. 多环境切换

    实际开发中,我们针对不同的应用场景,可能有不同的环境,不同的配置文件

    profile就是Spring对不同环境提供不同配置功能的支持,可以通过激活不同的环境版本,实现快速切换环境,

    方式一:多配置文件

    我们再编写配置文件时,文件名可以是application-{profile}.properties/yml,用来指定多个不同的环境版本;

    例如(properties格式)

    application.properties 代表主环境

    # /src/main/resources/application.properties
    server.port=8080
    

    application-test.properties 代表测试环境配置

    # /src/main/resources/application-test.properties
    server.port=8081
    

    application-dev.properties 代表开发环境配置

    # /src/main/resources/application-dev.properties
    server.port=8082
    

    当我们运行测试时,如果未加指定,它默认使用application.properties主配置文件;

    实际开发中,面对不同的环境,我们可以在默认配置文件application,properties中指定所需的配置文件环境,例如以下指定使用dev的配置文件:

    # /src/main/resources/application.properties
    server.port=8080
    spring.profiles.active=dev
    

    此后再启动SpringBoot,就可以看到已经切换到dev下的配置环境;

    YAML格式亦是如此

    image-20200920125248798

    方式二:一个配置文件(yaml的多文档块)

    yaml多文档块:可以在一个配置文件中配置多个环境并根据需要进行选择,无需上述多个配置文件,更为方便

    server:  
    	port: 8080
    #选择要激活那个环境块
    spring:  
    	profiles:    
    		active: prod
    		
    ---
    server:  
    	port: 8081
    spring:  
    	profiles: dev #配置环境名称dev
    
    ---
    server:  
    	port: 8082
    spring:  
    	profiles: prod  #配置环境名称prod
    

    注意:如果yml和 properties的配置文件同时存在,同时都配置了端口,但是yaml多环境没有指定环境,默认会使用properties配置文件的!




    二、YAML配置注入

    当我们新建一个项目Springboot项目时,默认使用properties格式的配置文件,其实SpringBoot还支持yaml格式的配置文件,且这是最流行,最为广泛使用的

    1. YAML入门

    1、什么是YAML?

    YAML 有两种展开方式:

    • YAML Ain't a Markup Language:YAML 不是一种标记语言

    • Yet Another Markup Language:YAML是一种标记语言

    之所以用反向缩略语重命名,是为了强调 YAML以数据做为中心,而不是以标记语言为重点

    功能

    • YAML的语法和其他高级语言类似,并且可以简单表达清单、散列表,标量等数据形态。

    • 它使用空白符号缩进和大量依赖外观的特色,特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲(例如:许多电子邮件标题格式和YAML非常接近)

    2、对比传统标记语言

    以前的配置文件,大多数都是使用 XML 来配置;YAML 作为一种比 XML 更为简单易读的序列化语言,正越来越多地被用于应用及配置文件的开发中

    比如一个简单的端口配置,我们来对比下yaml和xml:

    <!--传统xml配置-->
    <server>
        <port>8081<port>
    </server>
    
    #YAML配置
    server:
      prot: 8080
    

    简单的一个对比就可以看出:YAML可读性好,易于实现

    不仅如此,YAML还有很多其他有点:

    • YAML和脚本语言的交互性好
    • YAML使用实现语言的数据类型
    • YAML有一个一致的信息模型
    • YAML可以基于流来处理
    • YAML表达能力强,扩展性好

    总之,YAML试图用一种比XML更敏捷的方式,来完成XML所完成的任务

    3、基本语法

    • 大小写敏感
    • 使用缩进表示层级关系
    • 缩进不允许使用tab,只允许空格
    • 缩进的空格数不重要,只要相同层级的元素左对齐即可
    • #表示注释

    4、数据类型

    YAML 支持以下几种数据类型:

    • 对象:键值对的集合,又称为映射(mapping)/ 哈希(hashes) / 字典(dictionary)
    • 数组:一组按次序排列的值,又称为序列(sequence) / 列表(list)
    • 纯量(scalars):单个的、不可再分的值

    对象

    对象键值对使用冒号结构表示 key: value,冒号后面要加一个空格。

    password: 123456
    

    对象的行内写法:

    User: {name: zsr,age: 20}
    

    还可以使用缩进表示层级关系:

    User:
      name: zsr
      age: 20
    

    数组

    - 值表示数组中的一个元素,比如:

    pets:
     - cat
     - dog
     - pig
    

    行内写法

    pets: [cat,dog,pig]
    

    数据结构的子成员是一个数组,则可以在该项下面缩进一个空格,例如:

    companies:
        -
            id: 1
            name: company1
            price: 200W
        -
            id: 2
            name: company2
            price: 500W
    

    意思是 companies 属性是一个数组,每一个数组元素又是由 id、name、price 三个属性构成。

    数组也可以使用流式(flow)的方式表示:

    companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price: 500W}]
    

    纯量

    纯量是最基本的,不可再分的值,包括:

    • 字符串
    • 布尔值
    • 整数
    • 浮点数
    • Null
    • 时间
    • 日期

    纯量直接写在后面就可以,字符串默认不用加上双引号或者单引号;

    key: value
    

    当写一些特殊字符时,我们可能会用上单引号或者双引号:

    • " " 双引号:不会转义字符串里面的特殊字符 , 特殊字符会作为本身想表示的意思;

      #比如
      name: "kuang \n shen"  
      #输出 
      kuang 换行 shen
      
    • ' ' 单引号:会转义特殊字符 , 特殊字符最终会变成和普通字符一样输出

      #比如
      name: ‘kuang \n shen’  
      #输出
      kuang \n shen
      

    使用一个例子来快速了解纯量的基本使用:

    boolean: 
        - TRUE  #true,True都可以
        - FALSE  #false,False都可以
    float:
        - 3.14
        - 6.8523015e+5  #可以使用科学计数法
    int:
        - 123
        - 0b1010_0111_0100_1010_1110    #二进制表示
    null:
        nodeName: 'node'
        parent: ~  #使用~表示null
    string:
        - 哈哈
        - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
        - newline
          newline2    #字符串可以拆成多行,每一行会被转化成一个空格
    date:
        - 2018-02-17    #日期必须使用ISO 8601格式,即yyyy-MM-dd
    datetime: 
        -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式,时和日期之间使用T连接,最后使用+代表时区
    


    2. SpringBoot——yaml注入配置文件

    yaml文件更强大的地方在于,他可以给我们的实体类直接注入匹配值!

    1、编写一个实体类 Dog

    在主程序同级目录下新建pojo包,在包下新建一个Dog实体类

    image-20200920110431397

    package com.zsr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.stereotype.Component;
    
    @Data
    @AllArgsConstructor//有参构造
    @NoArgsConstructor//无参构造
    @Component//注册bean到容器中
    public class Dog {
        private String name;
        private Integer age;
    }
    

    2、编写一个Person实体类

    Person类,包含所有常见数据类型,以及Dog对象

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Component //注册bean到容器中
    public class Person {
        private String name;
        private Integer age;
        private Boolean happy;
        private Date birth;
        private Map<String, Object> maps;
        private List<Object> lists;
        private Dog dog;
    }
    

    3、编写yaml配置文件

    在springboot项目中的resources目录下新建一个文件 application.yml,使用yaml配置的方式进行注入

    image-20200920110327482
    person:
      name: zsr
      age: 20
      happy: True
      birth: 2000/02/04
      maps: {k1: v1,k2: v2}
      lists:
        - guitar
        - sing
        - play
      dog:
        name: 多多
        age: 4
    

    4、yaml配置注入

    刚才已经把person对象的所有属性值都写好了

    再通过@ConfigurationProperties注解注入到我们的类中,

    /*
    @ConfigurationProperties作用:
    	将配置文件中配置的每一个属性的值,映射到这个组件中;
    	告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
    	参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
    */
    @Component //注册bean
    @ConfigurationProperties(prefix = "person")
    public class Person {
        private String name;
        private Integer age;
        private Boolean happy;
        private Date birth;
        private Map<String,Object> maps;
        private List<Object> lists;
        private Dog dog;
    }
    

    IDEA爆红提示:springboot配置注解处理器没有找到,我们点击Open Document查看文档
    image-20200919110130064
    image-20200919110736754
    发现未找到,我们降低版本为2.1.9即可

    https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/html/configuration-metadata.html#configuration-metadata-annotation-processor
    

    进入到网页中,可以找到一个依赖,加上他,就不会爆红提示
    image-20200919115857791

    <!-- 导入配置文件处理器-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-configuration-processor</artifactId>
    	<optional>true</optional>
    </dependency>
    

    5、测试

    配置完成后,我们修改测试类进行测试

    package com.zsr;
    
    import com.zsr.pojo.Dog;
    import com.zsr.pojo.Person;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class Springboot02ConfigApplicationTests {
        @Autowired //将person自动注入进来
        private Person person;
    
        @Test
        void contextLoads() {
            System.out.println(person); //打印看下person对象
        }
    }
    

    结果:所有值全部注入成功!yaml配置成功注入到实体类!
    image-20200919120937486

    6、加载指定的配置文件

    以上我们通过@configurationProperties注解默认从全局配置文件中获取值

    • 此时配置文件名必须为application才能被spring认出

    • 其实我们可以通过@PropertySource指定加载的配置文件,可以自定义文件名

    1、我们去在resources目录下新建一个person.properties文件

    name=zsr
    age=20
    happy=True
    birth=2000/02/04
    lists=guitar,sing,play
    

    2、相应修改对应的实体类,用@PropertySource注解加载指定person.properties文件

    package com.zsr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Component //注册bean到容器中
    @PropertySource(value = "classpath:person.properties")
    public class Person {
        //SPEL表达式取出指定的值
        @Value("${name}")
        private String name;
        @Value("${age}")
        private Integer age;
        @Value("${happy}")
        private Boolean happy;
        @Value("${birth}")
        private Date birth;
        private Map<String, Object> maps;
        @Value("${lists}")
        private List<Object> lists;
        //properties不能存对象
        private Dog dog;
    }
    

    3、修改测试类

    package com.zsr;
    
    import com.zsr.pojo.Dog;
    import com.zsr.pojo.Person;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class Springboot02ConfigApplicationTests {
        @Autowired //将person自动注入进来
        private Person person;
        @Test
        void contextLoads() {
            System.out.println(person); //打印看下person对象
        }
    }
    

    4、运行测试

    指定配置文件绑定成功!
    image-20200919140057495

    7、yaml配置文件占位符

    yaml配置文件还可以编写占位符生成随机数

    person:
        name: zsr${random.uuid} # 随机uuid
        age: ${random.int}  # 随机int
        happy: true
        birth: 2000/02/04
        maps: {k1: v1,k2: v2}
        lists:
          - guitar
          - sing
          - play
        dog:
          name: ${person.hello:other}_多多
          age: 4
    

    然后运行测试:
    image-20200920112656038


    3. 对比回顾properties配置

    以上采用的yaml配置文件是最简单且最常用的方式;也是springboot所推荐的!

    接下来来对比一下默认的properties配置文件

    :properties配置文件在写中文的时候,会有乱码,我们需要去IDEA中设置编码格式为UTF-8;
    image-20200919173846087

    测试properties配置文件

    1、新建一个实体类User

    package com.zsr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.stereotype.Component;
    
    @Component
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        private String name;
        private int age;
        private String sex;
    }
    

    2、编辑配置文件 user.properties

    name=zsr
    

    3、我们在User类上使用@Value来进行注入!

    package com.zsr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    import org.springframework.beans.factory.annotation.Value;
    
    @Component
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @PropertySource(value = "classpath:user.properties")
    public class User {
        //直接使用@value()
        @Value("${user.name}")//从配置文件中取值
        private String name;
        @Value("#{9*2}")//SPEL表达式:@Value("#{表达式}")
        private int age;
        @Value("男") //纯量
        private String sex;
    }
    

    4、Springboot测试类测试

    package com.zsr;
    
    import com.zsr.pojo.Person;
    import com.zsr.pojo.User;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class Springboot02ConfigApplicationTests {
    
        @Autowired //将user自动注入进来
        private User user;
    
        @Test
        void contextLoads() {
            System.out.println(user); //打印看下person对象
        }
    
    }
    

    结果正常输出:
    image-20200920120742665

    对比小结

    image-20200920121117587

    1. @ConfigurationProperties只需要写一次即可,@Value则需要对每个字段都添加

    2. 松散绑定:比如我的yaml中写的 last-name,这个和 lastName 是一样的,- 后面跟着的字母默认是大写的,这就是松散绑定

    3. JSR303数据校验:可以在字段是增加一层过滤器验证,可以保证数据的合法性

    4. 复杂类型封装:yaml中可以封装对象,使用@value就不支持

    最佳实践

    • 配置 yaml 和配置 properties 都可以获取到值时,首荐 yaml;

    • 如果在某个业务中,只需要获取配置文件中的某个值,可以使用一下@value

    • 如果有编写的JavaBean来和配置文件进行一一映射,就直接@configurationProperties

    展开全文
  • Linux 网络配置文件

    万次阅读 多人点赞 2019-05-23 22:42:46
    一、网络配置文件 1.1 系统网络设备配置文件/etc/sysconfig/network-scripts ]# vim /etc/sysconfig/network-scripts/ifcfg-eth0 DEVICE=eth0 //表示网卡物理设备的名字 BOOTPROTO=dhcp //表示为网卡配置静态...

    一、网络配置文件

    1.1 系统网络设备配置文件/etc/sysconfig/network-scripts
    ]# vim /etc/sysconfig/network-scripts/ifcfg-eth0
    DEVICE=eth0 //表示网卡物理设备的名字
    BOOTPROTO=dhcp //表示为网卡配置静态还是动态IP地址(none:表示无须启动协议;bootp:表示使用BOOTP协议;
    dhcp :使用dhcp协议动态获取ip地址; static:表示手工设置静态IP地址)
    ONBOOT=yes //表示启动系统时是否激活网卡,yes为激活,no不激活
    TYPE=Ethernet //网络类型
    USERCTL=yes
    PEERDNS=yes
    IPV6INIT=no
    PERSISTENT_DHCLIENT=1
    HWADDR= //表示网卡的MAC地址
    GATEWAY = //表示该网关地址
    NETMASK //表示子网掩码
    IPADDR= //表示IP地址

    ]# systemctl restart network (重启服务)


    2、 /etc/resolv.conf 域名解析配置文件
    nameserver :表示解析域名使用该IP地址指定的主机为域名服务器;
    search : 表示DNS搜索路径


    3 、/etc/hosts 主机名匹配IP地址

    4 、/etc/networks 网络名和网络地址之间的映射关系
    ]# vim /etc/networks
    default 0.0.0.0
    loopback 127.0.0.0
    link-local 169.254.0.0


    5、 /etc/protocols 定义了主机使用的协议,及每个协议的协议号等相关信息
    ]# vim /etc/protocols

    6、/etc/services 定义了系统中所有服务的名称、协议类型、服务端口号等信息,该文件是一个服务名和服务端口号对应的数据库文件
    ]# vim /etc/services


    二 、Linux 网络命令
    2.1 traceroute 显示数据包到目标主机之间的路径,可以追踪网络数据包的路由途径
    命令语法:traceroute 【选项】 【主机名|IP地址】【数据包大小】
    -d 使用Socket层级的排错功能。
    -f<存活数值> 设置第一个检测数据包的存活数值TTL的大小。
    -F 设置勿离断位。
    -g<网关> 设置来源路由网关,最多可设置8个。
    -i<网络界面> 使用指定的网络界面送出数据包。
    -I 使用ICMP回应取代UDP资料信息。
    -m<存活数值> 设置检测数据包的最大存活数值TTL的大小。
    -n 直接使用IP地址而非主机名称。
    -p<通信端口> 设置UDP传输协议的通信端口。
    -r 忽略普通的Routing Table,直接将数据包送到远端主机上。
    -s<来源地址> 设置本地主机送出数据包的IP地址。
    -t<服务类型> 设置检测数据包的TOS数值。
    -v 详细显示指令的执行过程。
    -w<超时秒数> 设置等待远端主机回报的时间。
    -x 开启或关闭数据包的正确性检验。


    2.2 ifconfig 可以显示和配置网络接口,比如设置IP地址、MAC地址、激活或关闭网络接口。
    【ssh登陆linux服务器操作要小心,网卡关闭了就不能连接开启了,除非你有多网卡。】
    ifconfig 命令设置的网卡信息在系统重启后会失效。
    语法格式 :ifconfig 【接口】【选项|IP地址】
    up 启动指定网络设备/网卡。
    down 关闭指定网络设备/网卡。
    arp 设置指定网卡是否支持ARP协议。
    -promisc 设置是否支持网卡的promiscuous模式,如果选择此参数,网卡将接收网络中发给它所有的数据包
    -allmulti 设置是否支持多播模式,如果选择此参数,网卡将接收网络中所有的多播数据包
    -a 显示全部接口信息
    -s 显示摘要信息(类似于 netstat -i)
    add 给指定网卡配置IPv6地址
    del 删除指定网卡的IPv6地址
    mtu<字节数> 设置网卡的最大传输单元 (bytes)
    netmask<子网掩码> 设置网卡的子网掩码。
    tunel 建立隧道
    dstaddr 设定一个远端地址,建立点对点通信
    -broadcast<地址> 为指定网卡设置广播协议
    -pointtopoint<地址> 为网卡设置点对点通讯协议
    multicast 为网卡设置组播标志
    address 为网卡设置IPv4地址
    txqueuelen<长度> 为网卡设置传输列队的长度


    2.3 ping 测试与目标主机之间的连通性
    格式:ping 【选项】【目标】
    -t Ping 指定的计算机直到中断。  
    -a 将地址解析为计算机名。  
    -n count 发送 count 指定的 ECHO 数据包数。默认值为 4。 
    -l length 发送包含由 length 指定的数据量的 ECHO 数据包。默认为 32 字节;最大值是65,527。  
    -f 在数据包中发送"不要分段"标志。数据包就不会被路由上的网关分段。  
    -i ttl 将"生存时间"字段设置为 ttl 指定的值。  
    -v tos 将"服务类型"字段设置为 tos 指定的值。  
    -r count 在"记录路由"字段中记录传出和返回数据包的路由。count 可以指定最少 1 台,最多 9 台计算机。  
    -s count 指定 count 指定的跃点数的时间戳。  
    -j computer-list 利用 computer-list 指定的计算机列表路由数据包。连续计算机可以被中间网关分隔(路由稀疏源)IP 允许的最大数量为 9。  
    -k computer-list 利用 computer-list 指定的计算机列表路由数据包。连续计算机不能被中间网关分隔(路由严格源)IP 允许的最大数量为 9。  
    -w timeout 指定超时间隔,单位为毫秒。  
    destination-list 指定要 ping 的远程计算机。
    ——根据ping返回信息分析原因
    1.Request timed out :对方已关机;没有这个地址;对方与自己不在同一网段内;设置了ICMP数据包过滤(比如防火墙设置);错误设置IP地址。
    2.Destination host Unreachable :对方与自己不在同一网段内,而自己又未设置默认的路由;网线 出了故障;
    3.Bad IP address :可能没有连接到DNS服务器;可能是IP地址不存在。
    4.Source quench received : 表示对方或中途的服务器繁忙无法回应。
    5.Unknown host——不知名主机:可能是域名服务器有故障;或者网络管理员的系统与远程主机之间的通信线路有故障。
    6.No answer——无响应 :中心主机没有工作; 本地或中心主机网络配置不正确; 本地或中心的路由器没有工作; 通信线路有故障; 中心主机存在路由选择问题。
    7.Ping 127.0.0.1:127.0.0.1是本地循环地址 ——表明本地机TCP/IP协议不能正常工作。
    8.no rout to host:网卡工作不正常。
    9.transmit failed ,error code: 10043网卡驱动不正常。
    10.unknown host name:DNS配置不正确。


    2.4 netstat 用来显示网络状态的信息,如网络连接、路由表、接口统计、伪装连接和组播成员.
    可用于列出系统上所有的网络套接字连接情况,包括 tcp, udp 以及 unix 套接字,另外它还能列出处于监听状态(即等待接入请求)的套接字。(@@@常用的)
    格式:netstat 【选项】【延迟】
    -a或–all:显示所有连线中的Socket; @@@
    -A<网络类型>或–<网络类型>:列出该网络类型连线中的相关地址;
    -c或–continuous:持续列出网络状态; @@@
    -C或–cache:显示路由器配置的快取信息;
    -e或–extend:显示网络其他相关信息; (-i 和-e 搭配,可以输出用户友好的信息)
    -F或–fib:显示FIB;
    -g或–groups:显示多重广播功能群组组员名单; @@@
    -h或–help:在线帮助;
    -i或–interfaces:显示网络接口信息表单; @@@
    -l或–listening:显示监控中的服务器的Socket; @@@
    -M或–masquerade:显示伪装的网络连线;
    -n或–numeric:直接使用ip地址,而不通过域名服务器; @@@
    -N或–netlink或–symbolic:显示网络硬件外围设备的符号连接名称;
    -o或–timers:显示计时器;
    -p或–programs:显示正在使用Socket的程序识别码和程序名称; @@@
    -r或–route:显示Routing Table内核路由信息; @@@
    -s或–statistice:显示网络工作信息统计表;
    -t或–tcp:显示TCP传输协议的连线状况; @@@
    -u或–udp:显示UDP传输协议的连线状况;
    -v或–verbose:显示指令执行过程;
    -V或–version:显示版本信息;
    -w或–raw:显示RAW传输协议的连线状况;
    -x或–unix:此参数的效果和指定"-A unix"参数相同;
    –ip或–inet:此参数的效果和指定"-A inet"参数相同。


    2.5 arp 用来增加、删除和显示ARP缓存条目
    ARP是一个重要的TCP/IP协议,并且用于确定对应IP地址的网卡物理地址;
    输出结果中用"C"表示ARP缓存内容,"M"表示永久性表项,"P"表示公共的表项。
    格式:arp【选项】【IP地址】【MAC地址】
    arp: 显示所有的表项
    -d address: 删除一个arp表项。
    -s address hw_addr: 设置一个arp表项。
    -a 使用bsd形式输出。(没有固定的列)
    -n 使用数字形式显示ip地址,而不是默认的主机名形式。
    -D 不是指定硬件地址而是指定一个网络接口的名称,表项将使用相应接口的MAC地址。一般用来设置ARP代理。
    H type, --hw-type type: 指定检查特定类型的表项,默认type为ether,
    -i If, --device If: 指定设置哪个网络接口上面的arp表项。
    -f filename: 作用同’-s’,不过它通过文件来指定IP地址和MAC地址的绑定。

    展开全文
  • 1.ServletContext方式 采用ServletContext读取配置文件realpath,然后通过文件流读出来。 优点:可以读取任意位置的文件 采用文件流读取,所以可以读取不同格式的文件 缺点:不能在servlet外面读取配置文件 ...
  • Flink基础系列5-Flink 配置文件参数

    万次阅读 2021-10-14 14:18:17
    文章目录一.Flink配置文件概述1.1 基础配置1.2 高可用性配置1.3 容错和检查点 配置1.4 web 前端配置1.5 高级配置1.6 Flink 集群安全配置1.7 Zookeeper 安全配置1.8 HistoryServer1.9 masters1.10 slaves1.11 zoo.cfg...
  • Spring Boot实现加载自定义配置文件

    万次阅读 2020-09-20 10:56:34
    关注 “Java艺术” 我们一起成长!你好,我是吴就业,这是我的第170篇原创文章,欢迎阅读!或许你也发现了,在配置项多的情况下,application-xx.yml配置文件显得过于臃肿...
  • python 操作配置文件

    万次阅读 2020-05-04 07:10:40
    配置文件 一般程序都需要保存一些设置信息,比如字体大小,语言等等。这时候就不能讲配置写入到程序代码中,需要一个文件来保存读取这些配置信息,这个文件就是配置文件。 一般配置文件以ini文件形式存在,其内容...
  • springboot 配置文件以及自动配置

    万次阅读 2018-05-30 19:15:20
    1.springboot 默认配置文件 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;SpringBoot使用默认的全局的配置文件,application.properties / ...
  • 一、SpringBoot 激活多环境全局配置文件 在实际的的开发中,对于一个工程,经常配置很多个Profile(配置文件),每个Profile都对应一个完整的全局配置,例如开发环境(application-dev.properties)、测试环境...
  • SpringBoot配置文件简介

    千次阅读 2020-07-29 20:25:49
    我们在使用SSM框架的时候,各种配置文件,使得Spring在某一段时间里被称作“配置地狱”,后面为了更加简化,就出现了SpringBoot,SpringBoot帮助我们做了很多的事情,使得开发更加简化了。 下面就聊聊博主对于...
  • 一:什么是classpath? classpath指的就是 *.java文件,资源文件等编译后存放的位置,对于maven项目就是指 target/classes:这个路径,只要编译后的文件在这个目录下,...springboot项目配置文件application.pr...
  • SpringBoot配置文件加载顺序

    千次阅读 2020-01-01 14:08:25
    SpringBoot配置文件加载顺序
  • SpringBoot读取外部配置文件的方法

    万次阅读 2020-06-02 23:32:59
    点击上方「蓝字」关注我们1.SpringBoot配置文件SpringBoot使用一个以application命名的配置文件作为默认的全局配置文件。支持properties后缀结尾的配置文...
  • SpringBoot配置文件和修改端口

    万次阅读 2018-05-16 18:44:24
    但是我们发现简单版的 Spring Boot 项目没有配置文件,定制版的项目有一个配置文件application.properties,我们还可以发现有些Spring Boot的项目使用的是xml或者yml配置文件。 那么 到底怎么样修改相关配置和增加...
  • Maven Settings.xml国内资源配置文件 官方绿色版

    千次下载 热门讨论 2016-07-21 22:59:41
    maven国内资源资源配置以及nexus私服的配置fangs
  • 1. springboot支持动态的读取文件,扩展接口:org.springframework.boot.env.EnvironmentPostProcessor 我的项目使用场景起因是: 在同一台机器上起了两个tomcat实例, 每个项目的日志文件打印路径要配成不同, 如果每次...
  • Python读取配置文件(config.ini),写入配置文件

    万次阅读 多人点赞 2018-10-23 22:18:58
    一、读取配置文件 我的目录如下,在config下有一个config.ini配置文件 配置文件内容 # 定义config分组 [config] platformName=Android appPackage=com.romwe appActivity=com.romwe.SplashActivity # 定义cmd...
  • 在编程的某些情况下,我们需要读取jar包中的文件,这种情况要区别于我们平时使用类加载器读取配置文件,这个时候配置在jar包中,就能读取到,但是配置文件也可以不在jar包中,只要放在Class-Path下就行了,所以这种...
  • springboot项目实现jar包外配置文件管理

    万次阅读 多人点赞 2018-04-23 14:45:06
    假设项目以最常规的方式打包成一个整体的jar包部署,即配置文件和第三方依赖包都包含在jar包里,就会有如下两个问题问题一:项目运行过程中,要改动配置文件的话需要重新打包并部署。问题二:多个第三方依赖包都相.....
  • 读取核心配置文件application.properties和application.yml 在application.properties下添加如下代码 test.name=test test.age=22  配置实体类: 第一种: @Component//使用@Configuration也...
  • SpringBoot自定义配置文件(xxx.properties)

    万次阅读 多人点赞 2018-07-11 20:57:37
    转载 :https://www.cnblogs.com/V1haoge/p/7183408.htmlSpringBoot中免除了大部分手动配置,但是对于一些特定的情况,还是需要我们进行手动配置的,SpringBoot为我们提供了application.properties配置文件,让我们...
  • Java Web中的配置文件路径

    千次阅读 2018-09-27 11:47:48
    Java Web项目中配置文件的加载路径,普通类和Servlet的默认根路径有些不一样 1、配置文件方在src下,在普通class文件中加载 public String sayHello(String name) { String path = "config/jdbc_mysql....
  • 很多人都知道读取配置文件,这是初级做法,上升一点难度是使用java bean的方式读取自定义配置文件,但是大家很少有知道读取pom文件信息,接下来我都会讲到。 正文 笔者还是基于Spring Boot :: (v1.5.8.RELEASE),...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,332,523
精华内容 2,533,009
关键字:

怎么配置文件