SpringBoot快速开发实践-CSDN博客

本文链接：https://blog.csdn.net/weixin_41800760/article/details/148622927

SpringBoot快速开发实践

前言

主要把开发实践整理出来，形成自己的一个体系。通信处理的时候，非常重视的是通信流程的建立。作者大学学习的是计算机通信，现在的编程体系已经从原始的Socket编程，框架升级之后，基本上找不到Socket的影子。但是通信的原理没有变化。那么如何从Socket通信，形成一个系统。这是一个非常复杂的过程，作者带领大家将整个过程进行开发。形成一个整体的概念。在开发过程中，需要了解哪些内容在框架中已经包含，熟悉应用框架，不要重复开发轮子。效率高。并且在掌握原理之后，解决问题的能力强，扩展能力强。本书在描述问题的时候，会涉及以下的一些组件的源码。

本书引用的源码

Tomcat 9.0.7X

FlowableXX

SpringBoot XX

Mybatis

Mybatisplus XX

JPA XX

SPLXX

开发环境及工具准备

程序开发对于初学者甚至对于一些有经验的开发者来讲，环境的构建涉及到多个部分，会比较麻烦。在开发的过程中，一般有java服务端开发及Vue前端开发，开发的环境对于初学者来讲，需要配置很多软件工具。本文列出在java全栈开发的过程中，主要的工具软件。方便初学者能快速掌握这些不同软件在开发过程中的作用。

开发环境准备

版本控制工具

Git客户端工具

Java编写及开发环境

Jdk:Java的运行环境

Intellij IDEA 2020.1.1版本，java程序的编写代码环境

Maven：Java项目的的依赖管理

数据库环境

Mysql的Server版本

Navicat，访问数据库的SQL工具

Redis，内存数据库

运行redis-server redis.windows.conf

前端开发编译环境

Node.js 前端的开发环境

一、什么是Nods.js

Node.js 是基于Chrome V8引擎的JavaScript运行环境，分为两个部分，一是解析和执行js代码，另一部分是内置API。那什么是API？百度解释：（API是应用程序编程接口，英文全称为Application Programming Interface。它是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。）通俗说就是别人写好代码，提供给开发人员使用的接口。

在Node.js的开发过程中，有时我们需要使用不同版本的Node.js来适应不同的项目需求。如何方便地切换Node.js版本呢？本文将介绍三种常用的方法，分别是使用nvm、n模块和nave。

nvm（Node Version Manager）是一个用于管理Node.js版本的工具，它允许你在同一台机器上安装和切换多个Node.js版本。

NVM是Node.js的版本管理工具，可以方便地在不同版本的Node.js之间切换。它可以通过命令行或者脚本来管理Node.js的版本，支持在同一台机器上安装多个版本的Node.js，并能够方便地切换它们。

NVM的主要功能包括：

安装和卸载Node.js的不同版本。

切换不同版本的Node.js。

管理全局和本地的Node.js模块。

支持在不同的操作系统上使用。

使用NVM可以方便地在同一台机器上开发和测试多个Node.js应用程序，而不必在不同的机器上安装不同的Node.js版本。此外，NVM还可以管理全局和本地的Node.js模块，使得开发者可以方便地在不同的项目中使用不同的Node.js模块。

NVM使用简单，只需要下载安装脚本，然后在命令行中输入相应的命令即可完成Node.js版本的安装、卸载和切换等操作。NVM也提供了一些方便的命令，如列出所有可用的Node.js版本、查看当前使用的Node.js版本等。

下载地址页：https://github.com/coreybutler/nvm-windows/releases

————————————————

原文链接：简单易懂的 nvm 和 Node.js 版本控制指南-CSDN博客

二、安装过程

1、以管理身份运行安装包

三、下载nodejs版本

首先，我们使用nvm ls 命令查看一下当前有哪些nodejs版本，可以看见，目前还没有安装任何nodejs版本。

下载一个nodejs版本，可以在这里找到对应的nodejs版本号：以往的版本 | Node.js

比如我们使用nvm下载安装一个Node.js 14.21.3的版本，可以使用以下命令：

nvm install 14.21.3

可以看到，我们目前已经成功的安装上了2个nodejs版本了。那么我么如何切换版本呢？

很简单，我们可以使用nvm use version来进行切换node版本。例如下面这样。

五、设置镜像源

设置镜像源，有助于下载依赖的时候，速度更快。

找到nvm安装根目录，找到settings.txt文件打开。

在文件末尾添加一下代码后，保存文件并关闭。

node_mirror: https://npmmirror.com/mirrors/node/

npm_mirror: CNPM Binaries Mirror

简单易懂的 nvm 和 Node.js 版本控制指南-CSDN博客

二、什么是NPM

NPM 全称是 Node Package Manager，是Node.js 的包管理工具，相当于 Maven。顾名思义，NPM就是用来下载 js 库并且管理项目的工具。

三、Node.js 和 NPM 之间的联系

Node.js 是平台，而 npm 是这个平台上的默认包管理工具，nodejs 内置了 npm

Node.js 内置了 NPM，所以在下载安装 Node.js 的时候，NPM 就已经下载安装好了。简而言之，Node.js 提供了一个运行环境，而 npm 则提供了管理这个环境中所有依赖关系和组件的工具。

四、部署一个入门的服务器程序

1.查看Node.js 和 NPM 的版本号

在命令提示符中输入如下代码，查看各自的版本号

node -v //查看node的版本号

npm -v //查看npm的版本号

(注：在安装Node.js 时，Node.js 内置了 npm，所以 npm 自动安装了，也可以手动下载，这里不做说明)

Cnpm

cnpm是一个淘宝构建的npmjs.com的完整镜像，也称为淘宝镜像，网址https://npmmirror…com/cnpm服务部署在国内阿里云服务器上，可以提高包的下载速度
官方也提供了一个全局工具包cnpm,操作命令与npm大体相同

我们可以通过npm来安装cnpm工具

npm install -g cnpm --registry=https://registry.npmmirror.com

Yarn

yarn是由Facebook在2016年推出的新的Javascript包管理工具，官方网址：https:/yarnpkg.com/

yarm官方宣称的一些特点

速度超快：yarn 缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快
超级安全：在执行代码之前，yarn 会通过算法校验每个安装包的完整性
超级可靠：使用详细、简洁的锁文件格式和明确的安装算法，yarn 能够保证在不同系统上无差异的工作

我们可以使用npm安装yarn

npm i -g yarn

可以通过如下命令配置淘宝镜像

yarn config set registry https://registry.npmmirror.com/

可以通过yarn config list查看yarm的配置项

5.5 npm 和yarn 选择

大家可以根据不同的场景进行选择
1.个人项目
如果是个人项目，哪个工具都可以，可以根据自己的喜好来选择
2.公司项目
如果是公司要根据项目代码来选择，可以通过锁文件判断项目的包管理工具

npm的锁文件为package-lock.json
yarm的锁文件为yarn.lock

包管理工具不要混着用，切记，切记，切记

————————————————

原文链接：https://blog.csdn.net/2401_83017604/article/details/138087519

WebStorm

npm（Node Package Manager）：npm 是 Node.js 的默认包管理器，用于安装、发布和管理 JavaScript 包。它是一个命令行工具，可以在终端中使用。npm 有一个全球的包仓库，可以从中下载和安装各种 JavaScript 包。

cnpm（China npm）：cnpm 是 npm 的一个镜像，专门为中国用户提供更快的下载速度。由于 npm 的服务器位于国外，中国用户在使用 npm 时可能会遇到下载速度慢的问题。cnpm 通过将 npm 的包镜像到国内服务器，解决了这个问题。

yarn：yarn 是由 Facebook 开发的另一个 JavaScript 包管理器。与 npm 不同，yarn 具有更快的下载速度和更稳定的依赖管理。它还引入了一些新的功能，如离线模式、并行安装等。yarn 使用与 npm 相同的包仓库，可以直接使用 npm 的包。

pnpm：pnpm 是另一个 JavaScript 包管理器，与 npm 和 yarn 不同，它使用硬链接和符号链接来共享依赖项，从而节省磁盘空间。pnpm 还具有更快的安装速度和更低的网络流量消耗。它也可以使用 npm 的包仓库。

npx：npx 是 npm 5.2.0 版本引入的一个命令行工具。它允许你在不全局安装包的情况下运行命令行工具。npx 可以直接运行安装在项目中的依赖包，而不需要手动设置环境变量或全局安装。

nvm（Node Version Manager）：nvm 是一个用于管理多个 Node.js 版本的工具。它允许你在同一台机器上安装和切换不同的 Node.js 版本。nvm 可以帮助开发人员在不同的项目中使用不同的 Node.js 版本，以适应项目的需求。

Pnpm当时是推荐的使用方式，下面描述一下如何通过来使用这个工具

安装pnpm（Performant npm），即高性能的npm包管理工具

一、通过npm全局安装

打开命令行工具：在你的计算机上打开命令行工具，例如Windows的CMD、PowerShell或Linux/macOS的Terminal。

执行安装命令：输入以下命令以全局方式安装pnpm。

npm install pnpm -g

这里的-g参数表示全局安装，这样pnpm就可以在你的系统任何位置被调用。

因为npm在安装的时候，时间过长如何出错，可以选择以下的替换方式。

二、替换的一种方式

1.先安装cnpm并且配置淘宝镜像

npm install -g cnpm --registry=https://registry.npm.taobao.org

2.用cnpm install pnpm -g安装pnpm

检查pnpm是否安装成功

3. pnpm -v

如果提示当前版本则安装成功

三、在具体项目中的使用方式

1、在项目中执行pnpm install用来安装项目所有依赖。

2、在项目中执行pnpm dev 运行，会出现以下的连接。

➜ Local: http://localhost:3100/

➜ Network: http://192.168.66.7:3100/

测试环境的配置

Postman类的工具使用

Winshark的使用

跟踪TCP报文的格式

Postman

Postman中 form-data、x-www-form-urlencoded、raw、binary的区别

form-data：就是http请求中的multipart/form-data,它会将表单的数据处理为一条消息，以标签为单元，用分隔符分开。既可以上传键值对，也可以上传文件

x-www-form-urlencoded

就是application/x-www-from-urlencoded,会将表单内的数据转换为键值对，比如,name=java&age = 23

Raw

可以上传任意格式的文本，可以上传text、json、xml、html等

content-type= text/html（HTML 文档）；text/plain（纯文本）；text/css（CSS 样式表）；application/json (json字符串)

binary

相当于Content-Type:application/octet-stream,从字面意思得知，只可以上传二进制数据，通常用来上传文件，由于没有键值，所以，一次只能上传一个文件。

json 是一种很简洁的协议，但可惜的是，它只能传递基本的数型(int,long,string等)，但不能传递byte类型。如果想要传输图片等二进制文件的话，是没办法直接传输。

补充：什么是Base64

Base64是一种编码方式，它可以将8位的非英语字符转化为7位的ASCII字符。这样的初衷，是为了满足电子邮件中不能直接使用非ASCII码字符的规定，但是也有其他重要的意义：

a）所有的二进制文件，都可以因此转化为可打印的文本编码，使用文本软件进行编辑；

b）能够对文本进行简单的加密。

http通信协议传送二进制的方式

HTTP传输二进制初探 - 从未被超越 - 博客园

关于HTTP传输ASCII文本内容的过程相信大家都应该容易理解，因为HTTP请求头和响应头都是以ASCII文本方式传输的。而对于HTTP传输二进制流的相关细节，其实没有我想象中的那么复杂，以前学习POP3和SMTP（这两个都是邮件传输协议）的时候，知道他们都只能传输ASCII文本，如果要在邮件中加入附件，如一张图片（图片文件就是二进制文件）那就得先对图片文件转码，即将邮件协议不能传输的二进制数据流转换成可被邮件协议传输的ASCII数据流，其中用的最多的转换就是BASE64编码转换。其实BASE64编码转换也同样适合于HTTP协议，只有你在转换后将HTTP响应头中的Transfer-Encoding设置为base64，当然如果客服端浏览器不支持base64编码那这种转换也是徒劳的，不过幸好现在几乎所有浏览器都支持BASE64(你能用浏览器查看邮件中的附件就是证据)。

不过话又回来，既然HTTP能够直接支持二进制的数据流传输，那我们又何必绕着弯子，走冤枉路呢？

Base64是一种任意二进制到文本字符串的编码方法，常用于在URL、Cookie、网页中传输少量二进制数据。

网页中一些小图片可以直接以base64编码的方式嵌入。不用再用链接请求消耗资源。

测试数据，测试环境

测试的数据加载

多环境的支持，开发环境H2，运行环境Mysql。Yml的方式

写作的时候，针对现实世界的AOP是无法处理的。所以有些日志散在不同的地方。

Controller层进行测试

Service层进行测试

Dao层测试放在后面的2个持久化层中进行描述

准备一个starter

Tips

关于springboot的日志logging.file和logging.path的配置问题，springboot日志配置

logging.file.path=e://jpalog

#logging.file.name=jpalogfile.log

它们俩不会同时生效，so只配置其中一个就好了。

单独一个path配置 logging.file.path=E:/logDemo

生成的文件默认为spring.log文件

单独配置logging.file.name=E:\jpalogfile.log

生成路径名字e:\jpalogfile.log

单独配置logging.file.name=jpalogfile.log

生成路径名字,当前项目下 jpalogfile.log

file和path同时配置

file生效，path没有生效。

APIfox

这个也非常的方便，可以保存分目类，可以持久的进行保存

IDEA内的http客户端工具

idea也提供了非常人性化的教程，鼠标焦点移动到.http文件内，右上角出现的两个图标，其中一个是http请求历史记录，另一个就是不同类型的http请求集合。随便打开一个就可以依葫芦画瓢自定义自己的http请求了：

如post请求

POST /user/info HTTP/1.1

Host: 127.0.0.1:8080

Content-Type: application/json

Cache-Control: no-cache

{"lastname": "jack"}

注意：head与body之间，根据http协议，需要有一个空行，否则会被认为全部是head，并且格式报错。

运维日志的管理

日志的作用

在开发调试阶段: 日志系统有助于更快的定位问题。

在应用运维阶段: 日志系统有助于记录大部分的异常信息，通过收集日志信息可以对系统的运行状态进行实时监控预警。

在数据分析阶段: 日志中通常包含大量的用户数据，包括点击行为、兴趣偏好等，基于这些数据可以对用户进行“画像”，进而助力战略决策。随着大数据技术日渐成熟，海量日志分析已经在互联网公司得到广泛应用。

可以说，完善的日志系统是系统好坏判断的重要标记，同时也是商业程序与个人练习程序重要的区别。

日志的观察配置

在开发过程中，经常会出现有的日志太多，有点太少。太少，考虑运维的比较少。太多，无法

日志框架

目前常用的日志框架有 Log4j，Log4j 2，Commons Logging，Slf4j，Logback，JUL。这些日志框架可以分为两种类型：门面日志和日志系统。

日志门面：

只提供日志相关的接口定义，即相应的 API，而不提供具体的接口实现。日志门面在使用时，可以动态或者静态地指定具体的日志框架实现，解除了接口和实现的耦合，使用户可以灵活地选择日志的具体实现框架。

日志系统：

与日志门面相对，它提供了具体的日志接口实现，应用程序通过它执行日志打印的功能。

日志系统：与日志门面相对，它提供了具体的日志接口实现，应用程序通过它执行日志打印的功能。

如图 2 所示，Commons-Logging 和 Slf4j （Simple Logging Facade For Java）属于日志门面框架，Log4j、Logback、和 JUL 则属于具体的日志系统框架。

日志框架的使用选择

而市面上常见的日志框架有很多，通常情况下，日志是由一个抽象层+实现层的组合来搭建的。比较常用的组合使用方式是 Slf4j 与 Logback 组合使用，Commons Logging 与 Log4j 组合使用，Logback 必须配合 Slf4j 使用。由于 Logback 和 Slf4j 是同一个作者，其兼容性不言而喻。开发常用的SpringBoot框架选择了Slf4j 与 Logback的组合使用。

如果是新的项目 (没有历史包袱，无需切换日志框架)，建议使用 Slf4j 与 Logback 组合

对于已有工程，需要根据所使用的日志库来确定门面适配器从而使用 Slf4j。Slf4j 的设计思想比较简洁，使用了 Facade 设计模式，Slf4j 本身只提供了一个 slf4j-api-version.jar 包，这个 jar 中主要是日志的抽象接口，jar 包中本身并没有对抽象出来的接口做实现。

如果在同一项目中使用不同的组件时，会出现不同组件依赖的日志组件不一致的情况？这就需要统一日志方案。需要做2个业务动作

适配器

统一使用 Slf4j，把他们的日志输出重定向到 Slf4j，然后 Slf4j 又会根据绑定器把日志交给具体的日志实现工具。Slf4j 带有几个桥接模块，可以重定向 Log4j，JCL 和 java.util.logging 中的 Api 到 Slf4j。

举例说明：如果老代码中直接使用了 Log4j 日志库接口打印日志，需引入如下配置：

<version>${log4j-over-slf4j.version}</version>

</dependency>

排除依赖

采用 maven 的 exclusion 方案

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<groupId>commons-logging</groupId>

<artifactId>commons-logging</artifactId>

</exclusion>

</exclusions>

<version>${springframework.version}</version>

</dependency>

SpringBoot日志的应用

spring-boot-starter其中包含了 spring-boot-starter-logging，该依赖内容就是 Spring Boot 默认的日志框架 logback。

在我们启动SpringBoot，发现我们并没有主动去配置过任何和日志打印的相关配置，但是控制台却打印了相关的启动日志；因为SpringBoot为Logback提供了默认的配置文件base.xml，base.xml文件里定义了默认的root输出级别为INFO。

Spring Boot中默认配置ERROR、WARN和INFO级别的日志输出到控制台,您还可以通过启动您的应用程序 --debug 标志来启用“调试”模式（开发的时候推荐开启）,以下两种方式皆可：

在运行命令后加入–debug标志，如：java -jar *.jar --debug

在application.properties中配置debug=true，该属性置为true的时候，核心Logger（包含嵌入式容器、hibernate、spring）会输出更多内容，但是你自己应用的日志并不会输出为DEBUG级别。

默认情况下，Spring Boot将日志输出到控制台，不会写到日志文件。我们还可以在application.properties或application.yml配置，但是只能配置简单的场景，保存路径、日志格式等，复杂的场景（区分 info 和 error 的日志、每天产生一个日志文件等）满足不了，只能自定义配置。

SpringBoot推荐的加载的文件名

根据不同的日志系统，你可以按如下规则组织配置文件名，就能被正确加载：

Logback：logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy

Log4j：log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml

Log4j2：log4j2-spring.xml, log4j2.xml

JDK (Java Util Logging)：logging.properties

Spring Boot官方推荐优先使用带有-spring的文件名作为你的日志配置（如使用logback-spring.xml，而不是logback.xml），命名为logback-spring.xml的日志配置文件，spring boot可以为它添加一些spring boot特有的配置项。配置了自定义的日志配置文件logback-spring.xml之后，就不用在application.properties进行配置了，不然多此一举，产生不必要的影响。避免冲突

默认的命名规则，并且放在 src/main/resources 下面即可，注意：logback.xml加载早于application.yml

自定义配置Logback

logback主要包含三个组成部分：Loggers（日志记录器）、Appenders（输出目的在）、Layouts（日志输出格式）

下面就是一个常用的日志配置模版，下面就从跟节点来解析每个节点

<?xml version="1.0" encoding="UTF-8"?>

<contextName>logback</contextName>

<level>ERROR</level>

</filter>

<pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n

</pattern>

</encoder>

</appender>

<appender name="file"

class="ch.qos.logback.core.rolling.RollingFileAppender">

</rollingPolicy>

<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n

</pattern>

</encoder>

</appender>

<appender-ref ref="console" />

<appender-ref ref="file" />

</root>

</configuration>

1、根节点configuration，有以下属性

scan,当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。

scanPeriod,设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。

debug,当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

2、contextName ，设置日志上下文名称，可以通过%contextName来打印日志上下文名称

3、property可以用来设置变量，可以通过${name}来访问，有以下的属性

name，用于${name}访问的key

value，用于${name}访问的value

file ，用于指定配置文件的路径，他的作用在于，如果你有多个配置信息的话，可以直接写在配置文件中，然后通过file引入

4、appender格式化日志输出节点，有两个属性name和class，class用来指定哪种输出策略，常用就是控制台输出策略和文件输出策略。appender有以下子节点：

filter，日志输出拦截器，可以自定义拦截器也可以用系统一些定义好的拦截器

它可以提供最大的自定义输出，如果需要用到系统定义的拦截器，例如我们用ThresholdFilter来过滤掉ERROR级别以下的日志不输出到文件中

· encoder和pattern节点组合用于具体输出的日志格式

spring boot中默认的日志输出格式如下：典型的日志输出格式

2014-03-05 10:57:51.112 INFO 45469 --- [ main] org.apache.catalina.core.StandardEngine :

Starting Servlet Engine: Apache Tomcat/7.0.52

2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] :

Initializing Spring embedded WebApplicationContext

2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader :

Root WebApplicationContext: initialization completed in 1358 ms

2014-03-05 10:57:51.698 INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean :

Mapping servlet: 'dispatcherServlet' to [/]

2014-03-05 10:57:51.702 INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean :

Mapping filter: 'hiddenHttpMethodFilter' to: [/*]

以下项将会被输出：

1、日期和时间--精确到毫秒，并按照时间进行简单的排序

2、日志级别--ERROR,WARN,INFO,DEBUG,TRACE

3、进程ID号

4、日志内容，用"---"分隔符分开

5、线程名字--括在方括号中

6、日志的名字--通常对应的是类名

7、日志内容

· file节点用来指明日志文件的输出位置，可以是绝对路径也可以是相对路径

· rollingPolicy日志回滚策略，在这里我们用了TimeBasedRollingPolicy，基于时间的回滚策略,有以下子节点

fileNamePattern，必要节点，可以用来设置指定时间的日志归档，例如我们上面的例子是每天将日志归档成一个zip包
maxHistory ,可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件,，例如设置为30的话，则30天之后，旧的日志就会被删除
totalSizeCap，可选节点，用来指定日志文件的上限大小，例如设置为3GB的话，那么到了这个值，就会删除旧的日志

除了用TimeBasedRollingPolicy策略，我们还可以用SizeAndTimeBasedRollingPolicy，配置子节点的maxFileSize来指定单个日志文件的大小

<file>mylog.txt</file>

<fileNamePattern>mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>

</rollingPolicy>

</encoder>

</appender>

root节点，必选节点，用来指定最基础的日志输出级别，他有俩个自己点可以用来应用appender，格式化日志输出

所有支持的日志系统都可以通过Spring Environment来指定日志级别，例如application.properties，可以使用“logging.level.*=LEVEL”来指定日志的级别，"LEVEL"的取值可以是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF。配置示例如下：

日志级别 trace<debug<info<warn<error<fatal 默认级别为info，即默认打印info及其以上级别的日志

logging.level.root=WARN #root日志以WARN级别输出

logging.level.org.springframework.web=DEBUG #org.springframework.web包下的日志以DEBUG级别输出

logging.level.org.hibernate=ERROR #org.hibernate包下的日志以ERROR级别输出

如果，我们需要指定我们的应用日志级别了，我们也可以使用同样的方式，如下：

配置中的"com.chhliu"为我们应用的包名。

logging.level.com.chhliu=INFO

6、logger节点，可选节点，用来具体指明包的日志输出级别，它将会覆盖root的输出级别

链接：https://www.jianshu.com/p/984b126a0519

这个配置文件比较多，可以在网上在配置的时候，进行搜索

https://blog.csdn.net/qq_36850813/article/details/108569093

http://tengj.top/2017/04/05/springboot7/

日志的格式，日志输出的地方，日志的级别，等

程序中使用日志的方式

之前我们大多数时候自己在每个类创建日志对象去打印信息，比较麻烦：

平时使用的时候推荐用自定义logback-spring.xml来配置，代码中使用日志也很简单，类里面添加private Logger logger = LoggerFactory.getLogger(this.getClass());即可。

现在可以直接在类上通过 @Slf4j 标签去声明式注解日志对象

先在pom.xml中添加依赖：

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

</dependency>

然后就直接可以使用了:

@Slf4j

@RestController

public class HfwController {

log.info("");

}

Jpa的日志

每个类的日志级别可以设置不一样的

Mybatis的日志

原始日志为log4j

#Mybatis输出sql日志

logging:

level:

org.jeecg.modules : debug

org.springframework.data.mongodb.core: DEBUG

Flowable的日志

它采用了Log4j的日志处理

调试时候的日志插件

如果使用IDEA，可以使用Grep Console插件来过滤分析日志

日志的FAQ

1、如何将Flowable的日志转为文件存储

2、Flowable中采用的sqlsession及sqlfactory是否与SpringBoot集成的Mybatis的或mybatisplus 的factory存在2个，如果这样的化，mybatis本地化的一级缓存是否失效？

flowable的日志为log4j，springboot的日志为logback，如何将flowable的日志转为logback的输出？
Mybatis本身的日志，详细输出的程度在什么地方进行控制？
SpringBoot默认的连接池为H，flowable的连接池如何转到SpringBoot的默认连接池上？
SpringBoot与flowable的集成方式
Mybatis，jpa设置日志打印的方式？
后续的文档中，全局搜索一些日志的文档处理方式
Mybatis 与Mybatisplus是否可以共存？

Maven的目录结构

mkdir myproject

cd myproject

mvn archetype:generate -DgroupId=com.example -DartifactId=myproject -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Maven的概念，为什么需要Maven构建。在不使用maven构建之前，用什么？

Maven的编译方式

Java文件组织的时候，一个类，有一个main函数。能够进入到target中

所以，需要一个项目进行组织，之前是ant，后来被maven代替了。

最佳实际的目录结构

Maven 是一个非常流行的 Java 项目构建工具，它提供了一种标准的方式来管理项目的构建、依赖管理和文档。Maven 项目遵循一定的目录结构，这有助于保持项目的整洁和一致。

Maven 项目目录结构

Maven 项目的目录结构通常如下所示：

my-project/

├── pom.xml

├── src/

│ ├── main/

│ │ ├── java/

│ │ │ └── com/example/package/MyClass.java

│ │ ├── resources/

│ │ │ └── application.properties

│ │ └── webapp/

│ │ └── WEB-INF/

│ │ ├── classes/

│ │ └── lib/

│ └── test/

│ ├── java/

│ │ └── com/example/package/MyClassTest.java

│ └── resources/

│ └── test.properties

└── target/

├── classes/

├── generated-sources/

├── maven-archiver/

├── maven-status/

├── test-classes/

└── generated-test-sources/

pom.xml：项目对象模型文件，包含了项目的配置信息，包括依赖、插件等。

src/main/java：主应用程序的 Java 源代码。

src/main/resources：主应用程序的资源文件，比如配置文件、图片等。

src/main/webapp：Web 应用程序的资源文件，如 HTML、CSS、JavaScript 文件等。

src/test/java：单元测试的 Java 源代码。

src/test/resources：单元测试的资源文件。

target：编译输出目录，包含编译后的类文件、测试类文件等。

Maven 项目编译的要求

src/main/java：此目录下的 .java 文件会被编译成 .class 文件，并最终被打包到 JAR 或 WAR 文件中。

src/main/resources：此目录下的文件会被直接复制到输出目录，通常是 target/classes，并且会被打包到 JAR 或 WAR 文件中。

src/test/java：此目录下的 .java 文件会被编译成 .class 文件，并最终被放在 target/test-classes 目录下，但不会被打包到 JAR 或 WAR 文件中。

src/test/resources：此目录下的文件会被复制到 target/test-classes 目录下，也不会被打包到 JAR 或 WAR 文件中。

Maven 项目编译器文件和打包后文件位置对应关系

src/main/java 中的 .java 文件会被编译到 target/classes 目录下。

src/main/resources 中的文件会被复制到 target/classes 目录下。

src/test/java 中的 .java 文件会被编译到 target/test-classes 目录下。

src/test/resources 中的文件会被复制到 target/test-classes 目录下。

Maven 项目编译

当你运行 mvn compile 命令时，Maven 会执行以下操作：

编译 src/main/java 目录下的 .java 文件。

复制 src/main/resources 目录下的资源文件。

将编译后的 .class 文件和资源文件放到 target/classes 目录下。

当你运行 mvn package 命令时，除了上述操作之外，还会执行打包操作，将 target/classes 目录下的内容打包到 JAR 或 WAR 文件中。

Maven 项目作用

标准化项目结构：Maven 项目遵循统一的目录结构，便于理解和维护。

依赖管理：Maven 自动下载和管理项目依赖。

生命周期管理：Maven 提供了一套生命周期，简化了构建过程。

插件扩展：Maven 支持各种插件来扩展功能，如打包、部署等。

在没有 Maven 之前

在 Maven 之前，项目通常使用以下方式组织：

Lib 库：项目依赖的库通常放在一个名为 lib 的目录下，项目中直接引用这些 JAR 文件。

自定义构建脚本：使用 Ant 或其他构建工具编写自定义的构建脚本来管理构建过程。

Maven 的出现极大地简化了 Java 项目的构建流程，使得项目结构更加规范，依赖管理更加简单，构建过程更加自动化。

Maven项目

可以更加详细一些。

Java运行的时候，所需要的目录，编译到taget中。如果有问题，先在target中，看是否被编译过去。

如果没有，源码是否被编译，在idea的工具中进行观察

可以在pom文件的resource目录

在没有maven之前，项目的组织方式，采用lib库的方式

Maven的项目作用

Maven项目编译的要求

知道默认的位置，这个地方是初学者经常出错的地方。

maven项目编译器文件和打包后文件位置对应关系

src/main/java和src/main/resource下的文件都会放置到jar包的根目录

src/main/java中的所有文件只有.java结尾的文件会被编译之后打包到jar包，其他文件不处理

src/test/java和src/test/resource下的文件不会被打包

当下，新的采用gradle的方式

Gradle 是一种现代的构建工具，它提供了比 Maven 更加灵活和强大的构建功能。Gradle 使用 Groovy 或 Kotlin 作为 DSL（领域特定语言）来定义构建脚本，并且支持增量构建，这使得 Gradle 成为许多大型项目的首选构建工具。

Gradle 项目目录结构

Gradle 项目的目录结构通常如下所示：

Mybatis中的xml文件与接口文件的位置

Mapper的接口所对应的xml应该在同一个目录下

第三方的lib库的位置

格式如下

<groupId>com.scudata</groupId>

<artifactId>esproc-bin</artifactId>

<scope>system</scope>

<systemPath>${basedir}/src/main/lib/esproc-bin-20220402.jar</systemPath>

</dependency>

<groupId>com.test.service</groupId>

<artifactId>hsqldb</artifactId>

<scope>system</scope>

<systemPath>${basedir}/src/main/lib/hsqldb.jar</systemPath>

</dependency>

<groupId>com.test.service</groupId>

<artifactId>mysql-connector-java-8.0.22</artifactId>

<scope>system</scope>

<systemPath>${basedir}/src/main/lib/mysql-connector-java-8.0.22.jar</systemPath>

</dependency>

这个原理很重要。

在IDEA中，自带有Maven的编译器。有点时候，如果编译不通过，可能是自带的maven版本不能支持代码的编译。

为了稳定期间，建议采用单独的一个maven项目，

另外，jdk的版本也是很重要的。要一致。

快速构建一个SpringBoot项目

在开发过程中，经常需要构建一些全新的环境测试一些功能，需要有一些快速的可重复的构建方式。但是java开发涉及到的工具有多个，如代码编译器，Maven工具及仓库，jdk版本，数据库等。如果不能深入理解这些内容，尤其是一些新手，会浪费很多时间在开发环境的构建中。下面就按照前文所用到的工具来快速配置一个全新的SpringBoot项目。

使用IDEA创建SpringBoot项目

使用 IntelliJ IDEA 快速构建一个 Spring Boot 项目可以按照以下步骤进行：

1. 打开 IntelliJ IDEA：启动 IntelliJ IDEA IDE。

2. 创建新项目：选择 "Create New Project" 或 "New Project" 选项。

3. 选择 Spring Initializr：在创建项目的向导中，选择 "Spring Initializr" 作为项目的类型。

4. 配置项目信息：在下一步中，配置项目的基本信息。

- 选择构建工具，如 Maven 或 Gradle。

- 输入项目的 Group 和 Artifact 名称。

- 选择 Spring Boot 版本。

- 选择项目的语言，如 Java、Kotlin 或 Groovy。

5. 添加依赖项：在下一步中，选择需要的依赖项，如 Spring Web、Spring Data JPA、Spring Security 等。你可以根据项目需求进行选择。

6. 配置项目路径：指定项目的保存路径和名称，并选择项目 SDK（JDK）版本。

7. 创建项目：点击 "Finish" 或 "Create" 按钮，IntelliJ IDEA 将使用 Spring Initializr 创建项目。

8. 等待项目构建：IntelliJ IDEA 将自动下载所需的依赖项，并生成项目的初始结构。等待构建过程完成。

9. 开发代码：项目创建完成后，你可以在 IntelliJ IDEA 中打开项目，并开始编写代码。可以创建控制器、服务、实体类等，根据你的项目需求进行开发。

10. 运行项目：找到项目的入口类（通常是带有 `@SpringBootApplication` 注解的类），右键点击该类，选择 "Run" 或 "Debug" 运行项目。

11. 测试项目：使用你选择的测试框架，编写测试用例并运行，确保项目的正常运行和功能。

通过以上步骤，你可以快速使用 IntelliJ IDEA 构建一个基于 Spring Boot 的项目。你可以进一步配置和定制项目，添加其他依赖项和功能，以满足特定的业务需求。

初始化-图形化

选择依赖

选择了几个，然后得到

等一会，下载了依赖之后。因为选择了数据库的依赖。在运行的时候，会出现Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.这样的错误。

在application.proerties中配置

spring.datasource.url=jdbc:mysql://localhost:3306/test

spring.datasource.username=root

spring.datasource.password=jsptpd@123456

spring.jpa.generate-ddl=true

Springboot集成H2

在开发或学习时，有时候想编写一个数据库操作的小demo，但又不想利用MySQL、Oracle等数据库进行建库建表操作，因为只想写个小案例，感觉没必要弄个很大很麻烦的数据库。或者云主机等环境中，应用系统简单，并且不方便安装独立的mysql等数据库进程。这种情况下，可以使用H2内置数据库。

H2 数据库是一个用 Java 开发的嵌入式(内存级别)数据库，它本身只是一个类库，也就是只有一个 jar 文件，可以直接嵌入到项目中。H2的配置,被内嵌到SpringBoot2中，它的官方网站 H2 Database Engine

内置数据库H2

H2 是一个用 Java 开发的嵌入式数据库，它本身只是一个类库，即只有一个 jar 文件，可以直接嵌入到应用项目中。H2 主要有如下三个用途：

第一个用途，也是最常使用的用途就在于可以同应用程序打包在一起发布，这样可以非常方便地存储少量结构化数据。

第二个用途是用于单元测试。启动速度快，而且可以关闭持久化功能，每一个用例执行完随即还原到初始状态。

第三个用途是作为缓存，即当做内存数据库，作为NoSQL的一个补充。当某些场景下数据模型必须为关系型，可以拿它当Memcached使，作为后端MySQL/Oracle的一个缓冲层，缓存一些不经常变化但需要频繁访问的数据，比如字典表、权限表。

它的访问地址 H2 Database Engine ，在使用的时候，按照以下步骤，不需要进行下载。

以下是几种常见的 jdbc:h2 连接 URL 示例：

连接方式

连接内存数据库

String url = "jdbc:h2:mem:testdb";

jdbc:h2:mem:soa_service_api、jdbc:h2:mem:~/.h2/url类似与这种配置的，表示将初始化和h2 console控制台上操作的数据保存在内存（mem-memory）

保存到内存的问题：由于每次重启应用内存释放掉后，对应的数据也会消失，当然初始化的表+初始化数据就都没了。

连接文件数据库

连接语法:

jdbc:h2:[file:][<path>]<databaseName>

有以下三种方式

当前项目的相对路径

url: jdbc:h2:file:./h2db/testjpah2;AUTO_SERVER=TRUE

会在当前程序的根目录下创建目录和数据库文件

当前登陆用户的相对路径

jdbc:h2:file:~/{path}/test

会在当前用户的根目录下创建目录和数据库文件，jdbc:h2:~/testdatabase在Window操作系统下，”~”这个符号代表的就是当前登录到操作系统的用户对应的用户目录，所以testdatabase数据库对应的文件存放在登录到操作系统的用户对应的用户目录当中。

如果采用文件型的，只能有一个用户

当前部署机器的绝对路径

jdbc:h2:C:/{path}/test

会在指定的盘符的指定文件夹下创建数据库文件

jdbc:h2:file:E:/data/H2 表示将初始化的数据和H2 Console控制台执行的数据保存到E盘下data/H2文件夹中

采用文件型数据库，即使应用重启，数据不会丢失。在项目中，一般使用当前项目的相对路径方式，方便程序进行移植

连接远程数据库

（TCP/IP 模式）：

String url = "jdbc:h2:tcp://localhost:9092/path/to/database";

（SSL/TLS 模式）

String url = "jdbc:h2:ssl://localhost:9092/path/to/database";

H2的客户端工具访问方式

SpringBoot程序启动之后

可以采用浏览器的方式进行访问

程序没有启动的时候，无法采用浏览器进行访问

可以采用IDEA作为客户端进行访问

设置内存访问方式

设置文件访问的方式

选择connection type 是embedded

path选择目标路径

然后是用户名及密码

SpringBoot中的配置方式

项目准备

从其他SpringBoot项目中复制一个或者使用IDEA的initial的方式新建一个干净的项目

Pom文件增加h2依赖

采用h2数据库的时候，在Pom文件中增加配置

<groupId>com.h2database</groupId>

</dependency>

修改配置文件application.yml

端口号配置

Server.port: 8085

数据源配置

spring:

datasource:

#h2:

driverClassName: org.h2.Driver

url: jdbc:h2:file:./testh2;AUTO_SERVER=TRUE

type: com.zaxxer.hikari.HikariDataSource

username: root

password: h2pw

spring.datasource.url的配置信息格式

jdbc:h2 是 H2 数据库的连接 URL 格式，用于建立与 H2 数据库的连接。

会在指定路径下自动创建一个名为testh2.mv.db的数据库，(后缀中有mv，是因为高版本的H2存储引擎默认为mvStore)

test.trace.db的文件，这个是h2的错误信息，可以直接打开看。在采用文件方式的h2数据库，SpringBoot启动的时候，这个h2的文件数据库就同时生成。

H2的访问方式配置

##h2 web console设置

URL是你程序的访问URl。

spring.h2.console.enabled=true #进行该配置，程序开启时就会启动h2 web consloe。当然这是默认的，如果你不想在启动程序时启动h2 web consloe，那么就设置为false。

注：

spring.h2.console.settings.web-allow-others=true # 进行该配置后，h2 web consloe就可以在远程访问了。否则只能在本机访问。

spring.h2.console.path=/h2 #进行该配置，你就可以通过YOUR_URL/h2访问h2 web consloe。YOUR_

H2的web控制台配置

Spring.h2.console.path: /h2-console

Spring.h2.console.enabled: true

spring.h2.console.settings.web-allow-others=true # 进行该配置后，h2 web consloe就可以在远程访问了。否则只能在本机访问。

spring.h2.console.enabled=true #进行该配置，程序开启时就会启动h2 web console。当然这是默认的，如果你不想在启动程序时启动h2 web console，那么就设置为false。

启动Springboot之后，以下进行访问http://localhost:8085/h2-console

其中8085是在配置文件启动的端口号，h2-console是h2数据库默认的路径

点击Connnect之后

访问方式

Web访问方式

http://localhost:8089/h2

初始化数据配置

##数据初始化设置

spring.datasource.schema=classpath:sql/schema.sql

#进行该配置后，每次启动程序，程序都会运行resources/db/schema.sql文件，对数据库的结构进行操作。

spring.datasource.data=classpath:sql/data.sql #进行该配置后，每次启动程序，程序都会运行resources/db/data.sql文件，对数据库的数据操作。

默认的加载数据结构的sql文件

resources/sql/schema.sql

SET NAMES utf8mb4;

SET FOREIGN_KEY_CHECKS = 0;-- ----------------------------

-- Table structure for userinfo

DROP TABLE

EXISTS `userinfo`;

CREATE TABLE `userinfo` (

`id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,

`username` VARCHAR ( 30 ),

`age` INT NULL DEFAULT 0,

`version` INT NULL DEFAULT 0,

`did` INT NULL DEFAULT NULL

);

默认的加载数据文件

resourses/sql/data.sql

INSERT INTO `userinfo` VALUES (1, '黄药师', 68, 2, 1);

INSERT INTO `userinfo` VALUES (2, 'huangrong', 28, 1, 1);

INSERT INTO `userinfo` VALUES (3, 'huangrong', 28, 1, 1);

INSERT INTO `userinfo` VALUES (13, 'xx', 23, 1, 1);

INSERT INTO `userinfo` VALUES (14, 'xx', 23, 1, 1);

Sql与DataSource平行层级，都在Spring下一层。

在SpringBoot2.5+版本后，采用如下配置方式

sql:

init:

mode: always #取值为 always，改成其他的会导致sql不会被执行

schema-locations: classpath:sql/schema.sql

data-locations: classpath:sql/data.sql

H2的sql语句，与Mysql的语句有点差别

如果设置JPA的方式

1.添加依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

</parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

2.添加配置

spring.jpa.properties.hibernate.hbm2ddl.auto=update

spring.jpa.properties.hibernate.show_sql=true

spring.jpa.properties.hibernate.format_sql=true

spring.jpa.open-in-view=true

4.添加实体类

package com.demo.h2.entity;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name = "user")

@Data

public class User {

@Id

private int userId;

private String userName;

}

5.添加dao

package com.demo.h2.dao;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

import com.demo.h2.entity.User;

@Repository

public interface UserDAO extends JpaRepository<User, Integer> {

}

项目启动之后访问http://localhost:8080/h2 就可以访问h2数据库的可视化后台，填入配置的url和驱动，帐号密码等信息进入操作控制台。

注意：如果采用jpa集成H2的库时候，初始库的构建，需要用到schema.sql，或者手动先建立一个库。哦，可能也不一定，一个文件就是一个库，所以文件名就是库名。

答：

观察到的现象：

如果ddl-auto ：none，那么schema及data.sql都执行

如果ddl-auto ：create，那么schema及data.sql 都不会执行

暂时不知道原因

设置启动数据库结构与数据脚本

源码加载的位置

AbstractScriptDatabaseInitializer

PathMatchingResourcePatternResolver

getResources

Assert.notNull(locationPattern, "Location pattern must not be null");

if (locationPattern.startsWith("classpath*:")) {

return this.getPathMatcher().isPattern(locationPattern.substring("classpath*:".length())) ? this.findPathMatchingResources(locationPattern) : this.findAllClassPathResources(locationPattern.substring("classpath*:".length()));

} else {

int prefixEnd = locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 : locationPattern.indexOf(58) + 1;

return this.getPathMatcher().isPattern(locationPattern.substring(prefixEnd)) ? this.findPathMatchingResources(locationPattern) : new Resource[]{this.getResourceLoader().getResource(locationPattern)};

}

多环境配置

方便进行切换

测试，采用test

Dev，采用mysql

就可以正常启动了。

在开发多环境的应用时，通常需要能够方便地切换不同的环境配置，例如开发环境（dev）、测试环境（test）、生产环境（prod）等。这样可以确保每个环境都有独立的配置，避免混淆或错误。

下面是如何在 Java 项目中使用 Spring Boot 和 Gradle 实现多环境配置的示例。

1. 添加多环境配置文件

Spring Boot 支持通过不同的配置文件来管理不同的环境配置。通常，我们会为每个环境创建一个配置文件，并在启动应用时指定使用哪个配置文件。

配置文件结构

在 src/main/resources 目录下，创建以下配置文件：

application.yml：默认配置文件，适用于所有环境。

application-dev.yml：开发环境配置文件。

application-test.yml：测试环境配置文件。

application-prod.yml：生产环境配置文件。

部署网站

购买一个云主机，会有一个IP地址，然后部署jdk，数据库，maven

然后如果是商业应用，购买域名，进行域名审核。

简单部署

Java -jar的方式

部署Nginx前后端分离

正向代理与反向代理

正向代理和反向代理的用途都是代理服务中进行客户端请求的转发通俗点来说，正向代理（如Squid、Proxy）是对客户端的伪装，隐藏了客户端的IP、头部或者其他信息，服务器得到的是伪装过的客户端信息；反向代理（如Nginx）是对目标服务器的伪装，隐藏了目标服务器的IP、头部或者其他信息，客户端得到的是伪装过的目标服务器信

息。

F:\nginx-1.15.11\nginx-1.15.11

2、Nginx的模块化设计

除了Core模块外，Nginx还有Event、Conf、HTTP、Mail等一系列模块，并且可以在编译时加入第三方模块。

Nginx的配置项

长连接

日志

前后端分离

打包前端文件

Vue2.0 npm run build

Vue3.0 cnpm run build

在腾讯机器上，打包vue2.0的时候，有问题，根据提示，补充安装一个内容就可以了。

生成了dist的目录。然后将dict的目录里面的内容，复制到nginx的html下。

同时将dict整个文件夹复制到html下。（这样处理的原因，主要是页面访问js的时候，路径不会有问题，未来这个点还是需要优化的）

打包服务端

Maven是目前十分流行的项目构建工具以及依赖解决工具，其提供的常用指令中有两个很容易引起使用者的疑惑，

那就是 install 和 package ，那么这两个命令到底有啥区别呢？

Maven install 安装指令，其做了两件事情：

1.将项目打包（jar/war），将打包结果放到项目下的 target 目录下

2. 同时将上述打包结果放到本地仓库的相应目录中，供其他项目或模块引用

Maven package 打包指令，其就做了一件事：

将项目打包（jar/war），将打包结果放到项目下的 target 目录下（也要先clean）

当前在jeecg的项目中，

执行结束之后，会产生一个jar文件，将该jar文件复制到一个安装目录下，就可以执行了。

Java -jar XXX.jar

上传打包好的文件到Nginx的安装目录下的html

这里是使用的nginx的默认配置，如果需要自定义存放位置的话，可以去conf文件下的Nginx.conf去配置

第三步，自定义配置

这个80端口，就是对外暴露的端口。采用Nginx之后，对外暴露的端口就是Nginx配置的端口，java 的服务端端口，是由Nginx来进行转发的。所以要配置下面的proxy。

原始在开发环境下启动的3000的端口，已经没有用了，也不需要使用了。

第四步，配置Nginx代理

这里的前端对应的是这样的：

后端对应：

server.context-path 起到在ngnix分发中的作用

第五步，启动Nginx

nginx是一款高性能的 Web和反向代理服务器。它的安装、配置、使用非常简单，基本上是解压后即可使用。那window系统中如何查看nginx是否启动呢？下面本篇文章就来给大家介绍一下window系统中查看nginx是否启动的方法，希望对你们有所帮助。

/nginx -s reload

在windows下启动这个程序，在运行的时候，会一闪而过。如何判断nginx已经启动的方式，可以观察一下

查看端口法

还可以使用netstat命令来查看nginx的监听端口是否在监听，如果正监听则表明nginx服务正常启动（当然前提是：没有其它程序也使用该端口），否则未启动。

方法：运行命令：netstat -an|findstr 8080 ，查看是否查找到记录

网页访问法

因为nginx是web服务器，正常启动的话，是可以访问它的网页的。例如：我们在浏览器中输入：127.0.0.1（或者加上设置的端口）回车后，应该能看到一个欢迎页面（没有改默认网页的情况）。如果能够看到，说明nginx启动正常。

查看进程法

如果nginx服务启动了话，在任务管理器中可以看到它的进程，否则表示未正常启动。

查看方法：在任务栏空白处右击，弹出菜单中选择”任务管理器“

查看文件法

从上面可以看出，nginx启动后会在logs目录下生成nginx.pid文件，停止后会自动删除。所以也可以通过查看该目录下是否生成此文件，来判断nginx服务是否启动。

方法：到logs目录下查看是否存在nginx.pid文件。

命令状态法

运行 nginx -s stop (停止) nginx -s reopen(重启) 如果没有报错误信息，则表示原来nginx是启动的。

方法：同时按下win+R，输入：cmd，回车打开命令行窗口。然后使用Cd命令切换到nginx安装目录，运行上面的命令。

注意：运行nginx -s stop 后，需再次运行:start nginx 来启动服务。

第六步，访问你服务器的地址

Vue2当前的版本，nginx可以运行，速度非常快

访问方式是localhost:8081

注意：如果服务端当前启动的端口是8080，如果在nginx配置文件上，监听端口也是8080，那么执行的时候，端口冲突，但是没有反应。

如果要让你的域名能直接进行访问，因为是默认的8080端口，那么需要将服务端的启动端口设置为其他的端口，不要设置为8080，就可以了。

当前配合2.4.3版本的nginx的配置文件如下。

服务端修改了数据库，redis的密码

客户端没有修改,执行客户端打包到dist，然后复制到html的路径下

配置文件采用这个配置文件

然后启动

然后访问方式是localhost:8081

#user nobody;

worker_processes 1;

#error_log logs/error.log;

#error_log logs/error.log notice;

#error_log logs/error.log info;

#pid logs/nginx.pid;

events {

worker_connections 1024;

}

http {

include mime.types;

default_type application/octet-stream;

#log_format main '$remote_addr - $remote_user [$time_local] "$request" '

# '$status $body_bytes_sent "$http_referer" '

# '"$http_user_agent" "$http_x_forwarded_for"';

#access_log logs/access.log main;

sendfile on;

#tcp_nopush on;

#keepalive_timeout 0;

keepalive_timeout 65;

#gzip on;

# gzip config

gzip on;

gzip_min_length 1k;

gzip_comp_level 9;

gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png;

gzip_vary on;

gzip_disable "MSIE [1-6]\.";

server {

listen 8081;

server_name localhost;

#charset koi8-r;

#access_log logs/host.access.log main;

location / {

root html;

index index.html index.htm;

}

location /jeecg-boot/ {

proxy_set_header Host $http_host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

#proxy_pass http://139.224.25.19:8082/jeecg-boot/;

proxy_pass http://127.0.0.1:8080/jeecg-boot/;

}

#error_page 404 /404.html;

# redirect server error pages to the static page /50x.html

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root html;

}

# proxy the PHP scripts to Apache listening on 127.0.0.1:80

#location ~ \.php$ {

# proxy_pass http://127.0.0.1;

# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000

#location ~ \.php$ {

# root html;

# fastcgi_pass 127.0.0.1:9000;

# fastcgi_index index.php;

# fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;

# include fastcgi_params;

# deny access to .htaccess files, if Apache's document root

# concurs with nginx's one

#location ~ /\.ht {

# deny all;

}

# another virtual host using mix of IP-, name-, and port-based configuration

#server {

# listen 8000;

# listen somename:8080;

# server_name somename alias another.alias;

# location / {

# root html;

# index index.html index.htm;

# }

# HTTPS server

#server {

# listen 443 ssl;

# server_name localhost;

# ssl_certificate cert.pem;

# ssl_certificate_key cert.key;

# ssl_session_cache shared:SSL:1m;

# ssl_session_timeout 5m;

# ssl_ciphers HIGH:!aNULL:!MD5;

# ssl_prefer_server_ciphers on;

# location / {

# root html;

# index index.html index.htm;

# }

}

Vue3的配置地方

访问服务端

Nginx在本地的配置，看速度是否可以加快

Nginx.conf

它的配置文件

vite.config.js

Vue3使用vite配置前端服务IP、端口、跨域代理、访问资源路径前缀_vite 端口-CSDN博客

Postman发送的内容

http://localhost:18008/javaTest/test

【java】Java运行时动态生成类几种方式_java动态生成类-CSDN博客

参考SpringBoot项目准备

Vue3的Debug机理

Vue3的路由方式

自定义技术组件方式

在Vue3的页面上，Freemaker的变量表，与配置的对应关系

调整Freemaker的处理方式 .vuei

采用Vue3重构工作流的系统

Vue3 Jeecg其他的功能，视图，大屏，仪表盘等

多表

辅助的系统配合

一般在开发的时候，可以申请一个Gitee的账号，方便代码进行版本控制

申请语雀的账号，方便开发进行协作或者进行自我总结。

Docker的使用

Docker的简介

Docker是一个开源的应用容器引擎，基于Go语言并遵从Apache2.0协议。它允许开发者将应用程序及其依赖打包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。Docker的核心概念包括容器、镜像、Dockerfile和镜像仓库。

容器是Docker的基本部署单元，是一个轻量级的、独立的运行时环境，包含应用程序及其相关依赖。容器利用Linux内核的命名空间和控制组技术，实现了隔离性和资源管理，使得应用程序在不同的容器中运行不会相互影响。

Docker镜像是一个特殊的文件系统，包含容器运行时所需的程序、库、资源、配置等文件，还包含了一些为运行时准备的一些配置参数。镜像不包含任何动态数据，其内容在构建之后也不会被改变。

Dockerfile是一种文本文件，用于定义Docker镜像的构建过程。通过Dockerfile，可以很容易地创建和复制容器，实现环境一致性、运营效率、开发人员生产力和版本控制等目标。

Docker还提供了镜像仓库（Docker Registry），用于存储和分发镜像。Docker Hub是Docker官方提供的公共镜像仓库，用户也可以搭建自己的私有镜像仓库。

总的来说，Docker具有快速启动、资源占用少、环境一致性等优点，极大地简化了应用程序的开发、部署和运行过程。它已经成为云计算和容器化技术的重要组成部分，被广泛应用于各种场景，如微服务架构、持续集成/持续部署等。

Docker 并非是一个通用的容器工具，它依赖于已存在并运行的 Linux 内核环境。Docker 实质上是在已经运行的 Linux 下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的 Linux 主机。因此，Docker 必须部署在 Linux 内核的系统上。如果其他系统想部署 Docker 就必须安装一个虚拟 Linux 环境。在 Windows 上部署 Docker 的方法都是先安装一个虚拟机，并在安装 Linux 系统的的虚拟机中运行 Docker。Docker Desktop 是 Docker 在 Windows 10 和 macOS 操作系统上的官方安装方式，这个方法依然属于先在虚拟机中安装 Linux 然后再安装 Docker 的方法。Docker Desktop 官方下载地址： https://docs.docker.com/desktop/setup/install/windows-install/

在Windows10上安装Docker，需要升级到Windows的专业版。家庭版不支持。

Windows 10 专业版上，可以安装Hyber-v的虚拟机。

安装docker

执行下载的Docker Desktop Installer.exe文件，然后都选择默认。安装之后，重启动机器，运行后，出现Docker Engine stopped 的界面

说明，本机需要安装支持Docker的组件，在后续将安装Hyper -V及wsl组件

安装Windows虚拟机的linux系统

安装 Hyper-V

Hyper-V 是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。这是 Docker Desktop for Windows 所使用的虚拟机。

Win+R，输入control之后，选择程序和功能

点击启用或关闭Windows功能，然后进入到这个界面

更新WSL内核版本

参考Docker Desktop requires a newer WSL kernel version.-CSDN博客

在命令行下执行

wsl --update

如果一直等待，可以换成

wsl --update --web-download 这个命令来执行。需要等待几分钟。

执行成功之后

启动Docker

点击Docker的运行图标

成功的界面

替换国内源

win10 Docker Desktop 换国内源及修改镜像位置_docker desktop 国内镜像-CSDN博客

因网络问题，一般需要使用国内源加快镜像下载速度。在安装完docker destop后，可通过如下四步修改镜像源

在3这个位置增加

"registry-mirrors":[

"https://registry.docker-cn.com",

"http://hub-mirror.c.163.com",

"https://docker.mirrors.ustc.edu.cn"

按照docker desktop的时候，同时实现docker compose了安装。检查的方式，在dos命令下执行docker compose -v

常用的几个命令

查看 docker 仓库中的 mysql 命令

docker search mysql

为选定需要 pull 到系统中的数据库镜像

docker pull mysql:5.7

整个 pull 过程需要花费一些时间，耐心等待。

列出已下载的镜像

# docker images命令列出已下载镜像 docker images

采用Docker安装启动 Mysql 容器

单独安装一个mysql8.0的服务器，还是很麻烦。采用docker化的方式，非常简单。

在dos的cmd命令行下执行

拉去镜像：docker pull mysql:8.0.33

查看镜像：docker images

3、安装容器：

命令：

docker run -itd --name mysql-8 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=hel1x2 mysql:8.0.33 --lower_case_table_names=1

3307是暴露到外部的连接端口

Password 是数据库的root的密码，hel1x2

--lower_case_table_names=1防止大小写错误

查看容器：docker ps -a

进入容器：

(1)采用命令方式进入 docker exec -it 5583b227c445/bin/bash ，这个id是docker分配的

登录命令：mysql -u root -p

(2)采用Navicat客户端：

基于Docker容器DevOps应用方案_docker ops-CSDN博客

Docker安装gitlab

打开cmd运行

docker pull gitlab/gitlab-ce

新建3个文件夹例如：

docker run -d --hostname localhost -p 1000:80 -p 443:443 --name gitlab --restart unless-stopped -v D:\docker\gitlab\config:/etc/gitlab -v D:\docker\gitlab\log:/var/log/gitlab -v D:\docker\gitlab\data:/var/data/gitlab gitlab/gitlab-ce:latest