精华内容
下载资源
问答
  • vue框架外文参考文献
    2019-03-14 20:35:00

    本项目基于vue2.5.2,如有错误,望指正。

    完整程序:https://github.com/M-M-Monica/bukesi

    Vue.js官方文档:https://cn.vuejs.org/v2/guide/

    一.vue-cli

    二.生命周期

    三.Vue Router

    四.Sass/SCSS

    五.content

    六.图片资源

    • Dribbble(部分图片资源来自Dribbble图侵删)

    七.父子组件通信

    八.Flex布局

    九.vue调试扩展程序

    十.vue1.0升级到vue2.0部分不同之处

    • 配置文件修改
      • package.json
      • build目录修改
      • config目录修改
    • Vue-Router API变化
      • 初始化路由变化
      • v-link指令替换为<router-link>组件
    • vue2.0语法变化
      • v-for指令的变化
      • v-el、v-ref指令的变化(2.0它们合并为ref)
      • 模板变化,组件只允许一个根元素(<template><div>...</div></template>)
      • 组件通信变化$dispatch废除(改用$emit)
      • 事件监听变化,废除events属性
      • 过渡的变化,transition组件
      • ......
    • 官方文档:从Vue1.x迁移

    转载于:https://www.cnblogs.com/M-M-Monica/p/10533298.html

    更多相关内容
  • Vue框架总结.pdf

    2022-04-03 11:04:52
    Vue 中,可以通过方法创建一些全局的组件,或者局部的组件。但是,在实际 的 Vue 项目中,使用得更多的是单文件组件。 单文件组件 每一个以 .vue 为后缀的文件,都是一个组件,称为“单文件组件”。 单文件组件...
  • 开发技术vue.js

    2017-09-15 17:36:08
    开发技术vue.js
  • Spring Boot文档翻译

    千次阅读 2018-01-02 15:02:19
    1.Spring Boot文档 ...本节简要介绍Spring Boot参考文档 1.1关于这个文档 Spring参考文档可以通过如下三种途径获得: Html PDF EPUB 注:考虑到大家翻墙问题,我准备了一份PDF,通过百度云盘分享的方式。

    目录


    Part I.Spring Boot文档


    本节简要介绍Spring Boot参考文档

    1.关于这个文档

    Spring参考文档可以通过如下三种途径获得:

    1. Html
    2. PDF
    3. EPUB

    注:考虑到大家翻墙问题,我准备了一份PDF,通过百度云盘分享的方式。

    2.获得帮助

    如果您在使用Spring Boot中遇到困难,我们希望能够提供帮助:

    • 尝试使用How to文档。它们提供常规的解决方法。
    • 学习Spring的基础知识,Spring Boot建立在它们之上。查阅Spring.io网站获取丰富的资料。
    • 在StackOverflow提问,我们监视Spring-Boot为标签的问题。
    • 在github.com/spring-projects/spring-boot/issues上报告错误。

    3.第一步

    如果您正在开始使用Spring Boot或“Spring”,请从以下主题开始:

    从头开始:概览| 要求| 安装
    教程:第1部分| 第2部分
    运行您的示例:第1部分| 第2部分

    4.使用Spring Boot

    准备好真正开始使用Spring Boot? 我们涵盖如下知识:

    构建系统:Maven | Gradle | ant|Starters
    最佳实践:代码结构| @Configuration | @EnableAutoConfiguration | bean以及相关依赖注入
    运行您的代码IDE |Packaged | Maven | Gradle
    打包你的应用程序:生产Jar
    Spring Boot CLI:使用CLI

    5.学习Spring Boot特性

    需要更多关于Spring Boot核心功能的细节? 以下内容适合您:

    核心特性:SpringApplication | 外部配置| 配置文件|日志
    Web应用程序:MVC | 嵌入式容器
    使用数据:SQL |NO-SQL
    消息:概述|JMS
    测试:概述| 启动应用程序|utils
    扩展:自动配置| @条件

    6.转向生产

    当你准备把你的Spring Boot应用程序投入生产时,我们有一些你可能会喜欢的技巧:

    管理端点:概览|定制
    连接选项:HTTP |JMX
    监测:指标| 审计| 追踪| 处理

    7.高级主题

    最后,我们有更多高级用户的一些话题:

    Spring Boot应用程序部署:云部署| OS服务
    构建工具插件:Maven |gradle
    附录:应用程序属性| 自动配置类| 可执行的jars

    Part II.入门


    如果您正在开始使用Spring Boot,或者一般情况下使用“Spring”,请先阅读本节。 它回答了基本的“什么?”,“如何?”和“为什么?”的问题。 它包括一个Spring Boot的介绍,以及安装说明。 然后,我们将引导您构建您的第一个Spring Boot应用程序,并讨论一些核心原则。

    8.介绍Spring Boot

    Spring Boot使您可以轻松创建可以运行的独立的,生产级的基于Spring的应用程序。我们对Spring平台和第三方库有一个自己的看法,这样你就可以用最小的麻烦开始。大多数Spring Boot应用程序只需要很少的Spring配置。

    您可以使用Spring Boot来创建可以使用java -jar或更传统的war部署启动的Java应用程序。我们还提供了一个运行“春天脚本”的命令行工具。

    我们的主要目标是:

    为所有Spring开发提供一个更快,更广泛的入门体验。
    开箱即用,但是随着需求开始偏离默认值,快速退出。
    提供大量项目(如嵌入式服务器,安全性,指标,运行状况检查和外部配置)通用的一系列非功能性功能。
    绝对不会生成代码,也不需要XML配置。

    9.系统要求

    Spring Boot 2.0.0.BUILD-SNAPSHOT需要Java 8和Spring Framework 5.0.2.RELEASE或更高版本。 为Maven 3.2+和Gradle 4提供了明确的构建支持。

    9.1.Servlet容器

    开箱即用支持以下嵌入式servlet容器:

    名字Servlet版本
    Tomcat 8.53.1
    Jetty 9.43.1
    Undertow 1.33.1

    您也可以将Spring Boot应用程序部署到任何与Servlet 3.0+兼容的容器。

    10.安装Spring Boot

    Spring Boot可以与“经典”的Java开发工具一起使用,也可以作为命令行工具安装。 无论哪种方式,您都需要Java SDK v1.8或更高版本。 在开始之前,您应该使用以下命令检查当前的Java安装版本:

    $ java -version

    如果您对Java开发不熟悉,或者想要尝试Spring Boot,则可能需要先尝试Spring Boot CLI(命令行界面),否则请阅读“经典”安装说明。

    10.1 Java开发人员的安装说明

    您可以像使用任何标准Java库一样使用Spring Boot。 为此,请在类路径中包含相应的spring-boot - *.jar文件。 Spring Boot不需要任何特殊的工具集成,因此您可以使用任何IDE或文本编辑器。 此外,Spring Boot应用程序没有什么特别之处,所以您可以像运行其他任何Java程序一样运行和调试Spring Boot应用程序。

    尽管您可以复制Spring Boot 的jar包,但我们通常建议您使用支持依赖管理的构建工具(如Maven或Gradle)。

    10.1.1 Maven安装

    Spring Boot与Apache Maven 3.2或更高版本兼容。 如果您还没有安装Maven,可以按照https://maven.apache.org/上的说明进行操作。

    注:在许多操作系统上,Maven可以安装一个包管理器。 如果您使用OSX Homebrew,请尝试brew install maven。 Ubuntu用户可以运行sudo apt-get install maven。 具有Chocolatey的Windows用户可以从提升(管理员)提示符运行choco install maven

    Spring Boot依赖使用org.springframework.boot groupId。 通常,您的Maven POM文件从spring-boot-starter-parent项目继承,并将依赖关系声明为一个或多个“Starter”。 Spring Boot还提供了一个可选的Maven插件来创建可执行的jar文件。

    以下列表显示了一个典型的pom.xml文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.example</groupId>
        <artifactId>myproject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <!-- Inherit defaults from Spring Boot -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
        </parent>
    
        <!-- Add typical dependencies for a web application -->
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
        </dependencies>
    
        <!-- Package as an executable jar -->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
        <!-- Add Spring repositories -->
        <!-- (you don't need this if you are using a .RELEASE version) -->
        <repositories>
            <repository>
                <id>spring-snapshots</id>
                <url>http://repo.spring.io/snapshot</url>
                <snapshots><enabled>true</enabled></snapshots>
            </repository>
            <repository>
                <id>spring-milestones</id>
                <url>http://repo.spring.io/milestone</url>
            </repository>
        </repositories>
        <pluginRepositories>
            <pluginRepository>
                <id>spring-snapshots</id>
                <url>http://repo.spring.io/snapshot</url>
            </pluginRepository>
            <pluginRepository>
                <id>spring-milestones</id>
                <url>http://repo.spring.io/milestone</url>
            </pluginRepository>
        </pluginRepositories>
    </project>

    注:有时您可能需要从不同的父POM继承,或者您可能不喜欢我们的默认设置 在这些情况下,请参见第13.2.2节“使用不带父项的Spring Boot”,以获得使用import scope的替代解决方案。

    10.1.2 Gradle安装

    Spring Boot与Gradle 4兼容。如果您没有安装Gradle,您可以按照www.gradle.org上的说明进行操作。

    Spring Boot依赖可以通过使用org.springframework.boot组声明,Spring Boot提供了一个有用的Gradle插件,可以用来简化依赖声明和创建可执行的jar。

    Gradle Wrapper
    当您需要构建项目时,Gradle Wrapper提供了一个“获取”Gradle的好方法。 这是一个小脚本和库,与代码一起提交来引导构建过程。 有关详细信息,请参阅docs.gradle.org/4.2.1/userguide/gradle_wrapper.html。

    以下示例显示了一个典型的build.gradle文件:

    buildscript {
        repositories {
            jcenter()
            maven { url 'http://repo.spring.io/snapshot' }
            maven { url 'http://repo.spring.io/milestone' }
        }
        dependencies {
            classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.0.0.BUILD-SNAPSHOT'
        }
    }
    
    apply plugin: 'java'
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
    
    jar {
        baseName = 'myproject'
        version =  '0.0.1-SNAPSHOT'
    }
    
    repositories {
        jcenter()
        maven { url "http://repo.spring.io/snapshot" }
        maven { url "http://repo.spring.io/milestone" }
    }
    
    dependencies {
        compile("org.springframework.boot:spring-boot-starter-web")
        testCompile("org.springframework.boot:spring-boot-starter-test")
    }

    10.2安装Spring Boot CLI

    Spring Boot CLI(命令行界面)是一个命令行工具,您可以使用它来快速使用Spring进行原型开发。 它可以让你运行Groovy脚本,这意味着你有一个熟悉的类Java语法,没有太多的样板代码。

    您不需要使用CLI来与Spring Boot一起工作,但这绝对是让Spring应用程序起飞的最快捷方式。

    10.2.1手动安装

    您可以从Spring软件存储库下载Spring CLI发行版:

    最前沿的分布式快照也是可用的。

    下载之后,请按照解压缩归档中的INSTALL.txt说明进行操作。 总之,在.zip文件的bin /目录中有一个spring脚本(用于Windows的spring.bat)。 或者,您可以使用带有.jar文件的java -jar(该脚本可以帮助您确保正确设置类路径)。

    10.2.2使用SDKMAN安装!

    SDKMAN! (软件开发工具包管理器)可用于管理各种二进制SDK的多个版本,包括Groovy和Spring Boot CLI。 获取SDKMAN! 从sdkman.io安装Spring Boot并使用以下命令:

    $ sdk install springboot
    $ spring --version
    Spring Boot v2.0.0.BUILD-SNAPSHOT

    如果您正在开发CLI的功能,并希望轻松访问您构建的版本,请使用以下命令:

    $ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin/spring-2.0.0.BUILD-SNAPSHOT/
    $ sdk default springboot dev
    $ spring --version
    Spring CLI v2.0.0.BUILD-SNAPSHOT

    前面的说明安装了一个名为dev实例的spring的本地实例。 它指向你的目标构建位置,所以每当你重建Spring Boot时,spring都是最新的。

    您可以通过运行以下命令来查看它:

    $ sdk ls springboot
    
    ================================================================================
    Available Springboot Versions
    ================================================================================
    > + dev
    * 2.0.0.BUILD-SNAPSHOT
    
    ================================================================================
    + - local version
    * - installed
    > - currently in use
    ================================================================================

    10.2.3 OSX Homebrew安装

    如果您在Mac上并使用Homebrew,则可以使用以下命令来安装Spring Boot CLI:
    Homebrew 安装 spring/usr/local/bin.

    注:如果您没有看到该公式,那么您的brew的安装可能会过期。 在这种情况下,运行brew更新并重试。

    10.2.4 MacPorts安装

    如果您在Mac上并使用MacPorts,则可以使用以下命令安装Spring Boot CLI:

    $ sudo port install spring-boot-cli
    

    10.2.5命令行完成

    Spring Boot CLI包含为BASH和zsh shell提供命令完成的脚本。 您可以在任何shell中获取脚本(也称为spring),或者将其放入您的个人或系统范围的bash完成初始化中。 在Debian系统上,系统范围的脚本在/ shell-completion / bash中,当一个新的shell启动时,该目录中的所有脚本都会被执行。 例如,如果您使用SDKMAN!安装了手动脚本,请使用以下命令:

    $ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
    $ spring <HIT TAB HERE>
      grab  help  jar  run  test  version

    注:如果使用Homebrew或MacPorts安装Spring Boot CLI,则命令行完成脚本会自动注册您的shell。

    10.2.6快速启动Spring CLI示例

    您可以使用以下Web应用程序来测试您的安装。 首先,创建一个名为app.groovy的文件,如下所示:

    @RestController
    class ThisWillActuallyRun {
    
        @RequestMapping("/")
        String home() {
            "Hello World!"
        }
    
    }

    然后从shell中运行它,如下所示:

    $ spring run app.groovy
    

    注:由于依赖的库需要下载,第一次运行会比较慢。

    打开 localhost:8080在您喜欢的浏览器中. 您将看到如下输出:

    Hello World!
    

    10.3从较早版本的Spring Boot升级

    如果您是从早期版本的Spring Boot进行升级,请查看项目wiki上托管的“发行说明”。 您会发现升级说明以及每个版本的“新功能”和“值得注意”功能列表。

    要升级现有的CLI安装,请使用相应的package manager命令(例如,brew升级),或者如果您手动安装了CLI,请按照标准说明记住更新PATH环境变量以删除任何旧的引用。

    11.开发你的第一个Spring Boot应用程序

    本节介绍如何开发一个简单的“Hello World!”Web应用程序,该应用程序突出了Spring Boot的一些主要功能。 我们使用Maven来构建这个项目,因为大多数IDE都支持它。

    注:spring.io网站包含许多使用Spring Boot的“入门指南”。 如果您需要解决特定问题,请先在那里查看。
    您可以通过转到start.spring.io并从依赖关系搜索器中选择“Web”起始器来快速执行以下步骤。 这样做会产生一个新的项目结构,以便您可以立即开始编码。 查看Spring Initializr文档以获取更多详细信息。

    在开始之前,请打开终端并运行以下命令以确保您已安装了Java和Maven的有效版本:

    $ java -version
    java version "1.8.0_102"
    Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
    Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)
    $ mvn -v
    Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-10T16:41:47+00:00)
    Maven home: /usr/local/Cellar/maven/3.3.9/libexec
    Java version: 1.8.0_102, vendor: Oracle Corporation

    此示例需要在其自己的文件夹中创建。 后续的说明假定你已经创建了一个合适的文件夹,并且它是你的“当前目录”。(windows环境下 提供Path路径即可)

    11.1创建POM

    我们需要从创建一个Maven pom.xml文件开始。 pom.xml是用来构建项目的配方。 打开你最喜欢的文本编辑器并添加以下内容:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.example</groupId>
        <artifactId>myproject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
        </parent>
    
        <!-- Additional lines to be added here... -->
    
        <!-- (you don't need this if you are using a .RELEASE version) -->
        <repositories>
            <repository>
                <id>spring-snapshots</id>
                <url>http://repo.spring.io/snapshot</url>
                <snapshots><enabled>true</enabled></snapshots>
            </repository>
            <repository>
                <id>spring-milestones</id>
                <url>http://repo.spring.io/milestone</url>
            </repository>
        </repositories>
        <pluginRepositories>
            <pluginRepository>
                <id>spring-snapshots</id>
                <url>http://repo.spring.io/snapshot</url>
            </pluginRepository>
            <pluginRepository>
                <id>spring-milestones</id>
                <url>http://repo.spring.io/milestone</url>
            </pluginRepository>
        </pluginRepositories>
    </project>

    上面的列表应该给你一个工作构建。 你可以通过运行mvn软件包来测试它(现在,你可以忽略“jar将是空的 - 没有内容被标记为包含!”警告)。

    注:此时,您可以将项目导入IDE(大多数现代Java IDE包含对Maven的内置支持)。 为了简单起见,我们继续在这个例子中使用纯文本编辑器。

    11.2添加类路径依赖关系

    Spring Boot提供了许多“入门”,可以让您将jar添加到类路径中。 我们的示例应用程序已经在POM的父节点中使用了spring-boot-starter-parentspring-boot-starter-parent是一个特别的启动器,提供了有用的Maven默认值。 它还提供了一个依赖管理部分,以便您可以省略版本标记以获得“有福”的依赖关系。

    其他“Starter”提供了在开发特定类型的应用程序时可能需要的依赖关系。 由于我们正在开发一个Web应用程序,因此我们添加了一个spring-boot-starter-web依赖项。 在此之前,我们可以通过运行以下命令来查看我们目前的状态:

    $ mvn dependency:tree
    
    [INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

    mvn依赖项:tree命令打印项目依赖项的树形表示。 你可以看到spring-boot-starter-parent本身不提供依赖关系。 要添加必要的依赖关系,请编辑您的pom.xml,并在父节点下方添加spring-boot-starter-web依赖项:

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    如果再次运行mvn dependency:tree,则会看到现在有很多附加依赖项,包括Tomcat Web服务器和Spring Boot本身。

    11.3编写代码

    为了完成我们的应用程序,我们需要创建一个Java文件。 默认情况下,Maven从src / main / java编译源代码,因此您需要创建该文件夹结构,然后添加名为src / main / java / Example.java的文件以包含以下代码:

    import org.springframework.boot.*;
    import org.springframework.boot.autoconfigure.*;
    import org.springframework.web.bind.annotation.*;
    
    @RestController
    @EnableAutoConfiguration
    public class Example {
    
        @RequestMapping("/")
        String home() {
            return "Hello World!";
        }
    
        public static void main(String[] args) throws Exception {
            SpringApplication.run(Example.class, args);
        }
    
    }

    虽然这里没有太多的代码,但还是有很多重要的事在里头。 我们将在接下来的几节中介绍一些重要的部分。

    11.3.1 @RestController和@RequestMapping注解

    我们的Example类的第一个注解是@RestController。 这被称为stereotype注解。 它为阅读代码的人提供了线索,对于Spring来说,这个类扮演着特定的角色。 在这种情况下,我们的类是一个web @Controller,所以Spring在处理传入的Web请求时会考虑它。

    @RequestMapping注解提供了“路由”信息。 它告诉Spring,任何带有/ path的HTTP请求都应该映射到home方法。@RestController注解告诉Spring将结果字符串直接返回给调用者。

    注:stereotype含义:
    表示类型或方法在整体架构中的角色(在概念层面而不是实施层面)。

    @RestController和@RequestMapping注解是Spring MVC注解(它们不是Spring Boot特有的)。 有关更多详细信息,请参阅Spring参考资料中的MVC部分。

    11.3.2 @EnableAutoConfiguration注解

    第二个类级注解是@EnableAutoConfiguration。 这个注解告诉Spring Boot根据你添加的jar依赖来“猜测”你将如何配置Spring。 由于spring-boot-starter-web添加了Tomcat和Spring MVC,所以自动配置会假定你正在开发一个Web应用程序并相应地设置Spring。

    入门和自动配置
    自动配置旨在与“启动器”配合使用,但这两个概念并不直接相关。 您可以自由选择和选择初学者之外的jar依赖项,并且Spring Boot将尽其所能地自动配置您的应用程序。

    11.3.3 “main” 方法

    我们的应用程序的最后一部分是主方法。 这只是一个遵循Java约定的应用程序入口点的标准方法。 我们的主要方法通过调用run来委托Spring Boot的SpringApplication类。 SpringApplication将引导我们的应用程序,从Spring开始,它将启动自动配置的Tomcat Web服务器。 我们需要将Example.class作为参数传递给run方法,以告知SpringApplication是Spring的主要组件。 args数组也被传递以暴露任何命令行参数。

    11.4运行示例

    在这一点上我们的应用程序应该工作 由于我们使用了spring-boot-starter-parent POM,所以我们有一个有用的运行目标,我们可以使用它来启动应用程序。 键入mvn spring-boot:从根项目目录运行以启动应用程序:

    $ mvn spring-boot:run
    
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::  (v1.5.9.RELEASE)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started Example in 2.222 seconds (JVM running for 6.514)

    如果你打开一个web浏览器到localhost:8080你应该看到下面的输出:

    Hello World!

    要正常退出应用程序点击ctrl-c

    11.5创建一个可执行的jar

    让我们通过创建一个完全独立的可执行jar文件来完成我们的例子,我们可以在生产环境中运行它。 可执行jar(有时也称为“fat jars”)是包含您编译的类以及您的代码需要运行的所有jar依赖项的归档文件。

    可执行的jar和Java
    
    Java不提供任何标准的方式来加载嵌套的jar文件(即jar文件本身包含在jar中)。 如果您正在分发自包含的应用程序,这可能会有问题。
    
    为了解决这个问题,许多开发者使用“超级”罐子。 超级罐子只是将所有罐子里的所有类打包成一个单一的档案。 这种方法的问题在于,很难在应用程序中看到实际使用的库。 如果在多个罐子中使用相同的文件名(但是具有不同的内容),则也可能是有问题的。
    
    Spring Boot采用了不同的方法,可以直接嵌入jar。

    要创建一个可执行的jar文件,我们需要将spring-boot-maven-plugin添加到我们的pom.xml。 在依赖关系部分下面插入以下几行:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    注:spring-boot-starter-parent POM包含配置来绑定重新打包目标。 如果您不使用父POM,则需要自行声明此配置。 有关详细信息,请参阅插件文档。

    保存你的pom.xml并从命令行运行mvn包:

    $ mvn package
    
    [INFO] Scanning for projects...
    [INFO]
    [INFO] ------------------------------------------------------------------------
    [INFO] Building myproject 0.0.1-SNAPSHOT
    [INFO] ------------------------------------------------------------------------
    [INFO] .... ..
    [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
    [INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
    [INFO]
    [INFO] --- spring-boot-maven-plugin:1.5.9.RELEASE:repackage (default) @ myproject ---
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------

    如果您查看目标目录,则应该看到myproject-0.0.1-SNAPSHOT.jar。 该文件大小应该在10 MB左右。 如果你想查阅里面的内容,你可以使用jar tvf:

    $ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
    

    您还应该在目标目录中看到一个名为myproject-0.0.1-SNAPSHOT.jar.original的小得多的文件。 这是Maven在被Spring Boot重新包装之前创建的原始jar文件。

    要运行该应用程序,请使用java -jar命令:

    $ java -jar target/myproject-0.0.1-SNAPSHOT.jar
    
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::  (v1.5.9.RELEASE)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started Example in 2.536 seconds (JVM running for 2.864)

    像以前一样,要优雅地退出应用程序点击ctrl-c

    12.接下来读什么

    希望本节为您提供了一些Spring Boot的基础知识,并帮助您编写自己的应用程序。 如果您是面向任务的开发人员,则可能需要跳至spring.io,并查看一些入门指南,以解决具体的“如何使用Spring”问题; 我们也有Spring Boot特定的操作指南文档。

    Spring Boot版本库也有一些你可以运行的样本。 样本独立于代码的其余部分(也就是说,您不需要构建其余的代码来运行或使用样本)。

    否则,下一个逻辑步骤是阅读第三部分“使用Spring Boot”。 如果你真的不耐烦,也可以跳过来阅读Spring Boot的特性。

    Part III. 使用Spring Boot


    本节将更详细地介绍如何使用Spring Boot。 它涵盖了构建系统,自动配置以及如何运行应用程序等主题。 我们还介绍了一些Spring Boot的最佳实践。 尽管Spring Boot没有什么特别的地方(它只是你可以使用的另一个库),但是有一些建议,如果遵循这些建议,将使开发过程变得更容易一些。

    如果您刚刚开始使用Spring Boot,则可能需要先阅读入门指南,然后再深入本节。

    13.建立系统

    强烈建议您选择支持依赖管理的构建系统,并且可以使用发布到“Maven Central”存储库的工件。 我们建议您选择Maven或Gradle。 Spring Boot可以与其他构建系统(例如Ant)一起工作,但是它们不会得到特别好的支持。

    13.1依赖管理

    Spring Boot的每个发行版都提供了一个支持的依赖列表。 在实践中,您不需要为构建配置中的任何这些依赖项提供一个版本,因为Spring Boot正在为您进行管理。 当您升级Spring Boot本身时,这些依赖关系也将以一致的方式升级。

    注:如果您觉得有必要,您仍然可以指定一个版本并覆盖Spring Boot的建议。

    助手列表包含您可以使用Spring Boot的所有Sping模块以及第三方库的精选列表。 该列表可以作为标准物料清单(spring-boot-dependencies)提供,也可以为Maven和Gradle提供额外的专用支持。

    注:Spring Boot的每个版本都与Spring Framework的基础版本相关联,因此我们强烈建议您不要自行指定其版本。

    13.2 Maven

    Maven用户可以从spring-boot-starter-parent项目继承,以获得合理的默认值。 父项目提供以下功能:

    • Java 1.6作为默认的编译器级别。
    • UTF-8源码编译。
    • 依赖管理部分,允许您省略继承自Spring-Boot-dependencies POM的通用依赖项的标记。明智的资源过滤。
    • 明智的插件配置((exec plugin, surefire, Git commit ID, shade)。
    • 对application.properties和application.yml进行明智的资源过滤,包括特定于配置文件的文件(例如application-foo.properties和application-foo.yml)

    最后一点:因为默认配置文件接受Spring样式占位符($ {…}),Maven过滤被改为使用@ .. @占位符(你可以用Maven属性resource.delimiter覆盖)。

    13.2.1继承初始父项

    要将项目配置为从spring-boot-starter-parent继承,只需设置父项:

    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>

    注:您应该只需要在此依赖项上指定Spring Boot版本号。 如果您导入更多的启动器,则可以安全地省略版本号。

    通过该设置,您还可以通过在自己的项目中重写属性来覆盖各个依赖项。 例如,要升级到另一个Spring Data发行版,您需要将以下内容添加到您的pom.xml中。

    <properties>
        <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
    </properties>

    注:检查spring-boot-dependencies pom支持的属性列表。

    13.2.2使用没有父POM的Spring Boot

    不是每个人都喜欢从spring-boot-starter-parent POM继承。 你可能有你自己的企业标准,你需要使用,或者你可能只是喜欢显式声明所有的Maven配置。

    如果您不想使用spring-boot-starter-parent,则仍然可以通过使用scope = import dependency来保留依赖项管理的好处:

    <dependencyManagement>
         <dependencies>
            <dependency>
                <!-- Import dependency management from Spring Boot -->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>1.5.9.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    如上所述,该设置不允许您使用属性覆盖单个依赖项。 为了达到同样的结果,你需要在spring-boot-dependencies条目之前在项目的dependencyManagement中添加一个条目。 例如,要升级到另一个Spring Data发行版,您需要将以下内容添加到您的pom.xml中。

    <dependencyManagement>
        <dependencies>
            <!-- Override Spring Data release train provided by Spring Boot -->
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-releasetrain</artifactId>
                <version>Fowler-SR2</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>1.5.9.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    注:在上面的例子中,我们指定了一个BOM,但是任何依赖类型都可以被覆盖。

    13.2.3更改Java版本

    spring-boot-starter-parent选择相当保守的Java兼容性。 如果您想遵循我们的建议并使用较新的Java版本,则可以添加一个java.version属性:

    <properties>
        <java.version>1.8</java.version>
    </properties>

    13.2.4使用Spring Boot Maven插件

    Spring Boot包含一个Maven插件,可以将项目打包为可执行的jar文件。 如果你想使用它,请将插件添加到部分:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    注:如果你使用Spring Boot的启动父POM,只需要添加插件,除非你想改变在父代中定义的设置,否则不需要进行配置。

    13.3 Gradle

    Gradle用户可以在他们的依赖项部分直接导入’starters’。 与Maven不同的是,没有“超级父母”可以导入来共享某些配置。

    repositories {
        jcenter()
    }
    
    dependencies {
        compile("org.springframework.boot:spring-boot-starter-web:1.5.9.RELEASE")
    }

    spring-boot-gradle-plugin也是可用的,并提供了创建可执行的jar和从源代码运行项目的任务。 它还提供依赖性管理,除其他功能外,还允许您省略由Spring Boot管理的任何依赖项的版本号:

    plugins {
        id 'org.springframework.boot' version '1.5.9.RELEASE'
        id 'java'
    }
    
    
    repositories {
        jcenter()
    }
    
    dependencies {
        compile("org.springframework.boot:spring-boot-starter-web")
        testCompile("org.springframework.boot:spring-boot-starter-test")
    }

    13.4Ant

    可以使用Apache Ant + Ivy构建Spring Boot项目。 spring-boot-antlib“AntLib”模块也可以帮助Ant创建可执行的jar文件。

    为了声明依赖关系,一个典型的ivy.xml文件将如下所示:

    <ivy-module version="2.0">
        <info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
        <configurations>
            <conf name="compile" description="everything needed to compile this module" />
            <conf name="runtime" extends="compile" description="everything needed to run this module" />
        </configurations>
        <dependencies>
            <dependency org="org.springframework.boot" name="spring-boot-starter"
                rev="${spring-boot.version}" conf="compile" />
        </dependencies>
    </ivy-module>

    一个典型的`build.xml“将如下所示:

    <project
        xmlns:ivy="antlib:org.apache.ivy.ant"
        xmlns:spring-boot="antlib:org.springframework.boot.ant"
        name="myapp" default="build">
    
        <property name="spring-boot.version" value="1.5.9.RELEASE" />
    
        <target name="resolve" description="--> retrieve dependencies with ivy">
            <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" />
        </target>
    
        <target name="classpaths" depends="resolve">
            <path id="compile.classpath">
                <fileset dir="lib/compile" includes="*.jar" />
            </path>
        </target>
    
        <target name="init" depends="classpaths">
            <mkdir dir="build/classes" />
        </target>
    
        <target name="compile" depends="init" description="compile">
            <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" />
        </target>
    
        <target name="build" depends="compile">
            <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes">
                <spring-boot:lib>
                    <fileset dir="lib/runtime" />
                </spring-boot:lib>
            </spring-boot:exejar>
        </target>
    </project>

    注:如果您不想使用spring-boot-antlib模块,请参见第84.10节“从Ant构建不使用spring-boot-antlib的可执行文件”。

    13.5起动

    启动器是一套方便的依赖描述符,可以包含在应用程序中。 您可以获得所需的所有Spring及相关技术的一站式服务,无需搜索示例代码,也不需要粘贴依赖关系描述符。 例如,如果你想开始使用Spring和JPA来访问数据库,只需在你的项目中加入spring-boot-starter-data-jpa依赖项,你就可以开始了。

    初学者包含很多依赖项,您需要快速启动并运行一个项目,并使用一组支持的传递依赖项。

    命名原则

    所有官方首发者都遵循类似的命名模式; spring-boot-starter-,其中是特定类型的应用程序。 这种命名结构旨在帮助您找到启动器。 许多IDE中的Maven集成允许您按名称搜索依赖项。 例如,安装适当的Eclipse或STS插件后,只需在POM编辑器中点击ctrl-space并键入“spring-boot-starter”即可获得完整列表。

    正如创建自己的启动器部分中所解释的,第三方启动器不应该以spring-boot开始,因为它是为官方的Spring Boot工件保留的。 acme的第三方初学者通常被命名为acme-spring-boot-starter

    以下应用程序启动程序由Spring Boot在org.springframework.boot组下提供:

    表13.1。 Spring Boot应用程序启动器(链接实在太多 ,下次再补)

    项目名描述Pom
    spring-boot-starterCore starter, including auto-configuration support, logging and YAMLPom
    spring-boot-starter-activemqStarter for JMS messaging using Apache ActiveMQPom
    spring-boot-starter-amqpStarter for using Spring AMQP and Rabbit MQPom
    spring-boot-starter-aopStarter for aspect-oriented programming with Spring AOP and AspectJPom
    spring-boot-starter-artemisStarter for JMS messaging using Apache ArtemisPom
    spring-boot-starter-batchStarter for using Spring BatchPom
    spring-boot-starter-cacheStarter for using Spring Framework’s caching supportPom
    spring-boot-starter-cloud-connectorsStarter for using Spring Cloud Connectors which simplifies connecting to services in cloud platforms like Cloud Foundry and HerokuPom
    spring-boot-starter-data-cassandraStarter for using Cassandra distributed database and Spring Data CassandraPom
    zebra stripesStarter for using Cassandra distributed database and Spring Data CassandraPom
    spring-boot-starter-data-couchbaseStarter for using Couchbase document-oriented database and Spring Data CouchbasePom
    spring-boot-starter-data-elasticsearchStarter for using Elasticsearch search and analytics engine and Spring Data ElasticsearchPom
    spring-boot-starter-data-gemfireStarter for using GemFire distributed data store and Spring Data GemFirePom
    spring-boot-starter-data-jpaStarter for using Spring Data JPA with HibernatePom
    spring-boot-starter-data-ldapStarter for using Spring Data LDAPPom
    spring-boot-starter-data-mongodbStarter for using MongoDB document-oriented database and Spring Data MongoDBPom
    spring-boot-starter-data-neo4jStarter for using Neo4j graph database and Spring Data Neo4jPom
    spring-boot-starter-data-redisStarter for using Redis key-value data store with Spring Data Redis and the Jedis clientPom
    spring-boot-starter-data-restStarter for exposing Spring Data repositories over REST using Spring Data RESTPom
    spring-boot-starter-data-solrStarter for using the Apache Solr search platform with Spring Data SolrPom
    spring-boot-starter-freemarkerStarter for building MVC web applications using FreeMarker viewsPom
    spring-boot-starter-groovy-templatesStarter for building MVC web applications using Groovy Templates viewsPom
    spring-boot-starter-hateoasStarter for building hypermedia-based RESTful web application with Spring MVC and Spring HATEOASPom
    spring-boot-starter-integrationStarter for using Spring IntegrationPom
    spring-boot-starter-jdbcStarter for using JDBC with the Tomcat JDBC connection poolPom
    spring-boot-starter-jerseyStarter for building RESTful web applications using JAX-RS and Jersey. An alternative to spring-boot-starter-webPom
    spring-boot-starter-jooqStarter for using jOOQ to access SQL databases. An alternative to spring-boot-starter-data-jpa or spring-boot-starter-jdbcPom
    spring-boot-starter-jta-atomikosStarter for JTA transactions using AtomikosPom
    spring-boot-starter-jta-bitronixStarter for JTA transactions using BitronixPom
    spring-boot-starter-jta-narayanaSpring Boot Narayana JTA StarterPom
    spring-boot-starter-mailStarter for using Java Mail and Spring Framework’s email sending supportPom
    spring-boot-starter-mobileStarter for building web applications using Spring MobilePom
    spring-boot-starter-mustacheStarter for building MVC web applications using Mustache viewsPom
    spring-boot-starter-securityStarter for using Spring SecurityPom
    spring-boot-starter-social-facebookStarter for using Spring Social FacebookPom
    spring-boot-starter-social-linkedinStater for using Spring Social LinkedInPom
    spring-boot-starter-social-twitterStarter for using Spring Social TwitterPom
    spring-boot-starter-testStarter for testing Spring Boot applications with libraries including JUnit, Hamcrest and MockitoPom
    spring-boot-starter-thymeleafStarter for building MVC web applications using Thymeleaf viewsPom
    spring-boot-starter-validationStarter for using Java Bean Validation with Hibernate ValidatorPom
    spring-boot-starter-webStarter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded containerPom
    spring-boot-starter-web-servicesStarter for using Spring Web ServicesPom
    spring-boot-starter-websocketStarter for building WebSocket applications using Spring Framework’s WebSocket supportPom


    除了应用程序启动器之外,还可以使用以下启动器来添加生产准备功能:

    表13.2。 Spring Boot生产启动器

    项目名描述Pom
    spring-boot-starter-actuatorStarter for using Spring Boot’s Actuator which provides production ready features to help you monitor and manage your applicationPom
    spring-boot-starter-remote-shellStarter for using the CRaSH remote shell to monitor and manage your application over SSH. Deprecated since 1.5Pom


    最后,Spring Boot还包括一些可以用来排除或交换特定技术方面的入门知识:

    项目名描述Pom
    spring-boot-starter-jettyStarter for using Jetty as the embedded servlet container. An alternative to spring-boot-starter-tomcatPom
    spring-boot-starter-log4j2Starter for using Log4j2 for logging. An alternative to spring-boot-starter-loggingPom
    spring-boot-starter-loggingStarter for logging using Logback. Default logging starterPom
    spring-boot-starter-tomcatStarter for using Tomcat as the embedded servlet container. Default servlet container starter used by spring-boot-starter-webPom
    spring-boot-starter-undertowStarter for using Undertow as the embedded servlet container. An alternative to spring-boot-starter-tomcatPom

    注:有关其他社区贡献者的列表,请参阅GitHub上的spring-boot-starters模块中的README文件。

    14.构建你的代码

    Spring Boot不需要任何特定的代码布局,但是,有一些最佳实践可以提供帮助。

    14.1使用“默认”软件包

    当一个类不包含包声明时,它被认为是在“默认包”中。 通常不鼓励使用“默认软件包”,应该避免使用“默认软件包”。 对于使用@ComponentScan,@EntityScan或@SpringBootApplication注解的Spring Boot应用程序来说,这可能会导致特定的问题,因为每个jar的每个类都将被读取。

    注:我们建议您遵循Java推荐的软件包命名约定,并使用反向域名(例如,com.example.project)。

    14.2找到主应用程序类

    我们通常建议您将主应用程序类放在其他类的根包中。 @EnableAutoConfiguration注解通常放在主类上,它隐式地为某些项目定义了一个基本的“搜索包”。 例如,如果您正在编写JPA应用程序,则@EnableAutoConfiguration注解类的包将用于搜索@Entity项目。

    使用根包也允许使用@ComponentScan注解而不需要指定basePackage属性。 如果您的主类位于根包中,也可以使用@SpringBootApplication注解。

    这是一个典型的布局:

    com
     +- example
         +- myproject
             +- Application.java
             |
             +- domain
             |   +- Customer.java
             |   +- CustomerRepository.java
             |
             +- service
             |   +- CustomerService.java
             |
             +- web
                 +- CustomerController.java

    Application.java文件将声明main方法以及基本的@Configuration

    package com.example.myproject;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @EnableAutoConfiguration
    @ComponentScan
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }

    15.配置类

    Spring Boot支持基于Java的配置。 虽然可以使用XML源调用SpringApplication.run(),但我们通常建议您的主要来源是@Configuration类。 通常,定义main方法的类也是主要@Configuration的一个好候选。

    注:在互联网上已经发布了许多使用XML配置的Spring配置示例。 如果可能,请始终尝试使用基于Java的等效配置。 搜索启用*注解可以是一个很好的起点。

    15.1导入其他配置类

    你不需要把所有的@Configuration放到一个类中。 @Import注解可用于导入其他配置类。 或者,您可以使用@ComponentScan自动获取所有Spring组件,包括@Configuration类。

    15.2导入XML配置

    如果您必须使用基于XML的配置,我们建议您仍以@Configuration类开头。 然后您可以使用额外的@ImportResource注解来加载XML配置文件。

    16.自动配置

    Spring Boot自动配置会尝试根据您添加的jar依赖项自动配置您的Spring应用程序。 例如,如果HSQLDB在您的类路径中,并且您没有手动配置任何数据库连接Bean,则Spring Boot会自动配置内存数据库。

    您需要通过将@EnableAutoConfiguration或@SpringBootApplication注解添加到其中一个@Configuration类来选择自动配置。

    注:您应该只添加一个@EnableAutoConfiguration注解。 我们通常建议您将其添加到您的主@Configuration类。

    16.1逐渐更换自动配置

    自动配置是非侵入式的。 在任何时候,您都可以开始定义自己的配置来替换自动配置的特定部分。 例如,如果添加您自己的DataSource Bean,则默认的嵌入式数据库支持会被取消。

    如果您需要了解当前正在应用的自动配置,以及为什么使用–debug开关启动您的应用程序。 这样做可以启用调试日志以选择核心记录器,并将条件报告记录到控制台。

    16.2禁用特定的自动配置类

    如果您发现不需要的特定自动配置类正在应用,则可以使用@EnableAutoConfiguration的exclude属性来禁用它们,如以下示例所示:

    import org.springframework.boot.autoconfigure.*;
    import org.springframework.boot.autoconfigure.jdbc.*;
    import org.springframework.context.annotation.*;
    
    @Configuration
    @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
    public class MyConfiguration {
    }

    如果类不在类路径中,则可以使用注解的excludeName属性,并指定完全限定的名称。 最后,您还可以使用spring.autoconfigure.exclude属性来控制要排除的自动配置类的列表。

    注:您可以在注解级别和通过使用属性来定义排除。

    17.Spirng bean和依赖注入

    您可以自由使用任何标准的Spring框架技术来定义您的bean及其注入的依赖关系。 为了简单起见,我们经常发现使用@ComponentScan(查找你的bean)和使用@Autowired(做构造函数注入)。

    如果按上面的建议构建代码(在根包中查找应用程序类),则可以添加@ComponentScan而不带任何参数。 所有的应用程序组件(@Component@Service@Repository@Controller等)都会自动注册为Spring Beans。

    以下示例显示了一个@Service Bean,它使用构造函数注入来获取所需的RiskAssessor bean:

    package com.example.service;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class DatabaseAccountService implements AccountService {
    
        private final RiskAssessor riskAssessor;
    
        @Autowired
        public DatabaseAccountService(RiskAssessor riskAssessor) {
            this.riskAssessor = riskAssessor;
        }
    
        // ...
    
    }

    如果一个bean只有一个构造函数,则可以省略@Autowired,如下例所示:

    @Service
    public class DatabaseAccountService implements AccountService {
    
        private final RiskAssessor riskAssessor;
    
        public DatabaseAccountService(RiskAssessor riskAssessor) {
            this.riskAssessor = riskAssessor;
        }
    
        // ...
    

    注:注意如何使用构造函数注入让riskAssessor字段被标记为final,表明它不能被随后改变。

    18.使用@SpringBootApplication注解

    许多Spring Boot开发人员总是使用@Configuration@EnableAutoConfiguration@ComponentScan注解其主类。 由于这些注释经常一起使用(特别是如果您遵循以上最佳实践),Spring Boot提供了一种方便的@SpringBootApplication替代方法。

    @SpringBootApplication注释等同于使用@Configuration@EnableAutoConfiguration@ComponentScan及其默认属性,如以下示例所示:

    package com.example.myapplication;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }

    注:@SpringBootApplication还提供别名来自定义@EnableAutoConfiguration和@ComponentScan的属性。

    19.运行您的应用程序

    将应用程序封装为jar并使用嵌入式HTTP服务器的最大优点之一是,您可以像运行其他应用程序一样运行应用程序。 调试Spring Boot应用程序也很容易。 您不需要任何特殊的IDE插件或扩展。

    注:本节仅介绍基于jar的包装。 如果您选择将应用程序打包为war文件,则应参考您的服务器和IDE文档。

    19.1从IDE运行

    您可以从IDE运行Spring Boot应用程序作为一个简单的Java应用程序。 但是,您首先需要导入您的项目。 导入步骤取决于您的IDE和构建系统。 大多数IDE可以直接导入Maven项目。 例如,Eclipse用户可以从File菜单中选择Import …→Existing Maven Projects。

    如果不能直接将项目导入IDE,则可以使用构建插件生成IDE元数据。 Maven包含Eclipse和IDEA的插件。 Gradle为各种IDE提供插件。

    提示:如果您意外运行两次Web应用程序,则会看到“端口已被使用”错误。 STS用户可以使用“重新启动”按钮而不是“运行”按钮来确保关闭任何现有的实例。

    19.2作为打包应用程序运行

    如果您使用Spring Boot Maven或Gradle插件创建可执行jar,则可以使用java -jar运行应用程序,如以下示例所示:

    >$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar

    也可以运行打包的应用程序并启用远程调试支持。 这样做可以让您将调试器附加到打包的应用程序,如以下示例所示:

    $ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
           -jar target/myapplication-0.0.1-SNAPSHOT.jar

    19.3使用Maven插件

    Spring Boot Maven插件包含一个可用于快速编译和运行应用程序的运行目标。 应用程序以分解形式运行,就像在IDE中一样。

    $ mvn spring-boot:run
    

    您可能还想使用MAVEN_OPTS操作系统环境变量,如以下示例所示:

    $ export MAVEN_OPTS=-Xmx1024m
    

    19.4使用Gradle插件

    Spring Boot Gradle插件还包含一个bootRun任务,可用于以分解形式运行您的应用程序。 无论何时应用org.springframework.boot和java插件,都会添加bootRun任务,并显示在以下示例中:

    $ gradle bootRun
    

    您可能还想使用JAVA_OPTS操作系统环境变量,如以下示例所示:

    $ export JAVA_OPTS=-Xmx1024m
    

    19.5热插拔

    由于Spring Boot应用程序只是普通的Java应用程序,所以JVM热插拔应该是开箱即用的。 JVM热插拔在可以替换的字节码方面有一定的局限性。 对于更完整的解决方案,可以使用JRebel

    spring-boot-devtools模块还包括对快速应用程序重新启动的支持。 有关详细信息,请参阅下面的第20章开发人员工具部分以及热插拔“操作方法”。

    20.开发工具

    Spring Boot包含一组额外的工具,可以使应用程序开发体验更愉快。 spring-boot-devtools模块可以包含在任何项目中以提供额外的开发时间功能。 要包含devtools支持,请将模块依赖关系添加到您的构建中,如Maven和Gradle的以下列表所示:

    Maven

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    Gradle

    dependencies {
        compile("org.springframework.boot:spring-boot-devtools")
    }

    注意:运行完整打包的应用程序时,开发人员工具会自动禁用 如果您的应用程序是使用java -jar启动的,或者是从特定的类加载器启动的,那么它就被认为是“生产应用程序”。 将依赖关系标记为可选项是一种最佳实践,可以防止devtools通过项目传递到其他模块。 Gradle不支持可选的依赖关系,因此您可能需要查看propdeps-plugin。

    提示:重新打包的archives 在默认情况下不包含devtools。 如果要使用某个远程devtools功能,则需要禁用excludeDevtools构建属性以包含它。 该属性支持Maven和Gradle插件。

    20.1属性默认值

    Spring Boot支持的一些库使用缓存来提高性能。 例如,模板引擎缓存已编译的模板以避免重复解析模板文件。 此外,Spring MVC可以在服务静态资源时将HTTP缓存头添加到响应中。

    虽然缓存在生产中非常有益,但是在开发过程中可能会起到反作用,使您无法看到您在应用程序中所做的更改。 为此,spring-boot-devtools默认禁用缓存选项。

    缓存选项通常由您的application.properties文件中的设置进行配置。 例如,Thymeleaf提供了spring.thymeleaf.cache属性。 spring-boot-devtools模块不需要手动设置这些属性,而是自动应用合理的开发时间配置。

    注意:有关由devtools应用的属性的完整列表,请参阅DevToolsPropertyDefaultsPostProcessor

    20.2自动重启

    当类路径上的文件发生变化时,使用spring-boot-devtools的应用程序会自动重启。 在IDE中工作时,这可能是一个有用的功能,因为它为代码更改提供了一个非常快速的反馈循环。 默认情况下,监视指向文件夹的类路径上的任何条目以进行更改。 请注意,某些资源(如静态资产和视图模板)不需要重新启动应用程序。

    触发重启
    
    由于DevTools监视类路径资源,触发重启的唯一方法是更新类路径。 导致类路径更新的方式取决于您使用的IDE。 在Eclipse中,保存修改后的文件将导致类路径更新并触发重启。 在IntelliJ IDEA中,构建项目(Build - > Make Project)具有相同的效果。

    注意:只要分叉被启用,你也可以使用受支持的构建插件(Maven和Gradle)来启动你的应用程序,因为DevTools需要一个独立的应用程序类加载器才能正常运行。默认情况下,当Gradle和Maven检测到类路径上的DevTools时,它们会这样做。

    提示:与LiveReload一起使用时,自动重新启动的效果非常好。有关详细信息,请参阅LiveReload部分。如果使用JRebel,则自动重新启动将被禁用,以支持动态类重新加载。其他devtools功能(如LiveReload和属性覆盖)仍然可以使用。

    注意:DevTools依靠应用程序上下文的关闭hook在重新启动期间关闭它。如果您禁用了关闭hook(SpringApplication.setRegisterShutdownHook(false)),它将无法正常工作。

    注意:当确定类路径上的条目在更改时会触发重新启动时,DevTools会自动忽略名为spring-boot,spring-boot-devtools,spring-boot-autoconfigure,spring-boot-actuator和spring-boot-starter的项目。

    注意:DevTools需要自定义ApplicationContext使用的ResourceLoader。如果你的应用程序已经提供了一个,它将被包装。不支持直接覆盖ApplicationContext上的getResource方法。

    重新启动vs重新加载
    
    Spring Boot提供的重启技术通过使用两个类加载器来工作。 不改变的类(例如来自第三方jar的类)被加载到基类加载器中。 您正在开发的类将加载到重启类加载器中。 当应用程序重新启动时,重启classloader被丢弃,并创建一个新的。 这种方法意味着应用程序重新启动通常比“冷启动”快得多,因为基类加载器已经可用并且已经被填充了。
    
    如果您发现重新启动对于您的应用程序来说不够快,或者遇到类加载问题,则可以考虑从ZeroTurnaround中重新加载技术,例如JRebel。 这些工作通过重写类,因为他们被加载,使他们更容易重新加载。

    20.2.1记录条件评估中的变化

    默认情况下,每次重新启动应用程序时,都会记录显示条件评估增量的报告。 该报告显示了对应用程序的自动配置进行的更改,例如添加或删除Bean以及设置配置属性。

    要禁用报告的记录,请设置以下属性:

    spring.devtools.restart.log-condition-evaluation-delta=false
    

    20.2.2排除资源

    某些资源不一定需要在更改时触发重新启动。 例如,Thymeleaf模板可以就地编辑。 默认情况下,更改/ META-INF / maven,/ META-INF / resources,/ resources,/ static,/ public或/ templates中的资源不会触发重新启动,但会触发实时重新加载。 如果您想要自定义这些排除,可以使用spring.devtools.restart.exclude属性。 例如,要仅排除/ static和/ public,您将设置以下属性:

    spring.devtools.restart.exclude=static/**,public/**
    

    提示:如果要保留这些默认值并添加其他排除项,请改为使用spring.devtools.restart.additional-exclude属性。

    20.2.3观察其他路径

    您可能希望在更改不在类路径中的文件时重新启动或重新加载应用程序。 为此,请使用spring.devtools.restart.additional-paths属性来配置其他路径以监视更改。 您可以使用上述的spring.devtools.restart.exclude属性来控制额外路径下的更改是触发完全重新启动还是实时重新加载。

    20.2.4禁用重启

    如果您不想使用重新启动功能,则可以使用spring.devtools.restart.enabled属性将其禁用。 在大多数情况下,您可以在application.properties中设置此属性(这样做仍会初始化重新启动类加载器,但不会监视文件更改)。

    如果您需要完全禁用重新启动支持(例如,因为它不适用于特定的库),则需要在调用SpringApplication.run(…)之前将spring.devtools.restart.enabled System属性设置为false, 如以下示例所示:

    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "false");
        SpringApplication.run(MyApp.class, args);
    }

    20.2.5使用触发文件

    如果您在IDE中工作,并尝试连续更改文件,则可能只希望在特定时间触发重新启动。 为此,您可以使用“触发文件”,这是一个特殊的文件,当您想要实际触发重新启动检查时,该文件必须被修改。 只更改文件会触发检查,只有Devtools检测到必须执行某些操作时才会重新启动。 触发器文件可以手动更新或使用IDE插件。

    要使用触发器文件,请将spring.devtools.restart.trigger-file属性设置为触发器文件的路径。

    提示:您可能希望将spring.devtools.restart.trigger-file设置为全局设置,以便所有项目的行为方式相同。

    20.2.6自定义重启类加载器

    如上面的重新启动vs重新加载部分所述,重新启动功能是通过使用两个类加载器来实现的。对于大多数应用程序来说,这种方法运行良好但是,有时会导致类加载问题。

    默认情况下,IDE中的任何打开的项目都会加载“restart”类加载器,而任何常规的.jar文件都会加载“base”类加载器。如果您使用多模块项目,而不是每个模块都导入到IDE中,则可能需要自定义。为此,您可以创建一个META-INF / spring-devtools.properties文件。

    spring-devtools.properties文件可以包含前缀为restart.exclude和restart.include的属性。 include元素是应该被拉入到“重启”类加载器中的项目,排除元素是应该被下推到“基本”类加载器中的项目。该属性的值是应用于类路径的正则表达式模式,如以下示例所示:

    restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
    restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

    注意:所有的 property keys 必须是唯一的。 只要属性以restart.include开头。 或restart.exclude。都 已经被考虑了。


    注意:所有类路径中的META-INF / spring-devtools.properties都将被加载。 您可以将文件打包到项目中,也可以打包到项目使用的库中。

    21.打包您的应用

    可执行的jar可用于生产部署。 由于它们是独立的,因此它们也非常适合基于云的部署。

    对于额外的“生产准备”功能,例如运行状况,审计和公制REST或JMX端点,请考虑添加Spring boot执行器。 有关详细信息,请参阅第五部分“执行器:生产就绪功能”。

    22.下一步阅读什么

    您现在应该了解如何使用Spring Boot以及您应遵循的一些最佳实践。 您现在可以继续深入了解特定的Spring Boot功能,或者可以跳过并阅读Spring Boot的“生产准备”部分。

    Part IV Spring Boot功能


    本节将深入探讨Spring Boot的细节。 在这里,您可以了解您可能想要使用和定制的关键功能。 如果您还没有这样做,您可能需要阅读“第二部分”,入门指南“”和“第三部分”,使用Spring Boot“”部分,以便您具备良好的基础知识。

    23. SpringApplication

    SpringApplication类提供了一种方便的方式来引导从main()方法启动的Spring应用程序。 在许多情况下,您可以委托给静态的SpringApplication.run方法,如下例所示:

    public static void main(String[] args) {
        SpringApplication.run(MySpringConfiguration.class, args);
    }

    当您的应用程序启动时,您应该看到类似于以下输出的内容:

     .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::   v2.0.0.BUILD-SNAPSHOT
    
    2013-07-31 00:08:16.117  INFO 56603 --- [           main] o.s.b.s.app.SampleApplication            : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
    2013-07-31 00:08:16.166  INFO 56603 --- [           main] ationConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
    2014-03-04 13:09:54.912  INFO 41370 --- [           main] .t.TomcatServletWebServerFactory : Server initialized with port: 8080
    2014-03-04 13:09:56.501  INFO 41370 --- [           main] o.s.b.s.app.SampleApplication            : Started SampleApplication in 2.992 seconds (JVM running for 3.658)

    默认情况下,会显示INFO日志消息,其中包括一些相关的启动详细信息,例如启动应用程序的用户。

    23.1启动失败

    如果您的应用程序无法启动,已注册的FailureAnalyzers将有机会提供专门的错误消息和具体操作来解决问题。 例如,如果在端口8080上启动Web应用程序,并且该端口已被使用,则应该看到类似于以下消息的内容:

    ***************************
    APPLICATION FAILED TO START
    ***************************
    
    Description:
    
    Embedded servlet container failed to start. Port 8080 was already in use.
    
    Action:
    
    Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

    注:Spring Boot提供了大量的错误分析实现,您可以添加自己的。

    如果没有故障分析仪能够处理异常情况,您仍然可以显示完整的情况报告,以更好地了解出了什么问题。 为此,您需要为org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener启用调试属性或启用DEBUG日志记录。

    例如,如果使用java -jar运行应用程序,则可以按如下所示启用调试属性:

    $ java -jar myproject-0.0.1-SNAPSHOT.jar --debug
    

    23.2自定义横幅

    启动时打印的横幅可以通过将banner.txt文件添加到类路径中或通过将spring.banner.location属性设置为此类文件的位置来更改。 如果文件的编码不是UTF-8,可以设置spring.banner.charset。 除了文本文件之外,还可以将banner.gif,banner.jpg或banner.png图像文件添加到您的类路径或设置spring.banner.image.location属性。 图像被转换成ASCII艺术表现形式,并打印在任何文字横幅上方。

    在您的banner.txt文件中,您可以使用以下任何占位符:

    变量说明
    ${application.version}在MANIFEST.MF中声明的应用程序的版本号。 例如,Implementation-Version:1.0打印为1.0。
    ${application.formatted-version}您的应用程序的版本号,如MANIFEST.MF中所声明的,并进行格式化以显示(用括号括起来并以v作为前缀)。 例如(v1.0)。
    ${spring-boot.version}您正在使用的Spring Boot版本。 例如2.0.0.BUILD-SNAPSHOT。
    ${spring-boot.formatted-version}您正在使用的Spring Boot版本,格式化为显示(用括号括起来并以v作为前缀)。 例如(v2.0.0.BUILD-SNAPSHOT)。
    ${application.title}在MANIFEST.MF中声明的应用程序的标题。 例如Implementation-Title:MyApp被打印为MyApp。

    提示:如果要以编程方式生成横幅,则可以使用SpringApplication.setBanner(…)方法。 使用org.springframework.boot.Banner接口并实现自己的printBanner()方法。

    288/5000
    您还可以使用spring.main.banner-mode属性来确定横幅是否必须在System.out(控制台)上打印,发送到配置的记录器(日志),还是根本不生成(关闭)。

    打印的横幅在以下名称下注册为singleton bean:springBootBanner。

    注:YAML映射为false,因此如果要禁用应用程序中的横幅,请务必添加引号。

    • spring:
      • main:
        • banner-mode: “off”

    23.3定制SpringApplication

    如果SpringApplication默认不符合您的喜好,您可以创建一个本地实例并对其进行自定义。 例如,要关闭横幅,你可以写:

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MySpringConfiguration.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }

    注:传递给SpringApplication的构造函数参数是spring bean的配置源。 在大多数情况下,它们都是对@Configuration类的引用,但也可能是对XML配置的引用或应该扫描的包。

    也可以通过使用application.properties文件来配置SpringApplication。 有关详细信息,请参阅第24章,外部化配置。

    有关配置选项的完整列表,请参阅SpringApplication Javadoc。

    23.4 Fluent Builder API(流利的建造者API模式)

    如果您需要构建一个ApplicationContext层次结构(具有父/子关系的多个上下文),或者您只需要使用“流利”构建器API,则可以使用SpringApplicationBuilder。

    SpringApplicationBuilder允许将多个方法调用链接在一起,并包含可以创建层次结构的父级和子级方法,如以下示例所示:

    new SpringApplicationBuilder()
            .sources(Parent.class)
            .child(Application.class)
            .bannerMode(Banner.Mode.OFF)
            .run(args);

    注:创建ApplicationContext层次结构时有一些限制。 例如,Web组件必须包含在子上下文中,并且父环境和子环境都使用相同的环境。 有关完整的细节,请参阅SpringApplicationBuilder Javadoc。

    23.5应用程序事件和监听器

    除了通常的Spring框架事件,比如ContextRefreshedEventSpringApplication还会发送一些附加的应用程序事件。

    注:有些事件实际上是在创建ApplicationContext之前触发的,因此您不能将这些监听器注册为@Bean。 您可以使用SpringApplication.addListeners(…)或SpringApplicationBuilder.listeners(…)方法注册它们。

    如果您希望自动注册这些侦听器,无论创建应用程序的方式如何,都可以将META-INF / spring.factories文件添加到您的项目中,并使用org.springframework.context引用您的侦听器。 ApplicationListener键,如以下示例所示:

    org.springframework.context.ApplicationListener= com.example.project.MyListener

    应用程序事件按照以下顺序发送,就像您的应用程序运行一样:

    1. ApplicationStartingEvent在运行开始时发送,除了注册监听器和初始化器之外的任何处理之前。
    2. 当在上下文中使用的环境是已知的但在创建上下文之前发送ApplicationEnvironmentPreparedEvent。
    3. ApplicationPreparedEvent在刷新开始之前,但在bean定义加载之后发送。
    4. 在刷新之后发送ApplicationReadyEvent并处理任何相关的回调,以指示应用程序已准备好为请求提供服务。
    5. 如果启动时出现异常,则发送ApplicationFailedEvent。

    注:您不需要经常使用应用程序事件,但可以方便地知道它们存在。 在内部,Spring Boot使用事件来处理各种任务。

    应用程序事件是通过使用Spring框架的事件发布机制发送的。 这种机制的一部分确保发布给子上下文中监听器的事件也发布给任何祖先上下文中的监听器。 因此,如果您的应用程序使用SpringApplication实例的层次结构,则侦听器可能会收到同一类型应用程序事件的多个实例。

    为了让你的监听器区分上下文的事件和后代上下文的事件,它应该请求它的应用上下文被注入,然后比较注入的上下文和事件的上下文。 上下文可以通过实现ApplicationContextAware来注入,或者如果侦听器是一个bean,可以通过使用@Autowired注入。

    23.6 Web环境

    SpringApplication试图代表你创建正确类型的ApplicationContext。 默认情况下,使用AnnotationConfigApplicationContext或AnnotationConfigServletWebServerApplicationContext,具体取决于您是否正在开发Web应用程序。

    用来确定“网络环境”的算法相当简单(它基于几个类的存在)。 如果您需要覆盖默认值,可以使用setWebEnvironment(boolean webEnvironment)。

    也可以通过调用setApplicationContextClass(…)来完全控制ApplicationContext类型。

    提示:在JUnit测试中使用SpringApplication时,通常需要调用setWebEnvironment(false)。

    23.7访问应用程序参数

    如果您需要访问传递给SpringApplication.run(…)的应用程序参数,则可以注入一个org.springframework.boot.ApplicationArguments bean。 ApplicationArguments接口提供对原始String []参数以及解析的选项和非选项参数的访问,如以下示例所示:

    import org.springframework.boot.*
    import org.springframework.beans.factory.annotation.*
    import org.springframework.stereotype.*
    
    @Component
    public class MyBean {
    
        @Autowired
        public MyBean(ApplicationArguments args) {
            boolean debug = args.containsOption("debug");
            List<String> files = args.getNonOptionArgs();
            // if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
        }
    
    }

    提示:Spring Boot还向Spring环境注册了一个CommandLinePropertySource。 这使您可以通过使用@Value注释来注入单个应用程序参数。

    23.8使用ApplicationRunner或CommandLineRunner

    如果你需要在SpringApplication启动后运行一些特定的代码,你可以实现ApplicationRunner或者CommandLineRunner接口。 两个接口都以相同的方式工作,并提供了一个单一的运行方法,这是在SpringApplication.run(…)完成之前调用的。

    CommandLineRunner接口作为一个简单的字符串数组提供对应用程序参数的访问,而ApplicationRunner使用前面讨论的ApplicationArguments接口。

    import org.springframework.boot.*
    import org.springframework.stereotype.*
    
    @Component
    public class MyBean implements CommandLineRunner {
    
        public void run(String... args) {
            // Do something...
        }
    
    }

    您还可以实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order注释,如果定义了多个CommandLineRunner或ApplicationRunner bean,则必须按特定顺序调用它们。

    23.9应用退出

    每个SpringApplication都会向JVM注册一个关闭钩子,以确保ApplicationContext在退出时正常关闭。 所有标准的Spring生命周期回调(比如DisposableBean接口或者@PreDestroy注解)都可以使用。

    另外,如果在调用SpringApplication.exit()时想要返回特定的退出代码,bean可以实现org.springframework.boot.ExitCodeGenerator接口。 然后可以将此退出代码传递给System.exit()以将其作为状态代码返回,如以下示例所示:

    @SpringBootApplication
    public class ExitCodeApplication {
    
        @Bean
        public ExitCodeGenerator exitCodeGenerator() {
            return () -> 42;
        }
    
        public static void main(String[] args) {
            System.exit(SpringApplication
                    .exit(SpringApplication.run(ExitCodeApplication.class, args)));
        }
    
    }

    另外,ExitCodeGenerator接口可能由异常实现。 遇到这样的异常时,Spring Boot会返回实现的getExitCode()方法提供的退出代码。

    23.10管理员功能

    通过指定spring.application.admin.enabled属性,可以为应用程序启用与管理相关的功能。 这暴露了平台MBeanServer上的SpringApplicationAdminMXBean。 您可以使用此功能远程管理您的Spring Boot应用程序。 此功能对于任何服务包装器实现也可能是有用的。

    提示:如果您想知道应用程序在哪个HTTP端口上运行,请使用local.server.port的key获取该属性。

    24.外部化配置

    Spring Boot允许您将配置外部化,以便在不同的环境中使用相同的应用程序代码。您可以使用属性文件,YAML文件,环境变量和命令行参数来外部化配置。属性值可以通过使用@Value注解直接注入到bean中,通过Spring的Environment抽象来访问,或者通过@ConfigurationProperties绑定到结构化对象。

    Spring Boot使用了一个非常特殊的PropertySource命令,该命令旨在允许明智的重写值。属性按以下顺序考虑:

    1. 在主目录上开发Devtools全局设置属性(当devtools处于活动状态时〜/ .spring-boot-devtools.properties)。
    2. 在你的测试中使用@TestPropertySource注解。
    3. 在你的测试中@ SpringBootTest#属性注解属性。
    4. 命令行参数。
    5. 来自SPRING_APPLICATION_JSON的属性(嵌入在环境变量或系统属性中的内联JSON)。
    6. ServletConfig初始化参数。
    7. ServletContext初始化参数。
    8. 来自java:comp / env的JNDI属性。
    9. Java系统属性(System.getProperties())。
    10. OS环境变量。
    11. 一个RandomValuePropertySource只具有随机的属性*。
    12. 打包jar(application- {profile} .properties和YAML变体)之外的特定于配置文件的应用程序属性。
    13. 打包在您的jar(application- {profile} .properties和YAML变体)中的特定于配置文件的应用程序属性。
    14. 应用程序属性在打包的jar之外(application.properties和YAML变体)。
    15. 打包在jar中的应用程序属性(application.properties和YAML变体)。
    16. @Configuration类的@PropertySource注释。
    17. 默认属性(使用SpringApplication.setDefaultProperties指定)。

    为了提供一个具体的例子,假设你开发了一个使用name属性的@Component,如下例所示:

    import org.springframework.stereotype.*
    import org.springframework.beans.factory.annotation.*
    
    @Component
    public class MyBean {
    
        @Value("${name}")
        private String name;
    
        // ...
    
    }

    在您的应用程序类路径中(例如,在您的jar中),您可以拥有一个application.properties文件,该文件为名称提供了一个合理的默认属性值。 在新环境中运行时,可以在jar外部提供一个application.properties文件来覆盖该名称。 对于一次性测试,您可以使用特定的命令行开关(例如,java -jar app.jar –name =“Spring”)启动。

    提示:可以使用环境变量在命令行上提供SPRING_APPLICATION_JSON属性。 例如,您可以在UN * X shell中使用以下行:

    $ SPRING_APPLICATION_JSON =’{“acme”:{“name”:“test”}}’java -jar myapp.jar
    在前面的例子中,Spring结束了acme.name = test。 您也可以在System属性中将spring提供为spring.application.json,如下例所示:

    $ java -Dspring.application.json =’{“name”:“test”}’-jar myapp.jar
    您还可以使用命令行参数提供JSON,如以下示例所示:

    $ java -jar myapp.jar –spring.application.json =’{“name”:“test”}’
    您还可以将JSON作为JNDI变量提供,如下所示:java:comp / env / spring.application.json。

    24.1配置随机值

    RandomValuePropertySource用于注入随机值(例如,注入秘密或测试用例)。 它可以产生整数,长整数,uuids或字符串,如下例所示:

    my.secret=${random.value}
    my.number=${random.int}
    my.bignumber=${random.long}
    my.uuid=${random.uuid}
    my.number.less.than.ten=${random.int(10)}
    my.number.in.range=${random.int[1024,65536]}

    ndom.int *语法是OPEN值(,max)CLOSE其中OPEN,CLOSE是任何字符和值,max是整数。 如果提供最大值,则值是最小值,最大值是最大值(不包括)。

    24.2访问命令行属性

    默认情况下,SpringApplication将任何命令行选项参数(即以“ - ”开头的参数,例如–server.port = 9000)转换为属性并将其添加到Spring环境。 如前所述,命令行属性总是优先于其他属性源。

    如果您不希望将命令行属性添加到环境中,则可以使用SpringApplication.setAddCommandLineProperties(false)将其禁用。

    24.3应用程序属性文件

    SpringApplication从以下位置的application.properties文件加载属性,并将它们添加到Spring环境中:

    1. 当前目录的A / config子目录。
    2. 当前目录
    3. 一个classpath / config包
    4. 类路径根

    该列表按优先顺序排列(在列表中较高的位置定义的属性将覆盖在较低位置定义的属性)。

    注:您也可以使用YAML(’.yml’)文件替代“.properties”。

    如果您不喜欢application.properties作为配置文件名,则可以通过指定一个spring.config.name环境属性来切换到另一个文件名。 您还可以使用spring.config.location环境属性(逗号分隔的目录位置或文件路径列表)引用显式位置。 以下示例显示如何指定不同的文件名称:

    $ java -jar myproject.jar --spring.config.name=myproject
    

    以下示例显示如何指定两个位置:

    $ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

    警告:
    spring.config.name和spring.config.location很早就用来确定哪些文件必须被加载,所以它们必须被定义为环境属性(通常是OS环境变量,系统属性或命令行参数)。

    如果spring.config.location包含目录(而不是文件),则它们应该以/结尾(并且在运行时加载在加载之前从spring.config.name生成的名称,包括配置文件特定的文件名)。在spring.config.location中指定的文件原样使用,不支持特定于配置文件的变体,并被特定于配置文件的特性覆盖。

    配置位置按相反顺序搜索。默认情况下,配置的位置是classpath:/,classpath:/ config /,file:./,file:./ config /。结果搜索顺序如下:

    1. file:./config/
    2. file:./
    3. classpath:/config/
    4. classpath:/

    当使用spring.config.location配置自定义配置位置时,它们会替换默认位置。例如,如果使用值classpath:/ custom-config /,file:./ custom-config /配置了spring.config.location,则搜索顺序如下所示:

    1. file:./custom-config/
    2. classpath:custom-config/

    或者,使用spring.config.additional-location配置自定义配置位置时,除了默认位置以外,还会使用它们。在默认位置之前搜索其他位置。例如,如果配置了classpath:/ custom-config /,file:./ custom-config /的额外位置,则搜索顺序如下所示:

    1. file:./custom-config/
    2. classpath:custom-config/
    3. file:./config/
    4. file:./
    5. classpath:/config/
    6. classpath:/

    这种搜索顺序使您可以在一个配置文件中指定默认值,然后在另一个配置文件中有选择地覆盖这些值您可以在其中一个默认位置为application.properties中的应用程序提供默认值(或者使用spring.config.name选择的其他基本名称)。这些默认值可以在运行时被置于其中一个自定义位置的不同文件覆盖。

    注:如果使用环境变量而非系统属性,则大多数操作系统不允许使用句点分隔的键名称,但可以使用下划线(例如,SPRING_CONFIG_NAME而不是spring.config.name)。

    注:如果您的应用程序在容器中运行,则可以使用JNDI属性(在java:comp / env中)或servlet上下文初始化参数,而不是使用环境变量或系统属性。

    24.4配置文件特定的属性

    除了application.properties文件外,还可以使用命名约定application- {profile} .properties来定义配置文件特定的属性。如果没有设置活动配置文件,环境会有一组默认的配置文件(默认为[默认])。换句话说,如果没有显式激活配置文件,则会加载来自application-default.properties的属性。

    特定于配置文件的属性是从标准application.properties的相同位置加载的,配置文件特定的文件总是覆盖非特定的文件,而不管配置文件特定的文件位于打包的jar内还是外部。

    如果指定了多个配置文件,则应用最后一个赢取策略。例如,由spring.profiles.active属性指定的配置文件将添加到通过SpringApplication API配置的配置文件之后,因此优先。

    注:如果您在spring.config.location中指定了任何文件,则不考虑这些文件的特定于配置文件的变体。如果您还想使用配置文件特定的属性,请使用spring.config.location中的目录

    24.5属性中有占位符

    application.properties中的值在使用时会通过现有环境进行过滤,因此您可以返回到以前定义的值(例如,从System properties)。

    app.name=MyApp
    app.description=${app.name} 

    提示:您也可以使用这种技术来创建现有Spring Boot属性的“简短”变体。 有关详细信息,请参见第73.4节“使用简短的”命令行参数“”。

    24.6使用YAML而不是属性

    YAML是JSON的一个超集,因此,它是用于指定分层配置数据的非常方便的格式。 SpringApplication类自动支持YAML作为属性的替代方法,只要在类路径中有SnakeYAML库。

    注:如果您使用“Starter”,则SnakeYAML由spring-boot-starter自动提供。

    24.6.1加载YAML

    Spring框架提供了两个方便的类,可以用来加载YAML文档。 YamlPropertiesFactoryBean将YAML作为属性加载,YamlMapFactoryBean将YAML作为Map加载。

    例如,请考虑以下YAML文档:

    environments:
        dev:
            url: http://dev.example.com
            name: Developer Setup
        prod:
            url: http://another.example.com
            name: My Cool App

    面的例子将被转换成以下属性:

    environments.dev.url=http://dev.example.com
    environments.dev.name=Developer Setup
    environments.prod.url=http://another.example.com
    environments.prod.name=My Cool App

    YAML列表被表示为带有[index]解引用的属性键。 例如,考虑下面的YAML:

    my:
    servers:
        - dev.example.com
        - another.example.com

    前面的例子将被转换成这些属性:

    my.servers[0]=dev.example.com
    my.servers[1]=another.example.com

    要通过使用Spring DataBinder实用程序(这是@ConfigurationProperties所做的)绑定到这样的属性,您需要在java.util.List(或Set)类型的目标Bean中拥有一个属性,并且您需要提供一个setter 或者用一个可变的值初始化它。 例如,以下示例绑定到以前显示的属性:

    @ConfigurationProperties(prefix="my")
    public class Config {
    
        private List<String> servers = new ArrayList<String>();
    
        public List<String> getServers() {
            return this.servers;
        }
    }

    注:当列表配置在多个地方时,通过替换整个列表覆盖工作。 在前面的例子中,当my.servers在几个地方被重新定义时,来自PropertySource的整个列表具有更高的优先级,将覆盖该列表的任何其他配置。 逗号分隔列表和yaml列表都可以用来完全覆盖列表的内容。

    24.6.2在Spring环境中将YAML作为属性公开

    YamlPropertySourceLoader类可以用来在Spring环境中将YAML作为一个PropertySource公开。 这样做可以让您使用带有占位符语法的@Value注释来访问YAML属性。

    24.6.3多配置文件YAML文件

    您可以通过使用spring.profiles键来指定多个配置文件特定的YAML文档在单个文件中,以指示文档何时适用,如以下示例所示:

    server:
        address: 192.168.1.100
    ---
    spring:
        profiles: development
    server:
        address: 127.0.0.1
    ---
    spring:
        profiles: production
    server:
        address: 192.168.1.120

    在前面的示例中,如果开发配置文件处于活动状态,则server.address属性为127.0.0.1。同样,如果生产配置文件处于活动状态,则server.address属性为192.168.1.120。如果开发和生产配置文件未启用,则属性值为192.168.1.100。

    如果应用程序上下文启动时没有显式激活,则激活默认配置文件。所以,在下面的YAML中,我们为spring.security.user.password设置了一个只在“默认”配置文件中可用的值:

    
    server:
      port: 8000
    ---
    spring:
      profiles: default
      security:
        user:
          password: weak

    而在以下示例中,由于密码未附加到任何配置文件,因此始终设置密码,必须根据需要在所有其他配置文件中明确重置该密码:

    
    server:
      port: 8000
    spring:
      security:
        user:
          password: weak

    通过使用“spring.profiles”元素指定的spring配置文件可以有选择地使用!字符。如果为单个文档指定了否定配置文件和非否定配置文件,则至少有一个非否定配置文件必须匹配,且否定配置文件可能不匹配。

    24.6.4 YAML的缺点
    YAML文件不能使用@PropertySource注解加载。 所以,如果您需要以这种方式加载值,则需要使用属性文件。

    24.6.5合并YAML列表
    正如我们上面看到的,任何YAML内容最终都会转换为属性。 当通过配置文件重写“列表”属性时,该过程可能是违反直觉的。

    例如,假设名称和描述属性默认为空的MyPojo对象。 以下示例公开了AcmeProperties中的MyPojo列表:

    @ConfigurationProperties("acme")
    public class AcmeProperties {
    
        private final List<MyPojo> list = new ArrayList<>();
    
        public List<MyPojo> getList() {
            return this.list;
        }
    
    }

    考虑以下配置:

    acme:
      list:
        - name: my name
          description: my description
    ---
    spring:
      profiles: dev
    acme:
      list:
           - name: my another name

    如果dev配置文件不活动,AcmeProperties.list包含一个如上定义的MyPojo条目。 如果启用配置文件但是,列表仍然只包含一个条目(名称为“我的另一个名称”和描述为空)。 此配置不会将第二个MyPojo实例添加到列表中,并且不合并这些项目。

    当在多个配置文件中指定一个集合时,将使用具有最高优先级(只有那个)的集合:

    acme:
      list:
        - name: my name
          description: my description
        - name: another name
          description: another description
    ---
    spring:
      profiles: dev
    acme:
      list:
         - name: my another name

    在前面的示例中,如果dev配置文件处于活动状态,则AcmeProperties.list包含一个MyPojo条目(名称为“我的另一个名称”,空描述)。

    24.7类型安全的配置属性

    使用@Value(“$ {property}”)注释来注入配置属性有时会非常麻烦,特别是如果您使用多个属性或者您的数据是分层的。 Spring Boot提供了另一种使用属性的方法,可以让强类型的bean管理和验证应用程序的配置,如以下示例所示:

    package com.example;
    
    import java.net.InetAddress;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties("acme")
    public class AcmeProperties {
    
        private boolean enabled;
    
        private InetAddress remoteAddress;
    
        private final Security security = new Security();
    
        public boolean isEnabled() { ... }
    
        public void setEnabled(boolean enabled) { ... }
    
        public InetAddress getRemoteAddress() { ... }
    
        public void setRemoteAddress(InetAddress remoteAddress) { ... }
    
        public Security getSecurity() { ... }
    
        public static class Security {
    
            private String username;
    
            private String password;
    
            private List<String> roles = new ArrayList<>(Collections.singleton("USER"));
    
            public String getUsername() { ... }
    
            public void setUsername(String username) { ... }
    
            public String getPassword() { ... }
    
            public void setPassword(String password) { ... }
    
            public List<String> getRoles() { ... }
    
            public void setRoles(List<String> roles) { ... }
    
        }
    }

    前面的POJO定义了以下属性:

    • acme.enabled,默认为false。
    • acme.remote-address,可以从String强制类型。
    • acme.security.username,带有嵌套的“安全”对象,其名称由属性的名称确定。 特别是,返回类型没有在那里使用,可能是SecurityProperties。
    • acme.security.password。
    • acme.security.roles,带有一个String的集合。

    注:getters和setter通常是强制的,因为绑定是通过标准的Java Beans属性描述符来完成的,就像在Spring MVC中一样。在以下情况下,可能会忽略setter:

    地图,只要它们被初始化,需要一个getter,但不一定是一个setter,因为它们可以被绑定器改变。
    集合和数组可以通过索引(通常使用YAML)或使用单个逗号分隔值(属性)来访问。在后一种情况下,二传手是强制性的。我们建议始终为这种类型添加一个setter。如果初始化一个集合,确保它不是不可变的(如前面的例子)。
    如果嵌套的POJO属性被初始化(如上例中的Security域),则不需要setter。如果您希望活页夹使用其默认构造函数即时创建实例,则需要一个setter。
    有些人使用Project Lombok来自动添加getter和setter。确保Lombok不会为这种类型生成任何特定的构造函数,因为它被容器自动使用来实例化对象。

    提示:另请参阅@Value和@ConfigurationProperties之间的区别。

    您还需要列出要在@EnableConfigurationProperties注释中注册的属性类:

    @Configuration
    @EnableConfigurationProperties(AcmeProperties.class)
    public class MyConfiguration {
    }
    展开全文
  • 图书挂失是针对未归还的图书在...不光是中文资料还有外文资料,输入标题,关键字等进行检索,查找资料进行的很顺利,同时巩固了以前学过的文献检索的知识,也巩固了以前学过的C#知识,对我的知识框架也是一种加固。...

    本图书馆租赁管理系统是以对图书馆的书籍信息为核心的信息管理系统,主要是用于实现对图书馆书籍信息的管理,该管理系统主要提供图书信息功能、用户信息功能、图书借阅功能和系统设置的管理功能。其中关于图书的借阅功能又包括图书的借阅、图书的归还以及图书的挂失。通过这个图书馆租赁管理系统,可以方便图书馆管理员对图书馆内图书信息的了解以及对与图书借阅、归还、挂失等操作有关联的读者信息的了解与掌握。从而实现了对整个图书馆中图书信息的宏观掌控,为图书馆管理员的工作提供了方便,提高了图书馆管理员的工作效率。

     

    本图书馆租赁管理系统主要分为四个模块,它们分别是:图书信息管理、读者信息管理、图书借阅管理、系统设置。
    其中图书信息管理模块的主要功能是进行图书信息的管理,其中涉及的内容是图书的名称、图书的条形码、图书的作者等,主要是方便图书馆管理员对图书的基本信息的查阅与把控。
    读者信息管理主要是对读者信息的统计,其中涉及的内容是读者的姓名,性别,证件类型,证件号码等,主要是方便图书馆管理员对在图书馆中借阅图书的读者进行查询与统计,从而使图书馆管理员对相关读者的情况有进一步的了解。


    图书借阅管理模块是本系统的核心模块,主要涉及图书借阅、图书归还、图书挂失。图书借阅是当读者要进行借阅图书时候管理员可以方便的操作相关图书,从而方便读者的借阅。图书归还是针对已经出借的图书在读者进行归还时候的操作,通过图书归还可以使关于图书的数据库进行及时的更新,同时方便图书馆管理员对图书馆内图书的整体了解。图书挂失是针对未归还的图书在读者丢失的情况下进行的操作,及时的挂失可以使整个图书馆更加严谨,可以方便图书馆管理员的管理。
    系统设置模块主要是对图书馆管理员的权限进行设置,对于没有相关管理权限的管理员在强行进行系统操作时候会触发异常。
    论文内容的撰写基本符合学校的论文撰写规范,还需要进行进一步的完善与整合。论文的格式需要认真按照学校的论文标准格式进行修改。

     

     

     随着人民生活水平的提高,越来越多的人开始重视自己精神方面的提高,图书成为越来越多人的选择,随之而来的是图书馆的火热。越来越多的人开始选择读书,借阅书籍,过去传统的手工记录式的租赁方式已经不可能满足日常大量书籍的出租业务管理,所以基于此,很有必要借助于计算机来帮助人们来完成这些繁琐的事情。同时将图书的所有信息录入电脑,并且进行联网操作,可以使管理更加方便,不但让图书管理员可以方便快捷的核对查找图书的信息,顾客也可以方便的了解自己所要借阅书籍的状态和有关图书的所有信息,以便决定借阅哪本书籍。

     

     以前认为论文就是一个包含需求分析,总体设计,详细设计,编码与测试等内容的与程序相关的文档,真正进行论文编写的时候才发现还有许多内容在其中,包括绪论、主体、结论等,通过编写程序与文档也提高了我撰写论文的能力
      在准备编写系统的过程中,发现有很多的知识并不熟悉,无奈没有太多的时间去图书馆,只能在网上进行查资料,幸亏在大三的时候学过文献检索,所以这次得以顺利的,运用以前的知识,通过学校的校内网如愿的进行了资料的检索,不光是中文资料还有外文资料,输入标题,关键字等进行检索,查找资料进行的很顺利,同时巩固了以前学过的文献检索的知识,也巩固了以前学过的C#知识,对我的知识框架也是一种加固。

    展开全文
  • 164 2986jsp抗击新冠疫情专题宣传网站 165 2239基于SSM框架的校园爱心公益平台的设计与实现 166 3206ssm基于HTML5的“牧经校园疫情防控网站”的设计与实现 167 4791ssm计算机类专业考研交流学习平台 168 3928ssm人口...

    我是毕业admin,一个快要秃头的程序猿!

    提供了一些今年最新计算机毕业设计源代码,公众号:毕业admin,领取源代码!

    最困难的时候,也就是我们离成功不远的时候!

     

    14486ssm养老院信息管理
    22833ssm电子竞技俱乐部管理
    3518购物网站mysqlspringmvc
    43154springboot基于springboot的仓库管理系统
    54670ssm物料追溯系统
    64746springcloud轻纺城管理系统
    76052springboot疫情下图书馆管理系统
    8430jspm电路分析智能考试系统84CX
    92712ssm网上书店管理系统
    103824ssm《C语言程序设计》在线自学习系统
    11561jspm教研室教学日历管理系统mjm83程序mysql
    123785ssm平时成绩管理系统
    133231ssm民宿网站管理系统
    142905springboot房屋出租
    15271校园二手物品交易_mysql_ershou
    163551ssm新型冠状病毒防控咨询网站
    173542ssm保险公司客户信息管理系统
    185018springboot网上摄影工作室
    193352springboot招聘管理系统
    206022ssm城市交通海量数据管理系统
    213008ssm疫情医疗物资管理系统
    222913jsp疫情防控期间人员档案追寻系统
    233707ssm印染公司信息管理系统
    246026ssm幼儿健康管理系统
    254166springboot基于springboot技术的游戏交易平台
    264946springboot计算机组成原理虚拟仿真实验系统
    272620springboot软考在线题库系统
    283479ssm翻转课堂微视频管理系统
    292662ssm微商客户信息管理系统
    304384jsp校园快递代领系统
    31293jsp在线招聘求职管理系统qnz9083程序
    323029springboot房产信息门户网站
    334641ssm教工公寓管理
    344267ssm苗木购销系统
    35294JSP婚纱影楼管理系统的设计与实现sqlserver
    36418紫砂品鉴与交易
    375065springboot中医保健网站
    38381jspm体育用品管理系统mjmA195程序
    392242jsp超市管理系统
    40358jsp昆明地铁站区警务综合管理系统mjm92A2程序
    414974ssm基于web的企业人事管理信息系统
    424492jsp银行客户管理
    434045springbootb高校学习社区
    443936ssm移动辅助学习平台
    454480springboot蛋糕网店
    463727springboot家具网站
    476039ssm无人驾驶汽车管理系统
    484211ssm客服管理系统
    492281ssm飞机订票管理系统
    50359jsp某公司合同管理系统mjmA4程序
    513970ssm流浪动物救助及领养平台
    524966ssm疫情期间的物资分派管理系统
    534728jsp面向企业人力资源管理网上智能考勤系统
    544543jsp某山区环境保护监督管理平台
    553288springboot景区购票管理系统
    563081ssm超市后台系统
    572742jsp个人网站
    582969jsp个人信息管理系统
    592524jsp招聘信息系统
    603968ssm银枫家政服务管理系统
    612882ssm基于移动端的校园请假系统的设计与实现
    625066ssm房屋租赁系统设计与实现
    634903ssm基于JAVA宠物店管理系统
    64414jspm高校教师业绩管理系统mjmA2mysql程序
    65456jspmsh自动售货机云平台mjm95mysql程序
    663888ssm考勤系统设计
    67583拼餐网站2018
    682975ssm网络游戏论坛平台
    696049ssm创新创业竞赛管理系统
    704693ssm基于Vue.js的音乐播放器设计与实现
    712198ssm高校宿舍管理系统
    726044ssm酒店预订管理系统
    73331JSP学生评奖评优管理系统sqlserver
    744415springboot工程师上门服务管理系统
    753245jsp外卖点餐系统
    763952ssm儿童教育系统
    77581爱慕家具门户网站
    782482springboot基于Web的人事管理系统的设计与实现
    792134springboot医院急诊系统
    806169ssm考试排考系统
    81544s2sh云端图书馆管理系统mjm51A5程序mysql
    82561jspm教研室教学日历管理系统mjm83程序
    833236ssm永川区自行车在线租赁管理系统
    844453ssm企业固定资产管理系统
    854493springboot基于springboot的家居销售网站
    862736ssm在线投稿系统
    874999ssm航帆学院网站
    883451springboot校园招聘论坛设计
    894589ssm基于javaweb开发数码产品推荐平台系统设计与实现
    904614ssm旅游景点展示平台
    912510jsp同学录网站
    923406jsp衡师社团管理系统
    934697jsp作业自动评阅系统
    942275springboot后勤管理系统-餐饮评价监督系统
    95258多媒体技术与应用课程网sqlserver
    963521ssm基于uniapp移动端宠物系统
    97457jspm宅急送物流管理系统mysql
    985007springboot智慧型居民小区物业管理
    993934ssm智能推荐招聘网站
    1003319ssm哈尔滨旅游项目推荐平台
    1012608jsp移动公司crm客户关系管理系统开发与实现
    1022176ssm高校运动会
    1032545ssm补课管理系统
    1042220ssm幼儿园管理系统
    1053691springboot网上订餐系统
    1062164jsp小区失物招领网站
    1074207ssm打车拼车系统
    1086084ssm高校教学资源共享平台
    1092868smmjava宠物领养饲养交流管理平台
    1105086ssm缘梦书屋网站
    1114163ssm校园小区互助系统
    1124858ssm如家酒店管理系统
    1133778springboot教师工作量管理系统
    1143130ssm“陶瓷的世界”网页的实际与实现
    1156083ssm+sqlserver海城同泽中学图书仓库管理系统
    1164351ssm基于SpringMvC的流浪狗领养系统
    1174696ssm社区养老院管理系统
    118584jspm远程教育网站hsg
    1192765jsp房屋租赁平台
    1202987ssm影视论坛
    1212578ssm基于SSM的英语学习网站的设计与实现
    1224108springboot服装生产管理系统
    123587jspm学生成绩查询系统hsg3109
    1246077ssm大学餐厅菜品推荐和点评系统
    125523jspm游戏补丁共享网站mjm5684程序mysql
    126402教学资源网站的设计与实现
    1273766ssm互联网校园家教兼职平台
    1282514jsp二手车交易网站
    1293814springboot高校学生宿舍管理
    1303709springboot基于springboot的学生社团管理系统的研究设计
    1314881ssm高校教师个人信息管理系统
    1323576ssm超市商品管理系统
    1336179ssm基于动态网页技术开发的电商网站
    1344959springboot学生作业管理系统
    1354061ssm学生实验报告管理系统
    1364825springboot春晓学堂管理系统
    1374876ssm在线学习平台
    1386091ssm开放式实验室预约系统
    1394397ssm在线音乐网站
    1403830ssm汽车租赁系统
    1414896springboot大学生入学审核系统
    1424679springboot基于SpringBoot的电影社区网站
    1432328ssm医院药品管理系统
    144597java电信计费系统程序
    1453212ssm智慧书籍的网站
    1462105ssm电商扶贫平台网站
    147577jspm恒泰学生助学贷款系统hsg2018
    1484717ssm在线教学质量评价系统
    1493715ssm论文评审系统
    1503599springboot基于vue的百乐儿童玩具公司管理系统
    1513748ssm网上志愿服务系统
    1523480springboot旅游景点酒店预订网站
    1534887ssm调酒互动交流平台
    1542992springboot菜篮子系统
    1554488ssm宠物销售管理系统
    1563882ssm建材公司管理系统
    1573578ssm诗词文化网站
    1586101springboot教学质量测评系统
    1594345ssm高校科研信息管理系统
    1606094ssm停车管理系统
    1613553jsp毕业生论文管理系统
    1622723springboot房屋租赁
    1632397springboot学生学习评价系统
    1642986jsp抗击新冠疫情专题宣传网站
    1652239基于SSM框架的校园爱心公益平台的设计与实现
    1663206ssm基于HTML5的“牧经校园疫情防控网站”的设计与实现
    1674791ssm计算机类专业考研交流学习平台
    1683928ssm人口普查信息管理系统
    169347JSP网络订餐系统mysql
    1703974springboot酒店管理系统
    1716024ssm医院新型冠状病毒疫苗接种管理系统
    1724116ssm基于SSM+VUE技术的小区车辆档案车位管理系统设计与实现
    1732241jsp家庭记账系统
    1744507springboot基于VUE的个人记账管理系统
    175297jsp银行客户关系管理系统
    1763202springcloud基于springcloud的电商平台的设计与实现
    1774714ssm网上鲜花店系统
    1783835springboot康复医疗健康数据安全采集及分析系统
    1794443springboot发电站
    180454jsp在线音乐试听网站mysql
    1816109springboot笔记交易平台
    182368订餐管理系统带查重
    1834371ssm银行业务管理系统
    1843836springboot网上租贸系统
    1852161jsp医院挂号系统
    1864494springboot追星网站
    1872224ssm在线考试系统程序2021
    1882516ssm医院设备管理系统
    189545jspm银行信贷风险控制系统mjma9程序mysql
    190328JSP千山晚报投稿稿件处理系统sqlserver
    1913229ssm家教中心管理系统
    1922540springboot美容院信息管理系统
    1933469ssm酒店员工管理系统
    1943300ssm淮安城市开放大学实习实训管理系统
    1953462ssm无人智慧药柜系统设计
    1963884jsp校园快递联盟系统
    197551税务申报系统(ssh)
    1983615jsp足球队管理系统
    199482jspm汽车租赁管理系统zjya1
    2002458springboot基于微服务架构的图书借阅系统的设计与实现
    2014719springboot基于Vue.js的云医疗自助就诊平台的设计与实现
    2024076ssm大学生体测数据管理系统
    2032527springboot房屋租赁系统
    2043138ssm基于Java的燕理快递中转站系统的设计与实现
    205537jspssm在线阅读系统(要算法,只要程序
    2064960ssm恒美服饰原材料采购预约配送系统
    2073173ssm基于JavaEE高校学生综合服务信息平台
    2084873ssm辅导员班级量化管理系统
    2094884ssm基于Web产品管理系统
    210367医院药品管理系统
    2114792ssm食用菌菌棒溯源系统
    2122313jsp老年人健康饮食管理系统
    2134449springboot棉花
    2143912ssm健康食谱系统
    2152892ssm绩效考核管理系统
    216514基于RSA的数字签名系统
    2173134ssm毕业生离校未就业管理
    2184564ssm团结里小区疫情防控系统
    2194950jsp大学生兼职平台
    2202475springboot“花园街道”社区医院服务系统
    2212180jsp砂石矿山管理系统2021
    2224926ssm酒店管理系统
    2234476ssm大学生备考平台
    2243527ssm伊伊物流公司的管理系统
    2252361jsp失物招领系统
    2264107ssm中文网络小说平台系统
    2272907ssm网上课程资源管理系统
    2283535jsp租房管理系统
    2292721jsp学生健康信息管理
    2303322ssm基于SSM开发的校园情感网站
    2312404ssm中药分类管理系统
    2323191springboot郑财校园新闻管理系统
    2333925ssm基于javaweb的大学生宿舍管理系统
    2342443springboot个性化产品服务管理系统
    2352759ssm基于JavaWeb的网上购书后台管理系统
    2363357ssm车牌信息管理系统
    2374100ssm基于VUE的教育网站
    238409基于ssh学生请假管理系统
    2392354springboot客观题考试程序2021
    2402359ssm游泳馆管理平台
    2414757ssmC2C和B2C业务平台
    242250_jsp__access_在线网络购物系统_
    2432911ssm绿植培养在线交流平台
    2445032ssm工厂生产计划与进度管理系统
    245263JSP企业进销存系统的设计与实现SQLServer
    2462118springboot木材产销系统的生产管理模块
    2472741springboot贫困地区儿童资助网站
    2482186jsp高校学生社团管理
    2496043ssm计算机实验中心网站
    2502793jsp社区生活超市管理系统
    2512119jsp郑州卷烟厂库存管理系统
    2524895jsp学生宿舍信息管理
    2532518ssm智能化车辆管理综合信息平台
    2543760ssm学籍管理系统
    255619jsp智慧校园系统
    2562865ssm校园流浪猫图鉴管理系统的设计与实现
    2573296jsp安全生产监管系统
    2582994ssm运动会成绩管理系统
    2594605ssm基于WEB的儿童运动馆业务信息系统
    2604333springboot鞋类秒杀商城
    2613114ssm乐购游戏商城系统
    2624729ssm高校贫困生信息管理系统
    2632604jsp康养旅游信息系统
    2643872springboot高校毕业生就业管理系统
    2652396ssm基于Java的台球收费管理系统的设计与实现
    2664681ssm动物园管理系统
    2674121ssm基于SSM的网上拍卖系统
    2686147springboot编程训练系统设计与实现
    2693096jsp公益劳动招募管理系统
    2702483springboot旅游管理系统
    2712573jsp药品销售系统
    272451可自动抽取关系的客户物流配送关系管理
    2734544jsp青岛地区常见昆虫图鉴与论坛
    2744530ssm基于B_S模式的快递运输平台
    2753419ssm苹果酒店住房管理
    2763085ssm图书管理系统
    2773917springboot宠物交易
    2782717ssm智慧茶园综合管理系统
    2792886jsp游泳馆信息管理系统
    2802722springboot晨曦文学社在线投稿系统的设计与实现
    2814303ssm医友医院信息管理
    2822967ssm巴音学院学生资料管理系统
    283613手机销售
    284475jspm基于新高考的生涯辅导信息系统
    285615jspm精品课程网站hsg3102
    2864008jsp安居小区物业管理系统
    2873761ssm医院取药系统
    2883364jsp个人饮食营养管理信息系统
    2894334springboot衣依服装销售平台
    2902455ssm校园约自习网站
    2912663springboot校园闲置物品交易平台
    2922816ssm计算机课程在线培训学习管理系统
    2936050ssm期刊在线投稿系统
    2944017ssm亦心化妆品网站
    295483jspm汽车租赁网站zjy5234修改程序0513
    2964246ssm网上家教信息管理系统
    2975031ssm博物馆交流平台
    2982195jsp雁门关风景区宣传网站
    2993316springboot突发事件现场指挥系统
    3003241jsp酒店管理系统
    展开全文
  • 项目资料下载地址:请点击》》》 摘要 步入第四次工业革命以后,对高效率的管理模式这一需求...接口文档和接口测试问题 31 6.2数据安全问题 31 结语 33 参考文献 35 致谢 36 项目截图: 项目资料下载地址:请点击》》》
  • 近几年来,网络信息技术日新月异,整个网络环境相较于前几年有了深刻的变革,这些网络信息相关的技术不仅让我们...本文就结合当前较为主流的Python Web框架Django来搭建一个B2C线上电子产品销售平台的电商系统,该系
  • ASP(499套) ASP+ACCESS基于BS办公系统(源代码+论文).rar 1:计算机专业-ASP(499套) ASP+ACCESS基于BtoC电子商务网站设计(论文+源代码+开题报告+文献综述+外文翻译).rar 1:计算机专业-ASP(499套) ASP+ACCESS...
  • 能够熟练阅读外文文献、文档和相关社区论坛内容,可以针对自己的需要检索并学习相关知识; 5. 有良好的沟通能力,工作积极主动,对大模型的应用感兴趣,能够与团队其他成员协作。 NLP应用工程师(全职/实习) 工作...
  • 较好地掌握一门外语,能够比较熟练地阅读本专业的外文资料,具有一定的外文翻译能力。 具有较强的独立思考能力、自学能力和工程设计能力,能较好地应用所学知识和技能分析、解决专业领域应用中的实际问题。 具备...
  • 能够熟练阅读外文文献、文档和相关社区论坛内容,可以针对自己的需要检索并学习相关知识; 5. 有良好的沟通能力,工作积极主动,对大模型的应用感兴趣,能够与团队其他成员协作。 NLP应用工程师(全职/实习) 工作...
  • 能够熟练阅读外文文献、文档和相关社区论坛内容,可以针对自己的需要检索并学习相关知识; 5. 有良好的沟通能力,工作积极主动,对大模型的应用感兴趣,能够与团队其他成员协作。 NLP应用工程师(全职/实习) 工作...
  • 项目介绍 近几年来,网络信息技术日新月异,整个网络环境相较于前几年有了深刻的变革,这些网络信息相关的技术不仅让我们更加...本文就结合当前较为主流的Python Web框架Django来搭建一个B2C线上电子产品销售平台的电商
  • 可以流畅阅读外文文献,口语交流等, 对美式英式英语理解颇深,擅长从英文文献中解决技术难题。 ***************************************************************************************************************...
  • 熟练使用vue框架,有前端html、JS等相关经验8. 至少使用DRF 和VUE 有一个完整的项目经验三年工作经验以上优先 ...
  • JS方面,除了各种压缩、混淆、打包的工具之外,更是出现了browserify、grunt等工程化的框架,从此前端也有了工程化; 在服务端方面,express、koa开始登上舞台,并且衍生出了更多的后端框架; 最后,第一个...
  • 语言

    2019-10-02 22:16:03
    更别说英语这个基本技能了(因为真正的机器学习相关内容文献都是外文的,想第一手获取就得自己从外文期刊里面找),所以真的想把机器学习深度学习ai学好是非常难的,所以往往很多硕士包括我自己可能都只学到了点皮毛...
  • 作为一名老前端,肯定会用过许多主流的工具,比如 jQuery 及其各式插件,比如 Vue 比如 React,但很多时候我们就是那么习惯性地用着,可能没想过了解下它的源码、实现方式——这在我后期想起来是种略为毛骨悚然的...
  • 前言: 此篇文章原是本人重学前端记录在印象笔记中的笔记...跟我一起学前端是一个系列,主要由(HTML篇、HTML5篇、CSS篇、CSS3篇、原生JavaScript篇、jQuery(JavaScript库)篇、Vue、React、Anglar (JavaScript框架)篇、...
  • 作为一名老前端,肯定会用过许多主流的工具,比如 jQuery 及其各式插件,比如 Vue 比如 React,但很多时候我们就是那么习惯性地用着,可能没想过了解下它的源码、实现方式——这在我后期想起来是种略为毛骨悚然的...
  • 28 5.3前台首页功能模块 31 第六章 系统测试 33 6.1测试定义及目的 33 6.2性能测试 33 6.3测试模块 33 6.4测试结果 34 总 结 35 致 谢 36 参考文献 37 第一章 绪 论 1.1背景及意义 系统管理也都将通过计算机进行...
  • 2.3 前端开发框架技术 常用的前端框架技术主要包含JQuery框架、Bootstrap框架、React框架、Vue框架、Angular框架等。 2.4 数据库技术 数据库技术是信息系统的一个核心技术。是一种计算机辅助管理数据的方法,它研究...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
热门标签
关键字:

vue框架外文参考文献