build_buildroot - CSDN
精华内容
参与话题
  • Build和Rebuild的区别

    千次阅读 2019-05-22 00:49:22
    Build 只针对在上次编译之后更改过的文件进行编译, 而Rebuild会编译所有文件。 无论 Build 和 Rebuild,都可以分别针对解决方案和项目。 Rebuild 会编译所有文件,一般相当于执行 Clean + Build(清理并生成)。 ...
        
    1. Build 只针对在上次编译之后更改过的文件进行编译, 而Rebuild会编译所有文件。

    2. 无论 Build 和 Rebuild,都可以分别针对解决方案和项目。

    3. Rebuild 会编译所有文件,一般相当于执行 Clean + Build(清理并生成)。

    4. Build 编译的范围包括有更新的 Projects 以及依赖这些 Projects 的项目。

    5. Rebuild = Clean+Build

    6. 注意,Build 所检测的是项目中的改变,主要是源代码,而Rebuild则是简单粗暴的Clean+Build。

    在此做了一个简单的实验,在debug文件夹下删除一个配置文件,可以看出bulid是不会生成该配置文件的, rebuild却可以。


    2789632-6e79709c12e8395e.gif
    2789632-ea7abbec1389a5dd.png

    2789632-2c733460924dddd8.png
    展开全文
  • Maven build之pom.xml文件中的Build配置

    万次阅读 多人点赞 2018-03-28 14:58:43
    maven是什么,用通俗的话来将,maven能帮你构建工程,管理jar包,编译代码,还能帮你自动运行单元测试,打包,生成报表,甚至能帮你部署项目使用maven构建的项目均可以直接使用maven build完成项目的编译测试打包,...
    前言

    在阅读详细文档之前我们先来谈谈我自己对maven的一些个人理解,以助于从整体大局上了解maven。
    • maven是什么,用通俗的话来将,maven能帮你构建工程,管理jar包,编译代码,还能帮你自动运行单元测试,打包,生成报表,甚至能帮你部署项目
    • 使用maven构建的项目均可以直接使用maven build完成项目的编译测试打包,无需额外配置
    • Maven是通过pom.xml来执行任务的,其中的build标签描述了如何来编译及打包项目,而具体的编译和打包工作是通过build中配置的 plugin 来完成。当然plugin配置不是必须的,默认情况下,Maven 会绑定以下几个插件来完成基本操作。
    即在没有配置的情况下,执行mvn clean install时,maven会调用默认的plugin来完成编译打包操作,具体来讲,执行mvn clean install时会执行
    maven-clean-plugin:2.5:clean (default-clean)
    maven-resources-plugin:2.6:resources (default-resources)
    maven-compiler-plugin:3.1:compile (default-compile)
    maven-resources-plugin:2.6:testResources (default-testResources)
    maven-compiler-plugin:3.1:testCompile (default-testCompile)
    maven-surefire-plugin:2.12.4:test (default-test)
    maven-jar-plugin:2.4:jar (default-jar)
    maven-install-plugin:2.4:install (default-install)
    等plugin
    • 4.如果有需要可以针对各个 plugin 进行特殊配置,需要在pom.xml中的<plugins>标签中显示指定 plugin 和 属性配置。

    如上配置了maven-compiler-plugin的版本和编译时使用的jdk版本

    POM.XML的build标签
    在Maven的pom.xml文件中,Build相关配置包含两个部分,一个是<build>,另一个是<reporting>,这里我们只介绍<build>。

    1.pom.xml中的两种build
    在Maven的pom.xml文件中,存在如下两种<build>:

    说明:
    一种<build>被称为Project Build,即是<project>的直接子元素。另一种<build>被称为Profile Build,即是<profile>的直接子元素。
    Profile Build包含了基本的build元素,而Project Build还包含两个特殊的元素,即各种<...Directory>和<extensions>。

    2.Profile Build和Project Build的共有元素
    1) 共用的基本build元素
    示例如下:

    说明:
    • defaultGoal,执行构建时默认的goal或phase,如jar:jar或者package等
    • directory,构建的结果所在的路径,默认为${basedir}/target目录
    • finalName,构建的最终结果的名字,该名字可能在其他plugin中被改变

    2) <resources>
    资源往往不是代码,无需编译,而是一些properties或XML配置文件,构建过程中会往往会将资源文件从源路径复制到指定的目标路径。
    <resources>给出各个资源在Maven项目中的具体路径。示例如下:

    说明:
    • resources,build过程中涉及的资源文件
    • targetPath,资源文件的目标路径
    • filtering,构建过程中是否对资源进行过滤,默认false
    • directory,资源文件的路径,默认位于${basedir}/src/main/resources/目录下
    • includes,一组文件名的匹配模式,被匹配的资源文件将被构建过程处理
    • excludes,一组文件名的匹配模式,被匹配的资源文件将被构建过程忽略。同时被includes和excludes匹配的资源文件,将被忽略。
    • filters,给出对资源文件进行过滤的属性文件的路径,默认位于${basedir}/src/main/filters/目录下。属性文件中定义若干键值对。在构建过程中,对于资源文件中出现的变量(键),将使用属性文件中该键对应的值替换。
    • testResources,test过程中涉及的资源文件,默认位于${basedir}/src/test/resources/目录下。这里的资源文件不会被构建到目标构件中

    3) <plugins>
    <plugins>给出构建过程中所用到的插件。

    说明:
    • groupId
    • artifactId
    • version
    • extensions,是否加载该插件的扩展,默认false
    • inherited,该插件的configuration中的配置是否可以被(继承该POM的其他Maven项目)继承,默认true
    • configuration,该插件所需要的特殊配置,在父子项目之间可以覆盖或合并
    • dependencies,该插件所特有的依赖类库
    • executions,该插件的某个goal(一个插件中可能包含多个goal)的执行方式。一个execution有如下设置:
    • id,唯一标识
    • goals,要执行的插件的goal(可以有多个),如<goal>run</goal>
    • phase,插件的goal要嵌入到Maven的phase中执行,如verify
    • inherited,该execution是否可被子项目继承
    • configuration,该execution的其他配置参数
    4) <pluginManagement>
    在<build>中,<pluginManagement>与<plugins>并列,两者之间的关系类似于<dependencyManagement>与<dependencies>之间的关系。<pluginManagement>中也配置<plugin>,其配置参数与<plugins>中的<plugin>完全一致。只是,<pluginManagement>往往出现在父项目中,其中配置的<plugin>往往通用于子项目。子项目中只要在<plugins>中以<plugin>声明该插件,该插件的具体配置参数则继承自父项目中<pluginManagement>对该插件的配置,从而避免在子项目中进行重复配置。

    3. Project Build特有的<...Directory>
    往往配置在父项目中,供所有父子项目使用。示例如下:

    目录可以使用绝对路径,如示例所示。如果使用相对路径,则所有的相对路径都是在${basedir}目录下。

    4. Project Build特有的<extensions>
    <extensions>是执行构建过程中可能用到的其他工具,在执行构建的过程中被加入到classpath中。
    也可以通过<extensions>激活构建插件,从而改变构建的过程。
    通常,通过<extensions>给出通用插件的一个具体实现,用于构建过程。
    <extensions>的使用示例如下:


    ==================================================================
    ****************************** maven默认的输入输出目录 ************************************
    ==================================================================


    构建Maven项目的时候,如果没有进行特殊的配置,Maven会按照标准的目录结构查找和处理各种类型文件。

    src/main/java和src/test/java 
    这两个目录中的所有*.java文件会分别在comile和test-comiple阶段被编译,编译结果分别放到了target/classes和targe/test-classes目录中,但是这两个目录中的其他文件都会被忽略掉。
    src/main/resouces和src/test/resources
    这两个目录中的文件也会分别被复制到target/classes和target/test-classes目录中。

    当是web项目时,会在target下生成myproject目录,myproject是你的项目名
    src/main/webapps
    这个目录中的文件会被复制到target/myProject目录中
    target/classes
    默认会把这个目录中的所有内容复制到target/myProject/WEB-INF/classes目录中
    Dependency
    默认会将项目的依赖复制到target/myProject/WEB-INF/lib




    展开全文
  • 设计模式—build模式

    万次阅读 2017-12-29 07:56:55
    简介Builder模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦,使得构建过程和部件的表示...

    简介

    Builder模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦,使得构建过程和部件的表示隔离开来,两者之间的耦合度也降到最低。

    定义

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

    使用场景

    1.相同的方法,不同的执行顺序,产生不同的事件结果。(View的封装,对外暴露的方法不同)

    2.多个部件或零件,都可以装配到一个对象中,但是产生的运行结果又不相同时

    3.产品类非常复杂,或者产品类中的调用顺序不同产生了不同的作用

    4.初始化一个对象特别复杂,如参数特别多且很多都具有默认参数时

    关键点

    原始版-四个角色

    一个产品类—需要被构建的产品

    一个抽象Build类—隔离产品组件的构建

    一个具体构建产品的Build实现类—产品组件的具体构建

    一个组装类—组件与产品的组装

    简易版—两个角色

    一个产品类—需要被构建的产品

    一个Builder类—一般为产品类的静态内部类,负责组件的具体构建和产品的组装

    实现

    例:

    原始版

    /**
     * 产品类-Computer
     */
    public class Computer {
    
        private String mBoard;
        private String mDisplay;
        private String mOS;
    
        public String getmBoard() {
            return mBoard;
        }
    
        public void setmBoard(String mBoard) {
            this.mBoard = mBoard;
        }
    
        public String getmDisplay() {
            return mDisplay;
        }
    
        public void setmDisplay(String mDisplay) {
            this.mDisplay = mDisplay;
        }
    
        public String getmOS() {
            return mOS;
        }
    
        public void setmOS() {
            this.mOS = mOS;
        }
    }
    /**
     * 抽象Build类-构建与产品类相关的部件
     */
    public abstract class Builder {
    
        /**
         *构建主机组件
         */
        public abstract void setBoard(String board);
    
        /**
         * 构建显示器组件
         */
        public abstract void setDisplay(String display);
    
        /**
         * 构建操作系统组件
         */
        public abstract void setOs();
    
        /**
         * 构建产品
         */
        public abstract Computer create();
    }
    /**
     * 抽象Build的实现类-真正构建产品的类
     */
    public class ComputerBuilder extends Builder {
    
        private Computer computer = new Computer();
    
        @Override
        public void setBoard(String board) {
            computer.setmBoard(board);
        }
    
        @Override
        public void setDisplay(String display) {
            computer.setmDisplay(display);
        }
    
        @Override
        public void setOs() {
            computer.setmOS();
        }
    
        @Override
        public Computer create() {
            return computer;
        }
    }
    /**
     * 组装类:将builder构建的产品部件组装成产品,对外隐藏内部组装细节
     */
    public class Director {
    
        private Builder mBuilder;
    
        public Director(Builder builder) {
            this.mBuilder = builder;
        }
    
        public void construct(String board, String display) {
            mBuilder.setBoard(board);
            mBuilder.setDisplay(display);
            mBuilder.setOs();
        }
    }

    使用

    Builder builder = new ComputerBuilder();
            Director director = new Director(builder);
            director.construct("因特尔主板", "三星显示器");
            Computer computer = builder.create();

    简易版

    `/**
    * 产品类-Computer
    */
    public class Computer {

    private String mBoard;
    private String mDisplay;
    private String mOS;
    
    public String getmBoard() {
        return mBoard;
    }
    
    public void setmBoard(String mBoard) {
        this.mBoard = mBoard;
    }
    
    public String getmDisplay() {
        return mDisplay;
    }
    
    public void setmDisplay(String mDisplay) {
        this.mDisplay = mDisplay;
    }
    
    public String getmOS() {
        return mOS;
    }
    
    public void setmOS() {
        this.mOS = mOS;
    }
    
    
    public static class Builder {
    
        private String mBoard;
        private String mDisplay;
        private String mOS;
    
        public Builder setBoard(String board) {
            this.mBoard = board;
            return this;
        }
    
        public Builder setDisplay(String display) {
            this.mDisplay = display;
            return this;
        }
    
        public Builder setOs() {
            return this;
        }
    
        /**
         * 组装产品
         */
        private void construct(Computer computer) {
            computer.setmBoard(mBoard);
            computer.setmDisplay(mDisplay);
            computer.setmOS();
        }
    
        public Computer create() {
            Computer computer = new Computer();
            construct(computer);
            return computer;
        }
    }
    
    使用
    Computer computer = new Computer.Builder().setBoard("")
                    .setDisplay("")
                    .setOs()
                    .create();

    小结

    Builder模式通常作为配置类的构建器将配置的构建和表示分离开来,同时也是将配置从目标类中隔离出来,避免作为过多的setter方法。Builder模式比较常见的实现形式是通过链式调用,这样使得代码更加简洁、易懂。

    优点:

    1.良好的封装性,使用建造者模式可以使客户端不必知道产品内部组成的细节

    2.建造者独立,容易扩展

    缺点:

    会产生多余的Builder对象以及Director对象,消耗内存。

    展开全文
  • build和compile的区别[编程语言]

    万次阅读 2012-08-27 19:21:05
    最近想到一个问题,在写完代码之后运行之前需要编译一下,但是还有一个build功能,这两个到底有没有区别呢? 网上查了一下,buid比compile强大一点。运行的时候就知道,时间是不一样的。有人用过下面的方程式:...

    最近想到一个问题,在写完代码之后运行之前需要编译一下,但是还有一个build功能,这两个到底有没有区别呢?


    网上查了一下,buid比compile强大一点。运行的时候就知道,时间是不一样的。有人用过下面的方程式:

      BUILD = COMPILE   +   LINK   =   RESULT   IS   EXE  
      COMPILE   =   COMPILE   =   RESULT   IS   DCU

    不管这个说法对不对,但是build确实比compile做的要多啊,build付出的不亚于compile啊。

    下面简单看下大家对这两个的区别的看法:

    Build是从新编译所有和生成exe有关的文件,无论.pas文件是否修改过,它都会重新生成新的.dcu,并从新链接这些.dcu等等文件。   

    Compile是编译修改过的文件,它只生成新修改过的.pas的相应的.dcu,并从新链接这些改变过的.dcu等等文件。

    如果你感兴趣,还可以看下borland的官方解释吧:


    Use Project|Compile project to compile all files in the current project that have changed since the last build into a new executable file,. dynamic link library (.DLL), resource file (.RES), or so on. This command is similar to the Build command, except that Project|Compile builds only those files that have changed since the last compile, whereas Build rebuilds all files whether they have changed or not. 


    If you checked Show Compiler Progress from the Preferences page on the Tools|Environment Options dialog box, the Compiling dialog box displays information about the compilation progress and results. When your application successfully compiles, choose OK to close the Compiling dialog box.


    If the compiler encounters an error, the product reports that error on the status line of the Code editor and places the cursor on the line of source code containing the error. 


    The compiler builds executable files according to the following rules: 


    The project (.dpr) file is always recompiled.
    If the source code of a unit has changed since the last time the unit was compiled, the unit is compiled. When a unit is compiled, the product creates a file with a .dcu extension for that unit.


    If Delphi cannot locate the source code for a unit, that unit is not recompiled.


    If the interface part of a unit has changed, all the other units that depend on the changed unit are recompiled.
    If a unit links in an object file (external routines), and the object file has changed, the unit is recompiled.
    If a unit contains an Include file. and the Include file has changed, the unit is recompiled.


    You may choose to compile only portions of your code if you use conditional directives and predefined symbols in your code.








    Choose Build from the Project Manager Project context menu to rebuild all the components of your project regardless of whether they have changed.


    This command is similar to Make except that Build rebuilds everything whereas Make rebuilds only those files that have been changed since the last build. 


    Tip: This command is useful when you are unsure of exactly which files have or have not been changed, or when you simply want to ensure that all files are current and synchronized. It抯 also important to Build all files in a project when you抳e changed global compiler directives or compiler options, to ensure that all code compiles in the proper state.
    Note: This command works the same as Project|Build project.
    Tip: If you have multiple projects within a project group, you can make all projects within a project group by using the Project|Compile All Projects command.

    展开全文
  • build

    2019-09-24 07:05:16
    总的build``` // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { repositories { google() jcenter() } dependencies { classpath 'c...
  • Build

    2019-06-23 17:21:22
    public class Build { //当一个版本属性不知道时所设定的值。 public static final String UNKNOWN = "unknown"; //修订版本列表码 public static final String ID = getString("ro.build.id"); //显示屏参数 ...
  • build.gradle详解

    万次阅读 多人点赞 2018-01-16 17:08:00
    简述: 1 > java开发中有两个大名鼎鼎的项目构建ANT、Maven。 2 > Google推荐使用的Android Studio是采用Gradle来构建项目的。Gradle是一个非常先进的项目构建工具。 Gradle是用了一种基于Groovy的领域特定语言...
  • cnpm重新安装一遍image-webpack-loader
  • 今天jenkins构建时运行脚本报错如下: ...Build step 'Execute shell' marked build as failure 脚本是问题后来看了下原因是磁盘空间不足导致报错,清除下空间构建就正常了 ,虚惊一场!!  ...
  • Eclipse没有Build Path 的解决方法

    万次阅读 多人点赞 2018-01-10 21:19:00
    如果Project Explorer右键没有build path Window ->show view 选择package explorer
  • 项目合并后jenkins打包报错。 code ELIFECYCLE npm ERR!...vue-element-admin@3.6.6 build:sit: `cross-env NODE_ENV=production env_config=sit node build/build.js` npm ERR! Exit status 1 npm ERR! npm...
  • 使用Android Studio导入GitHub上面的开源项目时,出现上述的报错。在网上找了些资料[1][2],但是自己是win10,就没有尝试安装submodule init。后来发现一个新帖子[3],尝试后成功了。 其实这个错误非常简单,你的...
  • CMAKE 设置Build Type (Debug/Release)

    万次阅读 2014-11-24 11:36:11
    原来以为可以在 CMak eLists.txt中做如下设置:
  • Ubuntu的build-essential有什么作用

    万次阅读 2018-08-08 20:58:20
    但是如果单独安装gcc以及g++比较麻烦,幸运的是,Ubuntu提供了一个build-essential软件包。查看该软件包的依赖关系: y@ubuntu:~$ apt-cache depends build-essential build-essential |Depends: libc6-dev ...
  • missing script: build,后来发现package.json中scripts参数为 "scripts": { "dev": "vue-cli-service serve", "build:prod": "vue-cli-service build", "build:stage": "vue-cli-service build --mode stag...
  • IntelliJ IDEA如何build path

    万次阅读 2019-10-24 15:59:53
    File -> Project Structure -> Modules -> 选中要添加build path的项目 -> Dependencies -> 点击右边的小加号 ->选择JARs or directories ->选择要添加的外部jar包。 ...
  • Build step 'Execute shell' marked build as failure 1.磁盘空间不足导致报错。 2.请在“Execute shell”构建步骤中添加以下行。 #!/bin/bash 默认情况下,Jenkins采取/bin/sh -xe这种方式-x将打印每一个命令...
  • 解决 Configure build 下载慢的问题

    万次阅读 2018-10-18 15:09:17
    build.gradle 文件加入下面代码即可 buildscript { repositories { maven{ url 'http://maven.aliyun.com/nexus/content/groups/public/'} google() } } allprojects { repositories { ...
  • 修改 build.gradle在项目的 build.gradle 里面设置,注意有两个build.gradle,最好都注意一下。把build.gradle里面的版本改为自己能运行的工程里面版本号。android { compileSdkVersion 22 buildToolsVersion "23
  • maven install与maven build的区别

    万次阅读 2017-08-16 14:57:37
    没有 mvn build这个命令。只有mvn install 和 mvn packagemvn install 是将你打好的jar包安装到你的本地库中,一般没有设置过是在 用户目录下的 .m2\下面。mvn package 只是将你的代码打包到输出目录,一般的是 ...
1 2 3 4 5 ... 20
收藏数 1,615,748
精华内容 646,299
关键字:

build