当前位置: 澳门新濠3559 > 编程 > 正文

spring自己说它是一个轻量级的框架,其实当你了

时间:2019-10-06 23:54来源:编程
gradle是构建工具,类似于ant和maven,也许目前maven还是主流,但是gradle却是综合了ant和maven的优点,发展速度很快,所以很有必要了解一下。 简介 ApacheMaven是一个软件项目管理和理解工具

gradle是构建工具,类似于ant和maven,也许目前maven还是主流,但是gradle却是综合了ant和maven的优点,发展速度很快,所以很有必要了解一下。

简介

Apache Maven是一个软件项目管理和理解工具。基于项目对象模型(POM)的概念,Maven可以从一个中央信息管理项目的构建,报告和文档的软件项目管理工具。

Apache Maven一个潜在的基于java的Apache Ant的构建工具的替代者。ant脚本是可以直接运行在maven中的。maven和ant最大的差别就是在于maven的编译以及所有的脚本都有一个基础,就是POM(project object model),这个模型定义了项目的方方面面,然后各式各样的脚本在这个模型上工作,而ant完全是自己定义。

Maven它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期,一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

Maven主要做的是两件事:

  • 1.统一开发规范与工具

  • 1.统一管理jar包

最近开始学习SpringBoot,其实个人感觉SpringBoot并不是什么新的技术,Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。也就是说其实SpringBoot只是在Spring原有技术上组合而成,为了让开发人员快速搭建以及开发的一套框架而已(就好像Docker与容器技术一样)。

什么是springboot?

 笔者喜欢以“貌”取人,从字面意思上得到spring可能要booter化了*)

联想到java的bootstrap classloader,这里你不得不产生对它的向往了。当然springboot是这样作自我介绍的:“使用我,可以快速的搭建一个完整的spring应用”,以前在学习spring时,spring自己说它是一个轻量级的框架,可是在开发时 每次都要配置这么多的xml 并没有人让觉觉轻量级。当然这么理解是有问题的,spring两个核心IOC和Aop支撑起来这个框架。以及后来陆陆续续家族越来越强大,当然今天这个家族成员springboot 是非常让人激动的产品,springboot = spring*。在如今应用服务化的时代下,springcloud也足够让人惊艳,笔者之前很崇拜dubbo,很强大的RPC框架,对比这后springcloud有更强大的存在。今天主角是springboot。当然,springboot与springcloud亦是天作之合。

gradle是自动化开源构建工具,使用一种基于groovy的特定领域语言来声明项目设置。当前仅支持Java、groovy、kotlin和Scala。

Maven的安装

其实学习SpringBoot,我们首先一定要了解SpringBoot遵循的一个原则COC:约定优于配置(convention over configuration),也称作按约定编程,是一种软件设计范式,旨在减少软件开发人员需做决定的数量,获得简单的好处,而又不失灵活性。

springboot vs sping*

springboot 秉承着约定大于配置的思想成功的吸引了众多的开发者。

ssm结构是如今用的挺多的结构。非常的方便,配置spring的上下文有点太机械化了,而且对于web项目来讲tomcat的部署也是必须的还有 每次maven或gradle中依赖密密麻麻的jar包,在springboot中一切都是可以优化的。springboot 秉承着约定大于配置的思想成功的吸引了众多的开发者。今天笔者就简单的做一个springboot项目的例子

1、下载gradle:到gradle官网下载gradle:

安装maven超级简单,总共分三步:

- 下载 Maven ,其实就是一个压缩包,解压一下。下载地址

澳门新濠3559 1

image.png

1、bin目录

包含了mvn运行的脚本,bat结尾的是windows批处理脚本

2、boot目录

只有一个文件 plexus-classworlds-2.5.2.jar,是一个类加载器框架,Maven使用他加载自己的类库。

3、conf目录

settings.xml 文件

4、lib目录

Maven运行时需要的Java类库

- 配置一下环境变量

有两个环境变量可以配置:

MAVEN_HOME = 你自己的Maven安装地址
在path变量末尾加入“%MAVEN_HOME%bin;”

澳门新濠3559 2

image.png

如果想让 Maven 跑得更快点,可以根据自己的情况来设置 MAVEN_OPTS

MAVEN_OPTS = -Xms128m -Xmx512m(可选)

- 最后,验证是否安装成功

现在我们打开 cmd,输入:

mvn -v

澳门新濠3559 3

image.png

Maven 安装成功!

其实当你了解了SpringBoot的目的,以及核心思想,那么工程的搭建也就水到渠成了。(学习一门新的技术,一定要了解其历史,发展,以及目的等等,你将受益匪浅)。

IDEA+maven 构建

澳门新濠3559 4image.png

spring自己说它是一个轻量级的框架,其实当你了解了SpringBoot的目的。了解Maven仓库

使用 Maven 给我们带来的最直接的好处,就是统一管理jar 包,那么这些 jar 包存放在 本地仓库 中,默认地址位于 C:Users用户名.m2 目录下(当然也可以修改这个默认地址,当我们第一次输入mvn -v ,maven会在用户目录创建一个.m2的目录,这个是maven的本地仓库。)

我们可以将本地仓库理解“缓存”,目的是存放jar包。开发项目时项目首先会从本地仓库中获取 jar 包,当无法获取指定 jar 包的时候,本地仓库会从 远程仓库(或 中央仓库) 中下载 jar 包,并“缓存”到本地仓库中以备将来使用。

远程仓库(中央仓库)是 Maven 官方组织公布在互联网上的一个站点,里面收录了目前绝大多数主流的jar包,可通过 http://search.maven.org/ 来访问。这样一来,本地仓库会随着项目的积累越来越大。

澳门新濠3559 5

image.png

澳门新濠3559 6

image.png

Nexus是Maven仓库管理器,也可以叫Maven的私服,搭建私服可以加快构建速度,减少节省外网带宽。

进入正题,接下来就随我开始搭建一个SpringBoot项目。
首先大家要准备一些基础环境:

①新建一个maven web项目

澳门新濠3559 7maven工程.png

2、解压:把下载的压缩包解压即可。

修改本地仓库位置配置

本地仓库,在执行第一次mvn -v是会默认在用户文件夹生成.m2文件夹,我们可以通过maven的安装目录下面的conf文件夹里面的settings.xml来改变

澳门新濠3559 8

image.png

依据该配置,Maven就会将下载的类库保存到D:mavenrepository中

为了保持核心的配置文件不变,我们可以将settings.xml文件拷贝到.m2目录下面。以后只要对这个文件做修改就可以了,maven会优先读取.m2下面的配置文件。(可选)

  • jdk和jre(本教程使用java8)
  • idea(下载地址https://www.jetbrains.com/idea/),我们使用社区版即可,因为商业版是收费的。
  • gradle(本教程项目构建采用gradle4.3.1,下载地址https://gradle.org/,需要配置环境变量(百度一下便知))。
②编辑pom添加依赖
<?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> <groupId>is.jack.boots</groupId> <artifactId>boot</artifactId> <version>1.0-SNAPSHOT</version> <!--添加springboot的家族长老 ^_^ 方便管理依赖版本 以及后续支持数据持久化 缓存 模板引擎 中间件等等--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.8.RELEASE</version> </parent> <!-- springboot 依赖核心 一个jar包 包罗众多spring 组件 以及 tomcat --> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <properties> <java.version>1.8</java.version> </properties> <!-- maven spring 插件 用于maven打包管理 以及maven命令化springboot --> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build></project>

3、配置环境变量:新建系统变量GRADLE_HOME指向grade解压后的目录,在path中添加%GRADLE_HOME%bin,然后再cmd输入gradle -v,出现版本号则配置成功。如果没用,运行一下gradle的bin目录里面的gradle.bat,再输入gradle -v

澳门新濠3559,Eclipse的Maven项目

有了上面的准备之后,我们正式进入SpringBoot的世界。首先我们进入SpringBoot的官方首页https://projects.spring.io/spring-boot/ 如下图所示。

③启动项目
对呀!以上两部就完成项目的配置了.now,你只需要启动项目就行

以往的spring项目都得deployed成war包 然后发布到tomcat中去。而springboot-starter-web jar包中有以下结构

澳门新濠3559 9image.png

传统的spring的 bean,context,aop,web,mvc,core,slf4j加上tomcat,jackson等统统一网打进。这是springboot 第一处强大的地方接着 回到正题启动它 新建一个启动入口(新建一个main入口)

package io.entry;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Bean;import java.util.Arrays;@SpringBootApplicationpublic class Excute { public static void main(String[] args){ //这里执行结束,项目就启动了 下面的被@Bean的方法可以根据自己需求添加 SpringApplication.run(Excute.class,args); } @Bean public CommandLineRunner commandLineRunner(ApplicationContext ctx) { //传统spring项目中监听组件使用的是ApplicationListener //在springboot中使用的是CommandLineRunner 并且这个会自动帮你添加springboot中的组件 // -> java8 中新增的表达式 lamuda ps: java是不会眼睁睁的看着让其他简洁的语言随便超越, //所以java出的一些新特性也是值得关注的,顺便消化一下 return args -> { System.out.println("我可以打印出springboot 所用的组件或模块了"); String[] beanNames = ctx.getBeanDefinitionNames(); Arrays.sort(beanNames); for (String beanName : beanNames) { System.out.println; } }; }}

建立一个REST风格的controller

什么是REST ?你经常会用到ajax吧,使用一个uri请求的到了一个son或xml等等的数据。ok,这就是REST风格,而不是你经常使用的MVC中向你返回一个view。回到这里 REpresentation State Transfer 资源表属性转移 就是REST,他是一种架构约束。

package io.entry;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;//@RestController相当于 @RequestMapping   @Responsebody@RestControllerpublic class Controller { @RequestMapping public String tr(){ return "hello springboot!"; }}

执行main方法 启动了该项目

澳门新濠3559 10image.png

澳门新濠3559 11image.png

Eclipse安装Maven

打开eclipse,菜单“Help”-“Install New Software...”
在Work with 地址栏输入:http://download.eclipse.org/releases/oxygen (注意:oxygen是eclipse对应的版本名称),稍等片刻

澳门新濠3559 12

image.png

澳门新濠3559 13

③使用springboot maven插件执行项目

在终端输入 mvn package target/boot-1.0-SNAPSHOT.jar 将项目打成jar包再输入 java -jar target/boot-1.0-SNAPSHOT.jar 这里springboot maven 插件会自动找到main函数执行 springboot 当然上述操作完成后 开启工程还有个方法

1、gradle插件的安装:help --> eclipse marketplace --> 输入gradle搜索 --> install,如下图:

配置Maven

Window --> Preferences

澳门新濠3559 14

image.png

点击 Add 按钮,添加本地 maven 的安装路径值

澳门新濠3559 15

image.png

点击 Browse 按钮,选到你 maven 的 setting.xml 配置文件

澳门新濠3559 16

image.png

image.png

使用操作系统终端(windows 是cmd)

打开终端进入你的工程路径里 输入 mvn spring-boot:run

澳门新濠3559 17image.png

澳门新濠3559 18image.png

Eclipse的创建 Maven项目

选择新建项目,下载Maven项目

澳门新濠3559 19

image.png

澳门新濠3559 20

image.png

groupId、artifactId、version确定一个唯一的Maven

澳门新濠3559 21

image.png

1、groupId

顾名思义,这个应该是公司名或是组织名。一般来说groupId是由三个部分组成,每个部分之间以"."分隔,第一部分是项目用途,比如用于商业的就是"com",用于非营利性组织的就  是"org";第二部分是公司名,比如"tengxun"、"baidu"、"alibaba";第三部分是你的项目名

2、artifactId

可以认为是Maven构建的项目名,比如你的项目中有子项目,就可以使用"项目名-子项目名"的命名方式

3、version

版本号,SNAPSHOT意为快照,说明该项目还在开发中,是不稳定的版本。在Maven中很重要的一点是,groupId、artifactId、version三个元素生成了一个Maven项目的基本坐标,这非常重要,我在使用和研究Maven的时候多次感受到了这点。

4、packing

项目打包的类型,可以使jar、war、rar、ear、pom,默认是jar

澳门新濠3559 22

image.png

大家可以浏览一下,本次我们使用SpringBoot官方提供的快速项目构建脚手架SpringBoot-CLI(下载地址https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started)。

浏览器测试

澳门新濠3559 23简单的REST测试.png

今天完成了springboot的初次体验,相信很多的开发者会对它产生了很不错的印象,往后的几次将持续更新springboot 系列。

2、配置gradle:window --> preference --> gradle:

Maven项目的标准目录

src
  -main
      –bin   脚本库
      –java java源代码文件
      –resources 资源库,会自动复制到classes目录里
      –filters 资源过滤文件
      –assembly 组件的描述配置(如何打包)
      –config 配置文件
      –webapp web应用的目录。WEB-INF、css、js等
  -test
      –java 单元测试java源代码文件
      –resources 测试需要用的资源库
      –filters 测试资源过滤库
  -site Site(一些文档)
target
 -classes 项目主体输出目录
 -test-classes项目测试输出目录
 -site   项目site输出目录

工程根目录下就只有src和target两个目录

target是有存放项目构建后的文件和目录,jar包、war包、编译的class文件等
target里的所有内容都是maven构建的时候生成的

澳门新濠3559 24

image.png

框中的src/main/javasrc/test/java还有src/main/resourcessrc/test/resources其实就是src里面的内容,只是为了开发方便调试,引用出来。

澳门新濠3559 25

澳门新濠3559 26image.png

Maven pom.xml配置详解

新建的maven项目的pom.xml配置如下:

澳门新濠3559 27

image.png

image.png

1、eclipse新建gradle项目:比如我们新建springboot项目想用gradle构建,如下图选择gradle就行:

POM基础

1.Maven的声明
2.POM的关系,依赖,继承,模块, 属性
3.构建
4.报告
5.项目详细信息
6.环境设置

Maven命令

  1. 创建Maven的普通java项目:
    mvn archetype:create -DgroupId=packageName -DartifactId=projectName
  2. 创建Maven的Web项目:
    mvn archetype:create -DgroupId=packageName -DartifactId=webappName-DarchetypeArtifactId=maven-archetype-webapp
  3. 编译源代码: mvn compile
  4. 编译测试代码:mvn test-compile
  5. 运行测试:mvn test
  6. 产生site:mvn site
  7. 打包:mvn package
  8. 在本地Repository中安装jar:mvn install
  9. 清除产生的项目:mvn clean
  10. 生成eclipse项目:mvn eclipse:eclipse
  11. 生成idea项目:mvn idea:idea
  12. 组合使用goal命令,如只打包不测试:mvn -Dtest package
  13. 编译测试的内容:mvn test-compile
  14. 只打jar包: mvn jar:jar
  15. 只测试而不编译,也不测试编译:mvn test -skipping compile -skipping test-compile
    ( -skipping 的灵活运用,当然也可以用于其他组合命令)
  16. 清除eclipse的一些系统设置:mvn eclipse:clean

POM的关系补充说明

parent <relativePath/>
父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。
parent使用dependencyManagement定义依赖关系
继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述groupID和artifactID信息),如果groupID和artifactID以外的一些信息没有描述,则通过groupID和artifactID匹配到这里的依赖,并使用这里的依赖信息。<dependencyManagement><dependencies><dependency>......</dependency></dependencies></dependencyManagement>
modules <modules/>
模块是这个POM列出的项目,并作为一个组来执行,不需要考虑模块间依赖关系。一个POM打包的项目可以通过将它们列为模块来集合一组项目的构建,这些模块是目录的相对路径或这些项目的POM文件。 (Ps:继承和模块的区别:继承父不知子,但子知父。模块父知子,但子不知父。所以在具体的项目中一般都是继承和模块融合使用)
properties <properties/> <properties> <someVar>值</ someVar> </ properties>的值作为$ {someVar}
Maven属性是值占位符,就像Ant中的属性一样。它们的值可以在POM中的任何地方通过使用符号${properties}来访问,或者它们可以被插件用作默认值

 <!-- 声明 -->
<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>

  <!-- POM的关系 -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <!--依赖性 -->
  <dependencies>...</dependencies>
  <!--父项目 -->
  <parent>...</parent>
  <!-- 依赖信息定义 -->
  <dependencyManagement>...</dependencyManagement>
  <!-- 模块 -->
  <modules>...</modules>
  <!-- 依赖的分类器 -->
  <classifier>...</classifier>
  <!-- 为pom定义一些常量 -->
  <properties>...</properties>

  <!-- 构建 -->
  <build>...</build>
  <!-- 报告 -->
  <reporting>...</reporting>

  <!--项目详细信息  -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>

  <!-- 环境设置 -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

我们下载完成之后,然后将解压其配置到系统环境变量,如下图所示:

澳门新濠3559 28image.png

一个典型的pom.xml文件配置如下:

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">  

    <!-- 声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,但它仍然是必不可少的,这是为了当Maven引入了新的特性或者其他模型变更的时候,确保稳定性。 -->  
    <modelVersion>4.0.0</modelVersion>  

    <!-- 公司或者组织的唯一标志,并且配置时生成的路径也是由此生成, 如com.winner.trade,maven会将该项目打成的jar包放本地路径:/com/winner/trade -->  
    <groupId>com.winner.trade</groupId>  

    <!-- 本项目的唯一ID,一个groupId下面可能多个项目,就是靠artifactId来区分的 -->  
    <artifactId>trade-core</artifactId>  

    <!-- 本项目目前所处的版本号 -->  
    <version>1.0.0-SNAPSHOT</version>  

    <!-- 打包的机制,如pom,jar, maven-plugin, ejb, war, ear, rar, par,默认为jar -->  
    <packaging>jar</packaging>  

    <!-- 帮助定义构件输出的一些附属构件,附属构件与主构件对应,有时候需要加上classifier才能唯一的确定该构件 不能直接定义项目的classifer,因为附属构件不是项目直接默认生成的,而是由附加的插件帮助生成的 -->  
    <classifier>...</classifier>  

    <!-- 定义本项目的依赖关系 -->  
    <dependencies>  

        <!-- 每个dependency都对应这一个jar包 -->  
        <dependency>  

            <!--一般情况下,maven是通过groupId、artifactId、version这三个元素值(俗称坐标)来检索该构件, 然后引入你的工程。如果别人想引用你现在开发的这个项目(前提是已开发完毕并发布到了远程仓库),-->   
            <!--就需要在他的pom文件中新建一个dependency节点,将本项目的groupId、artifactId、version写入, maven就会把你上传的jar包下载到他的本地 -->  
            <groupId>com.winner.trade</groupId>  
            <artifactId>trade-test</artifactId>  
            <version>1.0.0-SNAPSHOT</version>  

            <!-- maven认为,程序对外部的依赖会随着程序的所处阶段和应用场景而变化,所以maven中的依赖关系有作用域(scope)的限制。 -->  
            <!--scope包含如下的取值:compile(编译范围)、provided(已提供范围)、runtime(运行时范围)、test(测试范围)、system(系统范围) -->  
            <scope>test</scope>  

            <!-- 设置指依赖是否可选,默认为false,即子项目默认都继承:为true,则子项目必需显示的引入,与dependencyManagement里定义的依赖类似  -->  
            <optional>false</optional>  

            <!-- 屏蔽依赖关系。 比如项目中使用的libA依赖某个库的1.0版,libB依赖某个库的2.0版,现在想统一使用2.0版,就应该屏蔽掉对1.0版的依赖 -->  
            <exclusions>  
                <exclusion>  
                    <groupId>org.slf4j</groupId>  
                    <artifactId>slf4j-api</artifactId>  
                </exclusion>  
            </exclusions>  

        </dependency>  

    </dependencies>  

    <!-- 为pom定义一些常量,在pom中的其它地方可以直接引用 使用方式 如下 :${file.encoding} -->  
    <properties>  
        <file.encoding>UTF-8</file.encoding>  
        <java.source.version>1.5</java.source.version>  
        <java.target.version>1.5</java.target.version>  
    </properties>  

    ...  
</project>  

澳门新濠3559 29

2、eclipse导入gradle项目:

构建配置

<build>  

    <!-- 产生的构件的文件名,默认值是${artifactId}-${version}。 -->  
    <finalName>myPorjectName</finalName>  

    <!-- 构建产生的所有文件存放的目录,默认为${basedir}/target,即项目根目录下的target -->  
    <directory>${basedir}/target</directory>  

    <!--当项目没有规定目标(Maven2叫做阶段(phase))时的默认值, -->  
    <!--必须跟命令行上的参数相同例如jar:jar,或者与某个阶段(phase)相同例如install、compile等 -->  
    <defaultGoal>install</defaultGoal>  

    <!--当filtering开关打开时,使用到的过滤器属性文件列表。 -->  
    <!--项目配置信息中诸如${spring.version}之类的占位符会被属性文件中的实际值替换掉 -->  
    <filters>  
        <filter>../filter.properties</filter>  
    </filters>  

    <!--项目相关的所有资源路径列表,例如和项目相关的配置文件、属性文件,这些资源被包含在最终的打包文件里。 -->  
    <resources>  
        <resource>  

            <!--描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。 -->  
            <!--举个例子,如果你想资源在特定的包里(org.apache.maven.messages),你就必须该元素设置为org/apache/maven/messages。 -->  
            <!--然而,如果你只是想把资源放到源码目录结构里,就不需要该配置。 -->  
            <targetPath>resources</targetPath>  

            <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性,文件在filters元素里列出。 -->  
            <filtering>true</filtering>  

            <!--描述存放资源的目录,该路径相对POM路径 -->  
            <directory>src/main/resources</directory>  

            <!--包含的模式列表 -->  
            <includes>  
                <include>**/*.properties</include>  
                <include>**/*.xml</include>  
            </includes>  

            <!--排除的模式列表 如果<include>与<exclude>划定的范围存在冲突,以<exclude>为准 -->  
            <excludes>  
                <exclude>jdbc.properties</exclude>  
            </excludes>  

        </resource>  
    </resources>  

    <!--单元测试相关的所有资源路径,配制方法与resources类似 -->  
    <testResources>  
        <testResource>  
            <targetPath />  
            <filtering />  
            <directory />  
            <includes />  
            <excludes />  
        </testResource>  
    </testResources>  

    <!--项目源码目录,当构建项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->  
    <sourceDirectory>${basedir}srcmainjava</sourceDirectory>  

    <!--项目脚本源码目录,该目录和源码目录不同, <!-- 绝大多数情况下,该目录下的内容会被拷贝到输出目录(因为脚本是被解释的,而不是被编译的)。 -->  
    <scriptSourceDirectory>${basedir}srcmainscripts  
    </scriptSourceDirectory>  

    <!--项目单元测试使用的源码目录,当测试项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->  
    <testSourceDirectory>${basedir}srctestjava</testSourceDirectory>  

    <!--被编译过的应用程序class文件存放的目录。 -->  
    <outputDirectory>${basedir}targetclasses</outputDirectory>  

    <!--被编译过的测试class文件存放的目录。 -->  
    <testOutputDirectory>${basedir}targettest-classes  
    </testOutputDirectory>  

    <!--项目的一系列构建扩展,它们是一系列build过程中要使用的产品,会包含在running bulid‘s classpath里面。 -->  
    <!--他们可以开启extensions,也可以通过提供条件来激活plugins。 -->  
    <!--简单来讲,extensions是在build过程被激活的产品 -->  
    <extensions>  

        <!--例如,通常情况下,程序开发完成后部署到线上Linux服务器,可能需要经历打包、 -->  
        <!--将包文件传到服务器、SSH连上服务器、敲命令启动程序等一系列繁琐的步骤。 -->  
        <!--实际上这些步骤都可以通过Maven的一个插件 wagon-maven-plugin 来自动完成 -->  
        <!--下面的扩展插件wagon-ssh用于通过SSH的方式连接远程服务器, -->  
        <!--类似的还有支持ftp方式的wagon-ftp插件 -->  
        <extension>  
            <groupId>org.apache.maven.wagon</groupId>  
            <artifactId>wagon-ssh</artifactId>  
            <version>2.8</version>  
        </extension>  

    </extensions>  

    <!--使用的插件列表 。 -->  
    <plugins>  
        <plugin>  
            <groupId></groupId>  
            <artifactId>maven-assembly-plugin</artifactId>  
            <version>2.5.5</version>  

            <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->  
            <executions>  
                <execution>  

                    <!--执行目标的标识符,用于标识构建过程中的目标,或者匹配继承过程中需要合并的执行目标 -->  
                    <id>assembly</id>  

                    <!--绑定了目标的构建生命周期阶段,如果省略,目标会被绑定到源数据里配置的默认阶段 -->  
                    <phase>package</phase>  

                    <!--配置的执行目标 -->  
                    <goals>  
                        <goal>single</goal>  
                    </goals>  

                    <!--配置是否被传播到子POM -->  
                    <inherited>false</inherited>  

                </execution>  
            </executions>  

            <!--作为DOM对象的配置,配置项因插件而异 -->  
            <configuration>  
                <finalName>${finalName}</finalName>  
                <appendAssemblyId>false</appendAssemblyId>  
                <descriptor>assembly.xml</descriptor>  
            </configuration>  

            <!--是否从该插件下载Maven扩展(例如打包和类型处理器), -->  
            <!--由于性能原因,只有在真需要下载时,该元素才被设置成true。 -->  
            <extensions>false</extensions>  

            <!--项目引入插件所需要的额外依赖 -->  
            <dependencies>  
                <dependency>...</dependency>  
            </dependencies>  

            <!--任何配置是否被传播到子项目 -->  
            <inherited>true</inherited>  

        </plugin>  
    </plugins>  

    <!--主要定义插件的共同元素、扩展元素集合,类似于dependencyManagement, -->  
    <!--所有继承于此项目的子项目都能使用。该插件配置项直到被引用时才会被解析或绑定到生命周期。 -->  
    <!--给定插件的任何本地配置都会覆盖这里的配置 -->  
    <pluginManagement>  
        <plugins>...</plugins>  
    </pluginManagement>  

</build>  

image.png

澳门新濠3559 30image.png导入的时候选这个,不然会报错。

报告

<!--描述使用报表插件产生报表的规范,特定的maven 插件能输出相应的定制和配置报表. -->  
<!--当用户执行“mvn site”,这些报表就会运行,在页面导航栏能看到所有报表的链接。 -->  
<reporting>  

    <!--true,则网站不包括默认的报表。这包括“项目信息”菜单中的报表。 -->  
    <excludeDefaults />  

    <!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->  
    <outputDirectory />  

    <!--使用的报表插件和他们的配置。 -->  
    <plugins>  

        <plugin>  
            <groupId />  
            <artifactId />  
            <version />  
            <inherited />  
            <configuration>  
                <links>  
                    <link>http://java.sun.com/j2se/1.5.0/docs/api/</link>  
                </links>  
            </configuration>  
            <!--一组报表的多重规范,每个规范可能有不同的配置。 -->  
            <!--一个规范(报表集)对应一个执行目标 。例如,有1,2,3,4,5,6,7,8,9个报表。 -->  
            <!--1,2,5构成A报表集,对应一个执行目标。2,5,8构成B报表集,对应另一个执行目标 -->  
            <reportSets>  

                <!--表示报表的一个集合,以及产生该集合的配置 -->  
                <reportSet>  

                    <!--报表集合的唯一标识符,POM继承时用到 -->  
                    <id>sunlink</id>  

                    <!--产生报表集合时,被使用的报表的配置 -->  
                    <configuration />  

                    <!--配置是否被继承到子POMs -->  
                    <inherited />  

                    <!--这个集合里使用到哪些报表 -->  
                    <reports>  
                        <report>javadoc</report>  
                    </reports>  

                </reportSet>  

            </reportSets>  

        </plugin>  

    </plugins>  

</reporting>     

接下来我们可以在命令行,运行一下命令(如果出现下图所示,及表示安装成功):

3、运行gradle项目:比如用gradle构建的springboot项目,运行方式:可以直接运行springboot的启动类,也可以在项目根目录下打开cmd命令行,然后输入gradle build,然后在项目根目录的build/libs下面就会有Xxx.jar,再输入命令java -jar build/libs/Xxx.jar,项目即可启动起来。

项目信息配置

<!--项目的名称, Maven产生的文档用 -->  
<name>banseon-maven </name>  

<!--项目主页的URL, Maven产生的文档用 -->  
<url>http://www.clf.com/ </url>  

<!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时 -->  
<!--(例如,CDATA中的文本会被解析器忽略,就可以包含HTML标签),不鼓励使用纯文本描述。 -->  
<!-- 如果你需要修改产生的web站点的索引页面,你应该修改你自己的索引页文件,而不是调整这里的文档。 -->  
<description>A maven project to study maven. </description>  

<!--描述了这个项目构建环境中的前提条件。 -->  
<prerequisites>  

    <!--构建该项目或使用该插件所需要的Maven的最低版本 -->  
    <maven />  

</prerequisites>  

<!--项目创建年份,4位数字。当产生版权信息时需要使用这个值。 -->  
<inceptionYear />  

<!--项目相关邮件列表信息 -->  
<mailingLists>  

    <!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->  
    <mailingList>  

        <!--邮件的名称 -->  
        <name> Demo </name>  

        <!--发送邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建 -->  
        <post> clf@126.com</post>  

        <!--订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建 -->  
        <subscribe> clf@126.com</subscribe>  

        <!--取消订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建 -->  
        <unsubscribe> clf@126.com</unsubscribe>  

        <!--你可以浏览邮件信息的URL -->  
        <archive> http:/hi.clf.com/</archive>  

    </mailingList>  

</mailingLists>  

<!--项目开发者列表 -->  
<developers>  

    <!--某个项目开发者的信息 -->  
    <developer>  

        <!--SCM里项目开发者的唯一标识符 -->  
        <id> HELLO WORLD </id>  

        <!--项目开发者的全名 -->  
        <name> banseon </name>  

        <!--项目开发者的email -->  
        <email> banseon@126.com</email>  

        <!--项目开发者的主页的URL -->  
        <url />  

        <!--项目开发者在项目中扮演的角色,角色元素描述了各种角色 -->  
        <roles>  
            <role> Project Manager</role>  
            <role>Architect </role>  
        </roles>  

        <!--项目开发者所属组织 -->  
        <organization> demo</organization>  

        <!--项目开发者所属组织的URL -->  
        <organizationUrl>http://hi.clf.com/ </organizationUrl>  

        <!--项目开发者属性,如即时消息如何处理等 -->  
        <properties>  
            <dept> No </dept>  
        </properties>  

        <!--项目开发者所在时区, -11到12范围内的整数。 -->  
        <timezone> -5</timezone>  

    </developer>  

</developers>  

<!--项目的其他贡献者列表 -->  
<contributors>  

    <!--项目的其他贡献者。参见developers/developer元素 -->  
    <contributor>  
        <name />  
        <email />  
        <url />  
        <organization />  
        <organizationUrl />  
        <roles />  
        <timezone />  
        <properties />  
    </contributor>  

</contributors>  

<!--该元素描述了项目所有License列表。应该只列出该项目的license列表,不要列出依赖项目的license列表。 -->  
<!--如果列出多个license,用户可以选择它们中的一个而不是接受所有license。 -->  
<licenses>  

    <!--描述了项目的license,用于生成项目的web站点的license页面,其他一些报表和validation也会用到该元素。 -->  
    <license>  

        <!--license用于法律上的名称 -->  
        <name> Apache 2 </name>  

        <!--官方的license正文页面的URL -->  
        <url>http://www.clf.com/LICENSE-2.0.txt </url>  

        <!--项目分发的主要方式: repo,可以从Maven库下载 manual, 用户必须手动下载和安装依赖 -->  
        <distribution> repo</distribution>  

        <!--关于license的补充信息 -->  
        <comments> Abusiness-friendly OSS license </comments>  

    </license>  

</licenses>  

<!--SCM(Source Control Management)标签允许你配置你的代码库,供Maven web站点和其它插件使用。 -->  
<scm>  

    <!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情,请看SCMs提供的URL格式和列表。该连接只读。 -->  
    <connection>scm:svn:http://svn.baidu.com/banseon/maven/</connection>  

    <!--给开发者使用的,类似connection元素。即该连接不仅仅只读 -->  
    <developerConnection>scm:svn:http://svn.baidu.com/banseon/maven/  
    </developerConnection>  

    <!--当前代码的标签,在开发阶段默认为HEAD -->  
    <tag />  

    <!--指向项目的可浏览SCM库(例如ViewVC或者Fisheye)的URL。 -->  
    <url> http://svn.baidu.com/banseon</url>  

</scm>  

<!--描述项目所属组织的各种属性。Maven产生的文档用 -->  
<organization>  

    <!--组织的全名 -->  
    <name> demo </name>  

    <!--组织主页的URL -->  
    <url> http://www.clf.com/</url>  

</organization>   
  • spring --version

4、给项目添加依赖:因为gradle项目没有pom.xml了,所添加依赖的方式有所不同。首先去maven仓库搜索需要的依赖:

分发配置

<!--项目分发信息,在执行mvn deploy后表示要发布的位置。 -->  
<!--有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。 -->  
<distributionManagement>  

    <!--部署项目产生的构件到远程仓库需要的信息 -->  
    <repository>  

        <!--是分配给快照一个唯一的版本号(由时间戳和构建流水号),还是每次都使用相同的版本号 -->  
        <!--参见repositories/repository元素 -->  
        <uniqueVersion>true</uniqueVersion>  

        <id> repo-id </id>  
        <name> repo-name</name>  
        <url>file://${basedir}/target/deploy </url>  
        <layout />  

    </repository>  

    <!--构件的快照部署到哪里,如果没有配置该元素,默认部署到repository元素配置的仓库 -->  
    <snapshotRepository>  
        <uniqueVersion />  
        <id />  
        <name />  
        <url />  
        <layout />  
    </snapshotRepository>  

    <!--部署项目的网站需要的信息 -->  
    <site>  

        <!--部署位置的唯一标识符,用来匹配站点和settings.xml文件里的配置 -->  
        <id> site-id </id>  

        <!--部署位置的名称 -->  
        <name> site-name</name>  

        <!--部署位置的URL,按protocol://hostname/path形式 -->  
        <url>scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web </url>  

    </site>  

    <!--项目下载页面的URL。如果没有该元素,用户应该参考主页。 -->  
    <!--使用该元素的原因是:帮助定位那些不在仓库里的构件(由于license限制)。 -->  
    <downloadUrl />  

    <!--如果构件有了新的groupID和artifact ID(构件移到了新的位置),这里列出构件的重定位信息。 -->  
    <relocation>  

        <!--构件新的group ID -->  
        <groupId />  

        <!--构件新的artifact ID -->  
        <artifactId />  

        <!--构件新的版本号 -->  
        <version />  

        <!--显示给用户的,关于移动的额外信息,例如原因。 -->  
        <message />  

    </relocation>  

    <!--给出该构件在远程仓库的状态。不得在本地项目中设置该元素,因为这是工具自动更新的。 -->  
    <!--有效的值有:none(默认),converted(仓库管理员从Maven 1 POM转换过来), -->  
    <!--partner(直接从伙伴Maven 2仓库同步过来),deployed(从Maven 2实例部署),verified(被核实时正确的和最终的)。 -->  
    <status />  

</distributionManagement>  
![](https://upload-images.jianshu.io/upload_images/2726392-a34ac6642db8623d.png)

image.png

澳门新濠3559 31image.png复制出来后添加到项目的build.gradle文件的depedencies处。澳门新濠3559 32image.png

仓库

<!--发现依赖和扩展的远程仓库列表。 -->  
<repositories>  

    <!--包含需要连接到远程仓库的信息 -->  
    <repository>  

        <!--如何处理远程仓库里发布版本的下载 -->  
        <releases>  

            <!--true或者false表示该仓库是否为下载某种类型构件(发布版,快照版)开启。 -->  
            <enabled />  

            <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。 -->  
            <!--这里的选项是:always(一直),daily(默认,每日), -->  
            <!--interval:X(这里X是以分钟为单位的时间间隔),或者never(从不)。 -->  
            <updatePolicy />  

            <!--当Maven验证构件校验文件失败时该怎么做: -->  
            <!--ignore(忽略),fail(失败),或者warn(警告)。 -->  
            <checksumPolicy />  

        </releases>  

        <!--如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置, -->  
        <!--POM就可以在每个单独的仓库中,为每种类型的构件采取不同的策略。 -->  
        <!--例如,可能有人会决定只为开发目的开启对快照版本下载的支持 -->  
        <snapshots>  
            <enabled />  
            <updatePolicy />  
            <checksumPolicy />  
        </snapshots>  

        <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 -->  
        <id> repo-id </id>  

        <!--远程仓库名称 -->  
        <name> repo-name</name>  

        <!--远程仓库URL,按protocol://hostname/path形式 -->  
        <url>http://192.168.1.169:9999/repository/ </url>  

        <!--用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。 -->  
        <!--Maven 2为其仓库提供了一个默认的布局; -->  
        <!--然而,Maven1.x有一种不同的布局。 -->  
        <!--我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。 -->  
        <layout> default</layout>  

    </repository>  

</repositories>  

<!--发现插件的远程仓库列表,这些插件用于构建和报表 -->  
<pluginRepositories>  

    <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->  
    <pluginRepository />  

</pluginRepositories>  

接下来我们就直接使用这个脚手架,我建议大家实际操作之前,最好去看看这个地址的简介:
https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#cli-init

gradle可以说是比较有前瞻性的技术,网上都说它是综合了maven和ant的优点,是以后的发展趋势。有兴趣的朋友可以了解一下。

profile配置

<!--在列的项目构建profile,如果被激活,会修改构建处理 -->  
<profiles>  

    <!--根据环境参数或命令行参数激活某个构建处理 -->  
    <profile>  
        <!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。 -->  
        <activation>  

            <!--profile默认是否激活的标识 -->  
            <activeByDefault>false</activeByDefault>  

            <!--activation有一个内建的java版本检测,如果检测到jdk版本与期待的一样,profile被激活。 -->  
            <jdk>1.7</jdk>  

            <!--当匹配的操作系统属性被检测到,profile被激活。os元素可以定义一些操作系统相关的属性。 -->  
            <os>  

                <!--激活profile的操作系统的名字 -->  
                <name>Windows XP</name>  

                <!--激活profile的操作系统所属家族(如 'windows') -->  
                <family>Windows</family>  

                <!--激活profile的操作系统体系结构 -->  
                <arch>x86</arch>  

                <!--激活profile的操作系统版本 -->  
                <version>5.1.2600</version>  

            </os>  

            <!--如果Maven检测到某一个属性(其值可以在POM中通过${名称}引用),其拥有对应的名称和值,Profile就会被激活。 -->  
            <!-- 如果值字段是空的,那么存在属性名称字段就会激活profile,否则按区分大小写方式匹配属性值字段 -->  
            <property>  

                <!--激活profile的属性的名称 -->  
                <name>mavenVersion</name>  

                <!--激活profile的属性的值 -->  
                <value>2.0.3</value>  

            </property>  

            <!--提供一个文件名,通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在,如果不存在则激活profile。 -->  
            <!--另一方面,exists则会检查文件是否存在,如果存在则激活profile。 -->  
            <file>  

                <!--如果指定的文件存在,则激活profile。 -->  
                <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>  

                <!--如果指定的文件不存在,则激活profile。 -->  
                <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>  

            </file>  

        </activation>  
        <id />  
        <build />  
        <modules />  
        <repositories />  
        <pluginRepositories />  
        <dependencies />  
        <reporting />  
        <dependencyManagement />  
        <distributionManagement />  
        <properties />  
    </profile>  

POM 4.0的一个新功能是项目能够根据所在的环境来改变设置,profile元素包含两个任选的活化(轮廓触发器)和设定变化的向POM制成如果所选择的文档已被激活。例如,为测试环境构建的项目可能会指向与最终部署不同的数据库。或者依赖关系可以根据所使用的JDK版本从不同的存储库中提取。

profile配置项在setting.xml中也有,是pom.xml中profile元素的裁剪版本,包含了id,activation, repositories, pluginRepositories和 properties元素。这里的profile元素只包含这五个子元素是因为setting.xml只关心构建系统这个整体(这正是settings.xml文件的角色定位),而非单独的项目对象模型设置。如果一个settings中的profile被激活,它的值会覆盖任何其它定义在POM中或者profile.xml中的带有相同id的profile。
pom.xml中的profile可以看做pom.xml的副本,拥有与pom.xml相同的子元素与配置方法。它包含可选的activation(profile的触发器)和一系列的changes。例如test过程可能会指向不同的数据库(相对最终的deployment)或者不同的dependencies或者不同的repositories,并且是根据不同的JDK来改变的。只需要其中一个成立就可以激活profile,如果第一个条件满足了,那么后面就不会在进行匹配。

澳门新濠3559 33

以上内容属于个人笔记整理,如有错误,欢迎批评指正!

环境配置

<!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL,本例为 jira -->  
<issueManagement>  

    <!--问题管理系统(例如jira)的名字, -->  
    <system> jira </system>  

    <!--该项目使用的问题管理系统的URL -->  
    <url> http://jira.clf.com/</url>  

</issueManagement>  

<!--项目持续集成信息 -->  
<ciManagement>  

    <!--持续集成系统的名字,例如continuum -->  
    <system />  

    <!--该项目使用的持续集成系统的URL(如果持续集成系统有web接口的话)。 -->  
    <url />  

    <!--构建完成时,需要通知的开发者/用户的配置项。包括被通知者信息和通知条件(错误,失败,成功,警告) -->  
    <notifiers>  

        <!--配置一种方式,当构建中断时,以该方式通知用户/开发者 -->  
        <notifier>  

            <!--传送通知的途径 -->  
            <type />  

            <!--发生错误时是否通知 -->  
            <sendOnError />  

            <!--构建失败时是否通知 -->  
            <sendOnFailure />  

            <!--构建成功时是否通知 -->  
            <sendOnSuccess />  

            <!--发生警告时是否通知 -->  
            <sendOnWarning />  

            <!--不赞成使用。通知发送到哪里 -->  
            <address />  

            <!--扩展配置项 -->  
            <configuration />  

        </notifier>  

    </notifiers>  

</ciManagement>  

image.png

首先我们建立一个文件夹,专门用来存放我们的SpringBoot项目,如下图所示:

澳门新濠3559 34

image.png

接着我们在命令行(管理员权限)输入如下命令:

  • spring init --list > d:springbootprojectsspringbootcli.config
    将会生成一个帮助文件到我们的文件夹下面,如下图:
![](https://upload-images.jianshu.io/upload_images/2726392-e9aca40c4a8af98d.png)

image.png

我们打开这个文件,会看到很多关于这个脚手架的参数,以及各个参数的默认值。通过这个文档,我们可以选择生成自己的SpringBoot项目。

澳门新濠3559 35

image.png

澳门新濠3559 36

image.png

这里面包括了,SpringBootCLI,支持的一些依赖,工程类型,以及各种参数设置。大家可以仔细阅读。
接下来我们就使用命令创建一个项目,记住SpringBoot的原则COC,所以如果你不需要改动,就不需要写。我自己的命令如下(我选择的语言是groovy,个人尝试,大家可换成java):

  • spring init --dependencies=web --language=groovy --packaging=jar --type=gradle-project --version=0.0.1

将命令行切入到你的工程文件夹执行,会出现如下的效果。

澳门新濠3559 37

image.png

接下来我们观看我们的工程文件夹。

澳门新濠3559 38

image.png

会出现一个Demo.zip,我们将其解压,然后我们可以看到其目录结构:

澳门新濠3559 39

image.png

关于gradle,以及gradle wrapper的知识这里我们就不多说了,大家可以发现脚手架已经帮我们生成了.gitignore文件,这对于我们是很方便的。

接下来我们就使用idea 社区版将其导入。

澳门新濠3559 40

image.png

选择gradle:

澳门新濠3559 41

image.png

这里我们选择使用本地的gradle 配置(主要是不需要去下载gradle了,节省时间,因为我们本地已经有了)。

澳门新濠3559 42

image.png

导入之后,等gradle刷新完成之后,我们便能看到如下的项目结构。

澳门新濠3559 43

image.png

其中gradle文件已经给我们配置好了,如果我们后续要继续添加依赖以及其他gradle tasks只需要去添加就好了。

澳门新濠3559 44

image.png

上面的DemoApplication.groovy就是SpringBoot程序的入口。

接下来我们打开idea的终端,输入如下命令:

  • gradle bootRun或者gradlew bootRun(大家可以去看gradle wrapper的作用就明白了)

我这里输入gradle bootRun(启动SpringBoot项目)

澳门新濠3559 45

image.png

到这一步,我们可以看到SpringBoot项目已经成功启动了。默认使用Tomcat启动的是8080端口。但我们并没有做请求处理,所以访问8080端口会报404错误。

接下来我们编写一个简单的Controller。(使用groovy语言)

澳门新濠3559 46

image.png

我们gradle bootRun运行SpringBoot项目,然后浏览器输入127.0.0.1:8080,便可以看到如下界面:

澳门新濠3559 47

image.png

接着我们可以看终端:

澳门新濠3559 48

image.png

进行到这一步,一个最简单的SpringBoot项目就算搭建而成了,其实我建议搭建多多使用命令行去操作,不要太依赖IDE。而且多看SpringBoot的官方文档,你将收获颇多。

如果后续有什么问题,可以QQ找我:1427730623,或者简书给我留言。

编辑:编程 本文来源:spring自己说它是一个轻量级的框架,其实当你了

关键词: 澳门新濠3559