Source Server : test
Source Server Type : MySQL
Source Server Version : 80020
Source Host : localhost:3306
Source Schema : blog
Target Server Type : MySQL
Target Server Version : 80020
File Encoding : 65001
Date: 21/06/2021 22:42:03
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
— —————————-
— Table structure for ms_admin
— —————————-
DROP TABLE IF EXISTS `ms_admin`;
CREATE TABLE `ms_admin` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
`password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_admin
— —————————-
INSERT INTO `ms_admin` VALUES (1, ‘admin’, ‘$2a$10$RZECQ90DjOT/t1mhnXsl5.XSuZWc0Sa1XduPxj2rb4yaSYcje3nWW’);
INSERT INTO `ms_admin` VALUES (2, ‘mszlu’, ‘$2a$10$RZECQ90DjOT/t1mhnXsl5.XSuZWc0Sa1XduPxj2rb4yaSYcje3nWW’);
— —————————-
— Table structure for ms_admin_permission
— —————————-
DROP TABLE IF EXISTS `ms_admin_permission`;
CREATE TABLE `ms_admin_permission` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`admin_id` bigint(0) NOT NULL,
`permission_id` bigint(0) NOT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_admin_permission
— —————————-
INSERT INTO `ms_admin_permission` VALUES (1, 1, 1);
INSERT INTO `ms_admin_permission` VALUES (2, 2, 1);
— —————————-
— Table structure for ms_article
— —————————-
DROP TABLE IF EXISTS `ms_article`;
CREATE TABLE `ms_article` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`comment_counts` int(0) NULL DEFAULT NULL COMMENT ‘评论数量’,
`create_date` bigint(0) NULL DEFAULT NULL COMMENT ‘创建时间’,
`summary` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘简介’,
`title` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘标题’,
`view_counts` int(0) NULL DEFAULT NULL COMMENT ‘浏览数量’,
`weight` int(0) NOT NULL COMMENT ‘是否置顶’,
`author_id` bigint(0) NULL DEFAULT NULL COMMENT ‘作者id’,
`body_id` bigint(0) NULL DEFAULT NULL COMMENT ‘内容id’,
`category_id` int(0) NULL DEFAULT NULL COMMENT ‘类别id’,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1405916999732707331 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_article
— —————————-
INSERT INTO `ms_article` VALUES (1, 1, 1621947720727, ‘通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过`java -jar`命令就可以运行起来。
这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。’, ‘springboot介绍以及入门案例’, 125, 0, 1, 1, 2);
INSERT INTO `ms_article` VALUES (9, 0, 1613947720727, ‘Vue (读音 /vjuː/,类似于 view) 是一套用于构建用户界面的渐进式框架。’, ‘Vue.js 到底是什么’, 3, 0, 1, 20, 2);
INSERT INTO `ms_article` VALUES (10, 0, 1523947720727, ‘本节将介绍如何在项目中使用 Element。’, ‘Element相关’, 10, 0, 1, 21, 2);
INSERT INTO `ms_article` VALUES (1405564731300831233, 0, 1623947720727, ‘66666666666’, ‘666666666666666’, 2, 0, 1, 1405564731351162882, 2);
INSERT INTO `ms_article` VALUES (1405909844724051969, 0, 1624030002164, ‘123’, ‘123123’, 2, 0, 1, 1405909844828909569, 3);
INSERT INTO `ms_article` VALUES (1405916999732707330, 0, 1624031708047, ‘springboot入门案例’, ‘SpringBoot入门案例’, 5, 0, 1, 1405916999854342146, 2);
— —————————-
— Table structure for ms_article_body
— —————————-
DROP TABLE IF EXISTS `ms_article_body`;
CREATE TABLE `ms_article_body` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`content` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
`content_html` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL,
`article_id` bigint(0) NOT NULL,
PRIMARY KEY (`id`) USING BTREE,
INDEX `article_id`(`article_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1405916999854342147 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_article_body
— —————————-
INSERT INTO `ms_article_body` VALUES (1, ‘# 1. Spring Boot介绍
## 1.1 简介
在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?
在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?
那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!
Spring Boot让我们的Spring应用变的更轻量化。
我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。
通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过`java -jar`命令就可以运行起来。
这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。
总结一下Spring Boot的主要优点:
1. 为所有Spring开发者更快的入门
2. 开箱即用,提供各种默认配置来简化项目配置
3. 内嵌式容器简化Web项目
4. 没有冗余代码生成和XML配置的要求
5. 统一的依赖管理
6. 自动装配,更易使用,更易扩展
## 1.2 使用版本说明
Springboot版本:使用最新的2.5.0版本
教程参考了官方文档进行制作,权威。
其他依赖版本:
1. Maven 需求:3.5+
2. JDK 需求 8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0 但是可以部署到Servlet到3.1+的容器中
# 2. 快速入门
快速的创建一个Spring Boot应用,并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。
教程使用的Idea版本:2019.3
## 2.1 创建基础项目
第一步: 创建maven项目
pom.xml :
~~~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.xiaopizhu</groupId>
<artifactId>helloSpringBoot</artifactId>
<version>1.0-SNAPSHOT</version>
<!–springboot的父工程其中定义了常用的依赖,并且无依赖冲突–>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
</project>
~~~
注意上方的parent必须加,其中定义了springboot官方支持的n多依赖,基本上常用的已经有了,所以接下来导入依赖的时候,绝大部分都可以不加版本号。
此时的工程结构为:
![image-20210523173241557](img/image-20210523173241557.png)
第二步: 添加web依赖
~~~xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
~~~
添加上方的web依赖,其中间接依赖了spring-web,spring-webmvc,spring-core等spring和springmvc的包,并且集成了tomcat。
第三步: 编写启动类
~~~java
package com.xiaopizhu.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloApp {
public static void main(String[] args) {
SpringApplication.run(HelloApp.class,args);
}
}
~~~
@SpringBootApplication注解标识了HelloApp为启动类,也是Spring Boot的核心。
第四步: 运行启动类的main方法
![image-20210523173712142](img/image-20210523173712142.png)
看到如上配置,证明启动成功,tomcat端口号默认为8080。
第五步: 如果想要修改端口号,可以在resources目录下新建application.properties
~~~properties
server.port=8082
~~~
第六步: 重新运行
![image-20210523174011613](img/image-20210523174011613.png)
此时的项目结构为:
![image-20210523174032053](img/image-20210523174032053.png)
src/main/java : 编写java代码,注意启动类需要放在项目的根包下。
src/main/resources: 放置资源的目录,比如springboot的配置文件,静态文件,mybatis配置,日志配置等。
src/test/java: 测试代码
## 2.2 编写一个Http接口
第一步:创建`HelloController`类,内容如下:
~~~java
package com.xiaopizhu.springboot.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(“hello”)
public class HelloController {
@GetMapping(“boot”)
public String hello(){
return “hello spring boot”;
}
}
~~~
注意包名,必须在启动类所在的包名下。
第二步:重启程序,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.3 编写单测试用例
第一步:添加spring boot测试依赖
~~~xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
~~~
第二步:在src/test 下,编写测试用例
~~~java
package com.xiaopizhu.springboot.controller;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest
public class TestHelloController {
private MockMvc mockMvc;
@BeforeEach
public void beforeEach(){
mockMvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
}
@Test
public void testHello() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get(“/hello/boot”)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo(“hello spring boot”)));
}
}
~~~
上面的测试用例,是构建一个空的`WebApplicationContext`,并且在before中加载了HelloController,得以在测试用例中mock调用,模拟请求。
## 2.4 打包为jar运行
第一步:添加打包(maven构建springboot)插件
~~~xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
~~~
在idea的右侧 maven中,使用package来打包程序,打包完成后,在target目录下生成helloSpringBoot-1.0-SNAPSHOT.jar
![image-20210523181737720](img/image-20210523181737720.png)
第二步:打开cmd:找到jar对应的目录
输入命令
~~~shell
java -jar helloSpringBoot-1.0-SNAPSHOT.jar
~~~
![image-20210523182426404](img/image-20210523182426404.png)
第三步:测试,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.5 查看jar包内容
~~~shell
jar tvf helloSpringBoot-1.0-SNAPSHOT.jar
~~~
# 3. 小结
1. 通过Maven构建了一个空白Spring Boot项目,再通过引入web模块实现了一个简单的请求处理。
2. 通过修改配置文件,更改端口号
3. 编写了测试用例
4. 打包jar包运行
‘, ‘<h2>2018-01-04</h2>
<pre><code class=”lang-“># 使用vue的Webpack模板生成脚手架
</code></pre>
<h2>2018-01-05</h2>
<pre><code class=”lang-“># 引入ElementUI
# babel-plugin-component自定义主题
# 首页
# 登陆页
# 注册页面
# 日志页
</code></pre>
<h2>2018-01-07</h2>
<pre><code class=”lang-“># 调整底部栏始终固定在底部
# 日志页 添加时间轴
# 首页的文章列表
</code></pre>
<h2>2018-01-08</h2>
<pre><code class=”lang-“># 使用组件-博客作者tab页
# 添加第三方图标
</code></pre>
<h2>2018-01-09</h2>
<pre><code class=”lang-“># 调整顶部导航栏:激活文字颜色,click
# 组件-最新文章tab页
# 最新文章、最热文章使用相同组件
# 底部栏设计
# 页面与两边边距改为100
</code></pre>
<h2>2018-01-10</h2>
<pre><code class=”lang-“># 写博客 引入mavonEditor编辑器
# 顶部导航栏都放入一个Menu中
# 写文章页面
# mavonEditor局部引入
# 页面的中间区域固定宽度,自动居中
# 发布和取消
# 发布dialog
</code></pre>
<h2>2018-01-11</h2>
<pre><code class=”lang-“># 文章组件用守卫来改变body背景色
# 调整登陆和注册页面,使其居中
#子页面调整根素为div
#文章详情页
</code></pre>
<h2>2018-01-12</h2>
<pre><code class=”lang-“># 文章详情页 内容 评论等
</code></pre>
<h2>2018-01-13</h2>
<pre><code class=”lang-“>## 重新调整页面结构
#顶部和底部 抽成 BaseHeader BaseFooter 组件
#BlogView为单独页,以前是Home的子路由
</code></pre>
<h2>2018-01-15</h2>
<pre><code class=”lang-“># 文章分类去掉子级
# 将首页的文章列表抽成 ArticleItem组件
# 增加文章的评论展示
# 增加文章分类、标签页
</code></pre>
<h2>2018-01-15 2</h2>
<pre><code class=”lang-“># 回到顶部去掉过渡动画(影响顶部导航栏)
# 顶部导航栏 增加登录后菜单
# 首页增加 最热标签
# 增加 文章分类 标签的详情页
# 将文章详情页、 文章分类标签页 改为Home的子路由(以前单独页)
# Home组件增加路由判断:更正导航栏的状态、条件显示底部栏
</code></pre>
<h2>2018-01-16</h2>
<pre><code class=”lang-“># 将写文章的顶部Header合并到BaseHeader中
# 图片都放到了static目录下
</code></pre>
<h2>2018-01-24</h2>
<pre><code class=”lang-“># 将自定义的theme放到assets下
# 加入axios
# 加入vuex
# 实现登录
# 实现退出
</code></pre>
<h2>2018-01-25</h2>
<pre><code class=”lang-“># 实现注册逻辑
# 写文章功能实现
# 写文章时支持插入图片
</code></pre>
<h2>2018-01-26</h2>
<pre><code class=”lang-“># 引入lodash工具类
# 优化写文章的工具栏:滚动时固定顶部
# 写文章 后台获取文章分类和标签
# 首页的文章列表
</code></pre>
<h2>2018-01-27</h2>
<pre><code class=”lang-“># 修改首页文章列表的样式
# 首页加载文章功能
# 文章查看功能
# 文章分类和标签功能列表
</code></pre>
<h2>2018-01-28</h2>
<pre><code class=”lang-“># 文章分类和标签详情
</code></pre>
<h2>2018-01-29</h2>
<pre><code class=”lang-“># 文章分类和标签的文章数
# 首页最热文章
# 首页最新文章
# 首页最热标签
</code></pre>
<h2>2018-01-30</h2>
<pre><code class=”lang-“># BaseHeader放回views中
# 修改Axios后置拦截,全局处理错误
# 将登录 退出 和头像 放到一起
</code></pre>
‘, 1);
INSERT INTO `ms_article_body` VALUES (20, ‘Vue (读音 /vjuː/,类似于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是,Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层,不仅易于上手,还便于与第三方库或既有项目整合。另一方面,当与现代化的工具链以及各种支持类库结合使用时,Vue 也完全能够为复杂的单页应用提供驱动。
如果你想在深入学习 Vue 之前对它有更多了解,我们制作了一个视频,带您了解其核心概念和一个示例工程。
如果你已经是有经验的前端开发者,想知道 Vue 与其它库/框架有哪些区别,请查看对比其它框架。
# 起步
> 官方指南假设你已了解关于 HTML、CSS 和 JavaScript 的中级知识。如果你刚开始学习前端开发,将框架作为你的第一步可能不是最好的主意——掌握好基础知识再来吧!之前有其它框架的使用经验会有帮助,但这不是必需的。
尝试 Vue.js 最简单的方法是使用 JSFiddle 上的 Hello World 例子。你可以在浏览器新标签页中打开它,跟着例子学习一些基础用法。或者你也可以创建一个 .html 文件,然后通过如下方式引入 Vue:
“`javascript
<script src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://cdn.jsdelivr.net/npm/vue”></script>
“`
安装教程给出了更多安装 Vue 的方式。请注意我们不推荐新手直接使用 vue-cli,尤其是在你还不熟悉基于 Node.js 的构建工具时。
# 声明式渲染
Vue.js 的核心是一个允许采用简洁的模板语法来声明式地将数据渲染进 DOM 的系统:
“`javascript
<div id=”app”>
{{ message }}
</div>
“`
“`javascript
var app = new Vue({
el: ‘#app’,
data: {
message: ‘Hello Vue!’
}
})
“`
我们已经成功创建了第一个 Vue 应用!看起来这跟渲染一个字符串模板非常类似,但是 Vue 在背后做了大量工作。现在数据和 DOM 已经被建立了关联,所有东西都是响应式的。我们要怎么确认呢?打开你的浏览器的 JavaScript 控制台 (就在这个页面打开),并修改 app.message 的值,你将看到上例相应地更新。
除了文本插值,我们还可以像这样来绑定素特性:
‘, ‘<p>Vue (读音 /vjuː/,类似于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是,Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层,不仅易于上手,还便于与第三方库或既有项目整合。另一方面,当与现代化的工具链以及各种支持类库结合使用时,Vue 也完全能够为复杂的单页应用提供驱动。</p>
<p>如果你想在深入学习 Vue 之前对它有更多了解,我们制作了一个视频,带您了解其核心概念和一个示例工程。<br />
如果你已经是有经验的前端开发者,想知道 Vue 与其它库/框架有哪些区别,请查看对比其它框架。</p>
<h1>起步</h1>
<blockquote>
<p>官方指南假设你已了解关于 HTML、CSS 和 JavaScript 的中级知识。如果你刚开始学习前端开发,将框架作为你的第一步可能不是最好的主意——掌握好基础知识再来吧!之前有其它框架的使用经验会有帮助,但这不是必需的。</p>
</blockquote>
<p>尝试 Vue.js 最简单的方法是使用 JSFiddle 上的 Hello World 例子。你可以在浏览器新标签页中打开它,跟着例子学习一些基础用法。或者你也可以创建一个 .html 文件,然后通过如下方式引入 Vue:</p>
<pre><div class=”hljs”><code class=”lang-javascript”><script src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/<span class=”hljs-string”>”https://cdn.jsdelivr.net/npm/vue”</span>><span class=”xml”><span class=”hljs-tag”></<span class=”hljs-name”>script</span>></span></span>
</code></div></pre>
<p>安装教程给出了更多安装 Vue 的方式。请注意我们不推荐新手直接使用 vue-cli,尤其是在你还不熟悉基于 Node.js 的构建工具时。</p>
<h1>声明式渲染</h1>
<p>Vue.js 的核心是一个允许采用简洁的模板语法来声明式地将数据渲染进 DOM 的系统:</p>
<pre><div class=”hljs”><code class=”lang-javascript”><div id=<span class=”hljs-string”>”app”</span>>
{{ message }}
<<span class=”hljs-regexp”>/div>
</span></code></div></pre>
<pre><div class=”hljs”><code class=”lang-javascript”><span class=”hljs-keyword”>var</span> app = <span class=”hljs-keyword”>new</span> Vue({
<span class=”hljs-attr”>el</span>: <span class=”hljs-string”>’#app'</span>,
<span class=”hljs-attr”>data</span>: {
<span class=”hljs-attr”>message</span>: <span class=”hljs-string”>’Hello Vue!'</span>
}
})
</code></div></pre>
<p>我们已经成功创建了第一个 Vue 应用!看起来这跟渲染一个字符串模板非常类似,但是 Vue 在背后做了大量工作。现在数据和 DOM 已经被建立了关联,所有东西都是响应式的。我们要怎么确认呢?打开你的浏览器的 JavaScript 控制台 (就在这个页面打开),并修改 app.message 的值,你将看到上例相应地更新。</p>
<p>除了文本插值,我们还可以像这样来绑定素特性:</p>
‘, 9);
INSERT INTO `ms_article_body` VALUES (21, ‘## 快速上手
本节将介绍如何在项目中使用 Element。
使用 Starter Kit
我们提供了通用的项目模板,你可以直接使用。对于 Laravel 用户,我们也准备了相应的模板,同样可以直接下载使用。
如果不希望使用我们提供的模板,请继续阅读。
使用 vue-cli
我们还可以使用 vue-cli 初始化项目,命令如下:
“`language
> npm i -g vue-cli
> mkdir my-project && cd my-project
> vue init webpack
> npm i && npm i element-ui
“`
引入 Element
你可以引入整个 Element,或是根据需要仅引入部分组件。我们先介绍如何引入完整的 Element。
# 完整引入
在 main.js 中写入以下内容:
“`javascript
import Vue from ‘vue’
import ElementUI from ‘element-ui’
import ‘element-ui/lib/theme-chalk/index.css’
import App from ‘https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/App.vue’
Vue.use(ElementUI)
new Vue({
el: ‘#app’,
render: h => h(App)
})
“`
以上代码便完成了 Element 的引入。需要注意的是,样式文件需要单独引入。
# 按需引入
借助 babel-plugin-component,我们可以只引入需要的组件,以达到减小项目体积的目的。
首先,安装 babel-plugin-component:
‘, ‘<h2>快速上手</h2>
<p>本节将介绍如何在项目中使用 Element。</p>
<h3>使用 Starter Kit</h3>
<p>我们提供了通用的项目模板,你可以直接使用。对于 Laravel 用户,我们也准备了相应的模板,同样可以直接下载使用。</p>
<p>如果不希望使用我们提供的模板,请继续阅读。</p>
<h3>使用 vue-cli</h3>
<p>我们还可以使用 vue-cli 初始化项目,命令如下:</p>
<pre><code class=”lang-language”>> npm i -g vue-cli
> mkdir my-project && cd my-project
> vue init webpack
> npm i && npm i element-ui
</code></pre>
<h3>引入 Element</h3>
<p>你可以引入整个 Element,或是根据需要仅引入部分组件。我们先介绍如何引入完整的 Element。</p>
<h4>完整引入</h4>
<p>在 main.js 中写入以下内容:</p>
<pre><div class=”hljs”><code class=”lang-javascript”><span class=”hljs-keyword”>import</span> Vue <span class=”hljs-keyword”>from</span> <span class=”hljs-string”>’vue'</span>
<span class=”hljs-keyword”>import</span> ElementUI <span class=”hljs-keyword”>from</span> <span class=”hljs-string”>’element-ui'</span>
<span class=”hljs-keyword”>import</span> <span class=”hljs-string”>’element-ui/lib/theme-chalk/index.css'</span>
<span class=”hljs-keyword”>import</span> App <span class=”hljs-keyword”>from</span> <span class=”hljs-string”>’https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/App.vue'</span>
Vue.use(ElementUI)
<span class=”hljs-keyword”>new</span> Vue({
<span class=”hljs-attr”>el</span>: <span class=”hljs-string”>’#app'</span>,
<span class=”hljs-attr”>render</span>: <span class=”hljs-function”><span class=”hljs-params”>h</span> =></span> h(App)
})
</code></div></pre>
<p>以上代码便完成了 Element 的引入。需要注意的是,样式文件需要单独引入。</p>
<h4>按需引入</h4>
<p>借助 babel-plugin-component,我们可以只引入需要的组件,以达到减小项目体积的目的。</p>
<p>首先,安装 babel-plugin-component:</p>
‘, 10);
INSERT INTO `ms_article_body` VALUES (1405564731351162882, ‘666666666666’, ‘<p>666666666666</p>
‘, 1405564731300831233);
INSERT INTO `ms_article_body` VALUES (1405909844828909569, ‘# 1. Spring Boot介绍
## 1.1 简介
在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?
在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?
那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!
Spring Boot让我们的Spring应用变的更轻量化。
我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。
通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过`java -jar`命令就可以运行起来。
这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。
总结一下Spring Boot的主要优点:
1. 为所有Spring开发者更快的入门
2. 开箱即用,提供各种默认配置来简化项目配置
3. 内嵌式容器简化Web项目
4. 没有冗余代码生成和XML配置的要求
5. 统一的依赖管理
6. 自动装配,更易使用,更易扩展
## 1.2 使用版本说明
Springboot版本:使用最新的2.5.0版本
教程参考了官方文档进行制作,权威。
其他依赖版本:
1. Maven 需求:3.5+
2. JDK 需求 8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0 但是可以部署到Servlet到3.1+的容器中
# 2. 快速入门
快速的创建一个Spring Boot应用,并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。
教程使用的Idea版本:2019.3
## 2.1 创建基础项目
第一步: 创建maven项目
pom.xml :
~~~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.xiaopizhu</groupId>
<artifactId>helloSpringBoot</artifactId>
<version>1.0-SNAPSHOT</version>
<!–springboot的父工程其中定义了常用的依赖,并且无依赖冲突–>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
</project>
~~~
注意上方的parent必须加,其中定义了springboot官方支持的n多依赖,基本上常用的已经有了,所以接下来导入依赖的时候,绝大部分都可以不加版本号。
此时的工程结构为:
![image20210523173241557.png](https://static.mszlu.com/6fc39758-0db2-431d-9f94-a705aa2c7e59.png)
第二步: 添加web依赖
~~~xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
~~~
添加上方的web依赖,其中间接依赖了spring-web,spring-webmvc,spring-core等spring和springmvc的包,并且集成了tomcat。
第三步: 编写启动类
~~~java
package com.xiaopizhu.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloApp {
public static void main(String[] args) {
SpringApplication.run(HelloApp.class,args);
}
}
~~~
@SpringBootApplication注解标识了HelloApp为启动类,也是Spring Boot的核心。
第四步: 运行启动类的main方法
![image-20210523173712142](img/image-20210523173712142.png)
看到如上配置,证明启动成功,tomcat端口号默认为8080。
第五步: 如果想要修改端口号,可以在resources目录下新建application.properties
~~~properties
server.port=8082
~~~
第六步: 重新运行
![image-20210523174011613](img/image-20210523174011613.png)
此时的项目结构为:
![image-20210523174032053](img/image-20210523174032053.png)
src/main/java : 编写java代码,注意启动类需要放在项目的根包下。
src/main/resources: 放置资源的目录,比如springboot的配置文件,静态文件,mybatis配置,日志配置等。
src/test/java: 测试代码
## 2.2 编写一个Http接口
第一步: 创建`HelloController`类,内容如下:
~~~java
package com.xiaopizhu.springboot.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(“hello”)
public class HelloController {
@GetMapping(“boot”)
public String hello(){
return “hello spring boot”;
}
}
~~~
注意包名,必须在启动类所在的包名下。
第二步: 重启程序,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.3 编写单测试用例
第一步: 添加spring boot测试依赖
~~~xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
~~~
第二步: 在src/test 下,编写测试用例
~~~java
package com.xiaopizhu.springboot.controller;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest
public class TestHelloController {
private MockMvc mockMvc;
@BeforeEach
public void beforeEach(){
mockMvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
}
@Test
public void testHello() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get(“/hello/boot”)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo(“hello spring boot”)));
}
}
~~~
上面的测试用例,是构建一个空的`WebApplicationContext`,并且在before中加载了HelloController,得以在测试用例中mock调用,模拟请求。
## 2.4 打包为jar运行
第一步: 添加打包(maven构建springboot)插件
~~~xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
~~~
在idea的右侧 maven中,使用package来打包程序,打包完成后,在target目录下生成helloSpringBoot-1.0-SNAPSHOT.jar
![image-20210523181737720](img/image-20210523181737720.png)
第二步: 打开cmd:找到jar对应的目录
输入命令
~~~shell
java -jar helloSpringBoot-1.0-SNAPSHOT.jar
~~~
![image-20210523182426404](img/image-20210523182426404.png)
第三步: 测试,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.5 查看jar包内容
~~~shell
jar tvf helloSpringBoot-1.0-SNAPSHOT.jar
~~~
# 3. 小结
1. 通过Maven构建了一个空白Spring Boot项目,再通过引入web模块实现了一个简单的请求处理。
2. 通过修改配置文件,更改端口号
3. 编写了测试用例
4. 打包jar包运行
‘, ‘<h1><a id=”1_Spring_Boot_0″></a>1. Spring Boot介绍</h1>
<h2><a id=”11__2″></a>1.1 简介</h2>
<p>在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?</p>
<p>在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?</p>
<p>那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!</p>
<p>Spring Boot让我们的Spring应用变的更轻量化。</p>
<p>我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。</p>
<p>通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过<code>java -jar</code>命令就可以运行起来。</p>
<p>这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。</p>
<p><strong>总结一下Spring Boot的主要优点:</strong></p>
<ol>
<li>为所有Spring开发者更快的入门</li>
<li>开箱即用,提供各种默认配置来简化项目配置</li>
<li>内嵌式容器简化Web项目</li>
<li>没有冗余代码生成和XML配置的要求</li>
<li>统一的依赖管理</li>
<li>自动装配,更易使用,更易扩展</li>
</ol>
<h2><a id=”12__27″></a>1.2 使用版本说明</h2>
<p>Springboot版本:使用最新的2.5.0版本</p>
<p>教程参考了官方文档进行制作,权威。</p>
<p>其他依赖版本:</p>
<pre><code>1. Maven 需求:3.5+
2. JDK 需求 8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0 但是可以部署到Servlet到3.1+的容器中
</code></pre>
<h1><a id=”2__42″></a>2. 快速入门</h1>
<p>快速的创建一个Spring Boot应用,并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。</p>
<p>教程使用的Idea版本:2019.3</p>
<h2><a id=”21__48″></a>2.1 创建基础项目</h2>
<p><strong>第一步:</strong> 创建maven项目</p>
<p>pom.xml :</p>
<pre><div class=”hljs”><code class=”lang-xml”><span class=”php”><span class=”hljs-meta”><?</span>xml version=<span class=”hljs-string”>”1.0″</span> encoding=<span class=”hljs-string”>”UTF-8″</span><span class=”hljs-meta”>?></span></span>
<span class=”hljs-tag”><<span class=”hljs-name”>project</span> <span class=”hljs-attr”>xmlns</span>=<span class=”hljs-string”>”http://maven.apache.org/POM/4.0.0″</span>
<span class=”hljs-attr”>xmlns:xsi</span>=<span class=”hljs-string”>”http://www.w3.org/2001/XMLSchema-instance”</span>
<span class=”hljs-attr”>xsi:schemaLocation</span>=<span class=”hljs-string”>”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>modelVersion</span>></span>4.0.0<span class=”hljs-tag”></<span class=”hljs-name”>modelVersion</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>com.xiaopizhu<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>helloSpringBoot<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>version</span>></span>1.0-SNAPSHOT<span class=”hljs-tag”></<span class=”hljs-name”>version</span>></span>
<span class=”hljs-comment”><!–springboot的父工程其中定义了常用的依赖,并且无依赖冲突–></span>
<span class=”hljs-tag”><<span class=”hljs-name”>parent</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-parent<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>version</span>></span>2.5.0<span class=”hljs-tag”></<span class=”hljs-name”>version</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>parent</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>project</span>></span>
</code></div></pre>
<p>注意上方的parent必须加,其中定义了springboot官方支持的n多依赖,基本上常用的已经有了,所以接下来导入依赖的时候,绝大部分都可以不加版本号。</p>
<p>此时的工程结构为:</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/6fc39758-0db2-431d-9f94-a705aa2c7e59.png” alt=”image20210523173241557.png” /></p>
<p><strong>第二步:</strong> 添加web依赖</p>
<pre><div class=”hljs”><code class=”lang-xml”><span class=”hljs-tag”><<span class=”hljs-name”>dependencies</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-web<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependencies</span>></span>
</code></div></pre>
<p>添加上方的web依赖,其中间接依赖了spring-web,spring-webmvc,spring-core等spring和springmvc的包,并且集成了tomcat。</p>
<p><strong>第三步:</strong> 编写启动类</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot;
<span class=”hljs-keyword”>import</span> org.springframework.boot.SpringApplication;
<span class=”hljs-keyword”>import</span> org.springframework.boot.autoconfigure.SpringBootApplication;
<span class=”hljs-meta”>@SpringBootApplication</span>
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>HelloApp</span> </span>{
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>static</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>main</span><span class=”hljs-params”>(String[] args)</span> </span>{
SpringApplication.run(HelloApp.class,args);
}
}
</code></div></pre>
<p>@SpringBootApplication注解标识了HelloApp为启动类,也是Spring Boot的核心。</p>
<p><strong>第四步:</strong> 运行启动类的main方法</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”img/image-20210523173712142.png” alt=”image-20210523173712142″ /></p>
<p>看到如上配置,证明启动成功,tomcat端口号默认为8080。</p>
<p><strong>第五步:</strong> 如果想要修改端口号,可以在resources目录下新建application.properties</p>
<pre><code class=”lang-properties”>server.port=8082
</code></pre>
<p><strong>第六步:</strong> 重新运行</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”img/image-20210523174011613.png” alt=”image-20210523174011613″ /></p>
<p>此时的项目结构为:</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”img/image-20210523174032053.png” alt=”image-20210523174032053″ /></p>
<p><strong>src/main/java :</strong> 编写java代码,注意启动类需要放在项目的根包下。</p>
<p><strong>src/main/resources:</strong> 放置资源的目录,比如springboot的配置文件,静态文件,mybatis配置,日志配置等。</p>
<p><strong>src/test/java:</strong> 测试代码</p>
<h2><a id=”22_Http_138″></a>2.2 编写一个Http接口</h2>
<p><strong>第一步:</strong> 创建<code>HelloController</code>类,内容如下:</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot.controller;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.GetMapping;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.RequestMapping;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.RestController;
<span class=”hljs-meta”>@RestController</span>
<span class=”hljs-meta”>@RequestMapping</span>(<span class=”hljs-string”>”hello”</span>)
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>HelloController</span> </span>{
<span class=”hljs-meta”>@GetMapping</span>(<span class=”hljs-string”>”boot”</span>)
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> String <span class=”hljs-title”>hello</span><span class=”hljs-params”>()</span></span>{
<span class=”hljs-keyword”>return</span> <span class=”hljs-string”>”hello spring boot”</span>;
}
}
</code></div></pre>
<p><strong>注意包名,必须在启动类所在的包名下。</strong></p>
<p>第二步: 重启程序,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot</p>
<p>得到结果:hello spring boot</p>
<h2><a id=”23__168″></a>2.3 编写单测试用例</h2>
<p>第一步: 添加spring boot测试依赖</p>
<pre><div class=”hljs”><code class=”lang-xml”> <span class=”hljs-tag”><<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-test<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>scope</span>></span>test<span class=”hljs-tag”></<span class=”hljs-name”>scope</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependency</span>></span>
</code></div></pre>
<p><strong>第二步:</strong> 在src/test 下,编写测试用例</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot.controller;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.BeforeAll;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.BeforeEach;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.Test;
<span class=”hljs-keyword”>import</span> org.springframework.boot.test.context.SpringBootTest;
<span class=”hljs-keyword”>import</span> org.springframework.http.MediaType;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.MockMvc;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.setup.MockMvcBuilders;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.hamcrest.Matchers.equalTo;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
<span class=”hljs-meta”>@SpringBootTest</span>
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>TestHelloController</span> </span>{
<span class=”hljs-keyword”>private</span> MockMvc mockMvc;
<span class=”hljs-meta”>@BeforeEach</span>
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>beforeEach</span><span class=”hljs-params”>()</span></span>{
mockMvc = MockMvcBuilders.standaloneSetup(<span class=”hljs-keyword”>new</span> HelloController()).build();
}
<span class=”hljs-meta”>@Test</span>
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>testHello</span><span class=”hljs-params”>()</span> <span class=”hljs-keyword”>throws</span> Exception </span>{
mockMvc.perform(MockMvcRequestBuilders.get(<span class=”hljs-string”>”/hello/boot”</span>)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo(<span class=”hljs-string”>”hello spring boot”</span>)));
}
}
</code></div></pre>
<p>上面的测试用例,是构建一个空的<code>WebApplicationContext</code>,并且在before中加载了HelloController,得以在测试用例中mock调用,模拟请求。</p>
<h2><a id=”24_jar_220″></a>2.4 打包为jar运行</h2>
<p><strong>第一步:</strong> 添加打包(maven构建springboot)插件</p>
<pre><div class=”hljs”><code class=”lang-xml”> <span class=”hljs-tag”><<span class=”hljs-name”>build</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>plugins</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>plugin</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-maven-plugin<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>plugin</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>plugins</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>build</span>></span>
</code></div></pre>
<p>在idea的右侧 maven中,使用package来打包程序,打包完成后,在target目录下生成helloSpringBoot-1.0-SNAPSHOT.jar</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”img/image-20210523181737720.png” alt=”image-20210523181737720″ /></p>
<p>第二步: 打开cmd:找到jar对应的目录</p>
<p>输入命令</p>
<pre><div class=”hljs”><code class=”lang-shell”>java -jar helloSpringBoot-1.0-SNAPSHOT.jar
</code></div></pre>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”img/image-20210523182426404.png” alt=”image-20210523182426404″ /></p>
<p><strong>第三步:</strong> 测试,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot</p>
<p>得到结果:hello spring boot</p>
<h2><a id=”25_jar_253″></a>2.5 查看jar包内容</h2>
<pre><div class=”hljs”><code class=”lang-shell”>jar tvf helloSpringBoot-1.0-SNAPSHOT.jar
</code></div></pre>
<h1><a id=”3__259″></a>3. 小结</h1>
<ol>
<li>通过Maven构建了一个空白Spring Boot项目,再通过引入web模块实现了一个简单的请求处理。</li>
<li>通过修改配置文件,更改端口号</li>
<li>编写了测试用例</li>
<li>打包jar包运行</li>
</ol>
‘, 1405909844724051969);
INSERT INTO `ms_article_body` VALUES (1405916999854342146, ‘# 1. Spring Boot介绍
## 1.1 简介
在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?
在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?
那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!
Spring Boot让我们的Spring应用变的更轻量化。
我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。
通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过`java -jar`命令就可以运行起来。
这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。
总结一下Spring Boot的主要优点:
1. 为所有Spring开发者更快的入门
2. 开箱即用,提供各种默认配置来简化项目配置
3. 内嵌式容器简化Web项目
4. 没有冗余代码生成和XML配置的要求
5. 统一的依赖管理
6. 自动装配,更易使用,更易扩展
## 1.2 使用版本说明
Springboot版本:使用最新的2.5.0版本
教程参考了官方文档进行制作,权威。
其他依赖版本:
1. Maven 需求:3.5+
2. JDK 需求 8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0 但是可以部署到Servlet到3.1+的容器中
# 2. 快速入门
快速的创建一个Spring Boot应用,并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。
教程使用的Idea版本:2019.3
## 2.1 创建基础项目
第一步: 创建maven项目
pom.xml :
~~~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.xiaopizhu</groupId>
<artifactId>helloSpringBoot</artifactId>
<version>1.0-SNAPSHOT</version>
<!–springboot的父工程其中定义了常用的依赖,并且无依赖冲突–>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
</project>
~~~
注意上方的parent必须加,其中定义了springboot官方支持的n多依赖,基本上常用的已经有了,所以接下来导入依赖的时候,绝大部分都可以不加版本号。
此时的工程结构为:
![image20210523173241557.png](https://static.mszlu.com/a7302c88-e106-46ad-9713-dc9a6d523957.png)
第二步: 添加web依赖
~~~xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
~~~
添加上方的web依赖,其中间接依赖了spring-web,spring-webmvc,spring-core等spring和springmvc的包,并且集成了tomcat。
第三步: 编写启动类
~~~java
package com.xiaopizhu.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloApp {
public static void main(String[] args) {
SpringApplication.run(HelloApp.class,args);
}
}
~~~
@SpringBootApplication注解标识了HelloApp为启动类,也是Spring Boot的核心。
第四步: 运行启动类的main方法
![image20210523173712142.png](https://static.mszlu.com/dc17b43e-08df-46b0-bb7a-eb73044de7da.png)
看到如上配置,证明启动成功,tomcat端口号默认为8080。
第五步: 如果想要修改端口号,可以在resources目录下新建application.properties
~~~properties
server.port=8082
~~~
第六步: 重新运行
![image20210523174011613.png](https://static.mszlu.com/318e4b7e-95d2-4e43-a18f-279ea6ff9495.png)
此时的项目结构为:
![image20210523174032053.png](https://static.mszlu.com/756e4ae0-c4c7-43a5-9b5d-bc7ce974a942.png)
src/main/java : 编写java代码,注意启动类需要放在项目的根包下。
src/main/resources: 放置资源的目录,比如springboot的配置文件,静态文件,mybatis配置,日志配置等。
src/test/java: 测试代码
## 2.2 编写一个Http接口
第一步: 创建`HelloController`类,内容如下:
~~~java
package com.xiaopizhu.springboot.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(“hello”)
public class HelloController {
@GetMapping(“boot”)
public String hello(){
return “hello spring boot”;
}
}
~~~
注意包名,必须在启动类所在的包名下。
第二步: 重启程序,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.3 编写单测试用例
第一步: 添加spring boot测试依赖
~~~xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
~~~
第二步: 在src/test 下,编写测试用例
~~~java
package com.xiaopizhu.springboot.controller;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest
public class TestHelloController {
private MockMvc mockMvc;
@BeforeEach
public void beforeEach(){
mockMvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
}
@Test
public void testHello() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get(“/hello/boot”)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo(“hello spring boot”)));
}
}
~~~
上面的测试用例,是构建一个空的`WebApplicationContext`,并且在before中加载了HelloController,得以在测试用例中mock调用,模拟请求。
## 2.4 打包为jar运行
第一步: 添加打包(maven构建springboot)插件
~~~xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
~~~
在idea的右侧 maven中,使用package来打包程序,打包完成后,在target目录下生成helloSpringBoot-1.0-SNAPSHOT.jar
![image20210523181737720.png](https://static.mszlu.com/45aa0db2-598f-4564-964c-a2d889dfbafe.png)
第二步: 打开cmd:找到jar对应的目录
输入命令
~~~shell
java -jar helloSpringBoot-1.0-SNAPSHOT.jar
~~~
![image20210523182426404.png](https://static.mszlu.com/74376f77-b8eb-4c2c-a4cc-d3bfe24901e3.png)
第三步: 测试,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果:hello spring boot
## 2.5 查看jar包内容
~~~shell
jar tvf helloSpringBoot-1.0-SNAPSHOT.jar
~~~
# 3. 小结
1. 通过Maven构建了一个空白Spring Boot项目,再通过引入web模块实现了一个简单的请求处理。
2. 通过修改配置文件,更改端口号
3. 编写了测试用例
4. 打包jar包运行
‘, ‘<h1><a id=”1_Spring_Boot_0″></a>1. Spring Boot介绍</h1>
<h2><a id=”11__2″></a>1.1 简介</h2>
<p>在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?</p>
<p>在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?</p>
<p>那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!</p>
<p>Spring Boot让我们的Spring应用变的更轻量化。</p>
<p>我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。</p>
<p>通过Spring Boot实现的服务,只需要依靠一个Java类,把它打包成jar,并通过<code>java -jar</code>命令就可以运行起来。</p>
<p>这一切相较于传统Spring应用来说,已经变得非常的轻便、简单。</p>
<p><strong>总结一下Spring Boot的主要优点:</strong></p>
<ol>
<li>为所有Spring开发者更快的入门</li>
<li>开箱即用,提供各种默认配置来简化项目配置</li>
<li>内嵌式容器简化Web项目</li>
<li>没有冗余代码生成和XML配置的要求</li>
<li>统一的依赖管理</li>
<li>自动装配,更易使用,更易扩展</li>
</ol>
<h2><a id=”12__27″></a>1.2 使用版本说明</h2>
<p>Springboot版本:使用最新的2.5.0版本</p>
<p>教程参考了官方文档进行制作,权威。</p>
<p>其他依赖版本:</p>
<pre><code>1. Maven 需求:3.5+
2. JDK 需求 8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0 但是可以部署到Servlet到3.1+的容器中
</code></pre>
<h1><a id=”2__42″></a>2. 快速入门</h1>
<p>快速的创建一个Spring Boot应用,并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。</p>
<p>教程使用的Idea版本:2019.3</p>
<h2><a id=”21__48″></a>2.1 创建基础项目</h2>
<p><strong>第一步:</strong> 创建maven项目</p>
<p>pom.xml :</p>
<pre><div class=”hljs”><code class=”lang-xml”><span class=”php”><span class=”hljs-meta”><?</span>xml version=<span class=”hljs-string”>”1.0″</span> encoding=<span class=”hljs-string”>”UTF-8″</span><span class=”hljs-meta”>?></span></span>
<span class=”hljs-tag”><<span class=”hljs-name”>project</span> <span class=”hljs-attr”>xmlns</span>=<span class=”hljs-string”>”http://maven.apache.org/POM/4.0.0″</span>
<span class=”hljs-attr”>xmlns:xsi</span>=<span class=”hljs-string”>”http://www.w3.org/2001/XMLSchema-instance”</span>
<span class=”hljs-attr”>xsi:schemaLocation</span>=<span class=”hljs-string”>”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>modelVersion</span>></span>4.0.0<span class=”hljs-tag”></<span class=”hljs-name”>modelVersion</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>com.xiaopizhu<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>helloSpringBoot<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>version</span>></span>1.0-SNAPSHOT<span class=”hljs-tag”></<span class=”hljs-name”>version</span>></span>
<span class=”hljs-comment”><!–springboot的父工程其中定义了常用的依赖,并且无依赖冲突–></span>
<span class=”hljs-tag”><<span class=”hljs-name”>parent</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-parent<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>version</span>></span>2.5.0<span class=”hljs-tag”></<span class=”hljs-name”>version</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>parent</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>project</span>></span>
</code></div></pre>
<p>注意上方的parent必须加,其中定义了springboot官方支持的n多依赖,基本上常用的已经有了,所以接下来导入依赖的时候,绝大部分都可以不加版本号。</p>
<p>此时的工程结构为:</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/a7302c88-e106-46ad-9713-dc9a6d523957.png” alt=”image20210523173241557.png” /></p>
<p><strong>第二步:</strong> 添加web依赖</p>
<pre><div class=”hljs”><code class=”lang-xml”><span class=”hljs-tag”><<span class=”hljs-name”>dependencies</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-web<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependencies</span>></span>
</code></div></pre>
<p>添加上方的web依赖,其中间接依赖了spring-web,spring-webmvc,spring-core等spring和springmvc的包,并且集成了tomcat。</p>
<p><strong>第三步:</strong> 编写启动类</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot;
<span class=”hljs-keyword”>import</span> org.springframework.boot.SpringApplication;
<span class=”hljs-keyword”>import</span> org.springframework.boot.autoconfigure.SpringBootApplication;
<span class=”hljs-meta”>@SpringBootApplication</span>
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>HelloApp</span> </span>{
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>static</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>main</span><span class=”hljs-params”>(String[] args)</span> </span>{
SpringApplication.run(HelloApp.class,args);
}
}
</code></div></pre>
<p>@SpringBootApplication注解标识了HelloApp为启动类,也是Spring Boot的核心。</p>
<p><strong>第四步:</strong> 运行启动类的main方法</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/dc17b43e-08df-46b0-bb7a-eb73044de7da.png” alt=”image20210523173712142.png” /></p>
<p>看到如上配置,证明启动成功,tomcat端口号默认为8080。</p>
<p><strong>第五步:</strong> 如果想要修改端口号,可以在resources目录下新建application.properties</p>
<pre><code class=”lang-properties”>server.port=8082
</code></pre>
<p><strong>第六步:</strong> 重新运行</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/318e4b7e-95d2-4e43-a18f-279ea6ff9495.png” alt=”image20210523174011613.png” /></p>
<p>此时的项目结构为:</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/756e4ae0-c4c7-43a5-9b5d-bc7ce974a942.png” alt=”image20210523174032053.png” /></p>
<p><strong>src/main/java :</strong> 编写java代码,注意启动类需要放在项目的根包下。</p>
<p><strong>src/main/resources:</strong> 放置资源的目录,比如springboot的配置文件,静态文件,mybatis配置,日志配置等。</p>
<p><strong>src/test/java:</strong> 测试代码</p>
<h2><a id=”22_Http_138″></a>2.2 编写一个Http接口</h2>
<p><strong>第一步:</strong> 创建<code>HelloController</code>类,内容如下:</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot.controller;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.GetMapping;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.RequestMapping;
<span class=”hljs-keyword”>import</span> org.springframework.web.bind.annotation.RestController;
<span class=”hljs-meta”>@RestController</span>
<span class=”hljs-meta”>@RequestMapping</span>(<span class=”hljs-string”>”hello”</span>)
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>HelloController</span> </span>{
<span class=”hljs-meta”>@GetMapping</span>(<span class=”hljs-string”>”boot”</span>)
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> String <span class=”hljs-title”>hello</span><span class=”hljs-params”>()</span></span>{
<span class=”hljs-keyword”>return</span> <span class=”hljs-string”>”hello spring boot”</span>;
}
}
</code></div></pre>
<p><strong>注意包名,必须在启动类所在的包名下。</strong></p>
<p>第二步: 重启程序,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot</p>
<p>得到结果:hello spring boot</p>
<h2><a id=”23__168″></a>2.3 编写单测试用例</h2>
<p>第一步: 添加spring boot测试依赖</p>
<pre><div class=”hljs”><code class=”lang-xml”> <span class=”hljs-tag”><<span class=”hljs-name”>dependency</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-starter-test<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>scope</span>></span>test<span class=”hljs-tag”></<span class=”hljs-name”>scope</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>dependency</span>></span>
</code></div></pre>
<p><strong>第二步:</strong> 在src/test 下,编写测试用例</p>
<pre><div class=”hljs”><code class=”lang-java”><span class=”hljs-keyword”>package</span> com.xiaopizhu.springboot.controller;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.BeforeAll;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.BeforeEach;
<span class=”hljs-keyword”>import</span> org.junit.jupiter.api.Test;
<span class=”hljs-keyword”>import</span> org.springframework.boot.test.context.SpringBootTest;
<span class=”hljs-keyword”>import</span> org.springframework.http.MediaType;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.MockMvc;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
<span class=”hljs-keyword”>import</span> org.springframework.test.web.servlet.setup.MockMvcBuilders;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.hamcrest.Matchers.equalTo;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
<span class=”hljs-keyword”>import</span> <span class=”hljs-keyword”>static</span> org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
<span class=”hljs-meta”>@SpringBootTest</span>
<span class=”hljs-keyword”>public</span> <span class=”hljs-class”><span class=”hljs-keyword”>class</span> <span class=”hljs-title”>TestHelloController</span> </span>{
<span class=”hljs-keyword”>private</span> MockMvc mockMvc;
<span class=”hljs-meta”>@BeforeEach</span>
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>beforeEach</span><span class=”hljs-params”>()</span></span>{
mockMvc = MockMvcBuilders.standaloneSetup(<span class=”hljs-keyword”>new</span> HelloController()).build();
}
<span class=”hljs-meta”>@Test</span>
<span class=”hljs-function”><span class=”hljs-keyword”>public</span> <span class=”hljs-keyword”>void</span> <span class=”hljs-title”>testHello</span><span class=”hljs-params”>()</span> <span class=”hljs-keyword”>throws</span> Exception </span>{
mockMvc.perform(MockMvcRequestBuilders.get(<span class=”hljs-string”>”/hello/boot”</span>)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo(<span class=”hljs-string”>”hello spring boot”</span>)));
}
}
</code></div></pre>
<p>上面的测试用例,是构建一个空的<code>WebApplicationContext</code>,并且在before中加载了HelloController,得以在测试用例中mock调用,模拟请求。</p>
<h2><a id=”24_jar_220″></a>2.4 打包为jar运行</h2>
<p><strong>第一步:</strong> 添加打包(maven构建springboot)插件</p>
<pre><div class=”hljs”><code class=”lang-xml”> <span class=”hljs-tag”><<span class=”hljs-name”>build</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>plugins</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>plugin</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>groupId</span>></span>org.springframework.boot<span class=”hljs-tag”></<span class=”hljs-name”>groupId</span>></span>
<span class=”hljs-tag”><<span class=”hljs-name”>artifactId</span>></span>spring-boot-maven-plugin<span class=”hljs-tag”></<span class=”hljs-name”>artifactId</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>plugin</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>plugins</span>></span>
<span class=”hljs-tag”></<span class=”hljs-name”>build</span>></span>
</code></div></pre>
<p>在idea的右侧 maven中,使用package来打包程序,打包完成后,在target目录下生成helloSpringBoot-1.0-SNAPSHOT.jar</p>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/45aa0db2-598f-4564-964c-a2d889dfbafe.png” alt=”image20210523181737720.png” /></p>
<p>第二步: 打开cmd:找到jar对应的目录</p>
<p>输入命令</p>
<pre><div class=”hljs”><code class=”lang-shell”>java -jar helloSpringBoot-1.0-SNAPSHOT.jar
</code></div></pre>
<p><img src=https://gitee.com/zhang-ruilin-1/personal-blog-project/blob/master/”https://static.mszlu.com/74376f77-b8eb-4c2c-a4cc-d3bfe24901e3.png” alt=”image20210523182426404.png” /></p>
<p><strong>第三步:</strong> 测试,使用postman或者直接在浏览器输入http://localhost:8082/hello/boot</p>
<p>得到结果:hello spring boot</p>
<h2><a id=”25_jar_253″></a>2.5 查看jar包内容</h2>
<pre><div class=”hljs”><code class=”lang-shell”>jar tvf helloSpringBoot-1.0-SNAPSHOT.jar
</code></div></pre>
<h1><a id=”3__259″></a>3. 小结</h1>
<ol>
<li>通过Maven构建了一个空白Spring Boot项目,再通过引入web模块实现了一个简单的请求处理。</li>
<li>通过修改配置文件,更改端口号</li>
<li>编写了测试用例</li>
<li>打包jar包运行</li>
</ol>
‘, 1405916999732707330);
— —————————-
— Table structure for ms_article_tag
— —————————-
DROP TABLE IF EXISTS `ms_article_tag`;
CREATE TABLE `ms_article_tag` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`article_id` bigint(0) NOT NULL,
`tag_id` bigint(0) NOT NULL,
PRIMARY KEY (`id`) USING BTREE,
INDEX `article_id`(`article_id`) USING BTREE,
INDEX `tag_id`(`tag_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1405916999787233282 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_article_tag
— —————————-
INSERT INTO `ms_article_tag` VALUES (1, 1, 7);
INSERT INTO `ms_article_tag` VALUES (2, 1, 5);
INSERT INTO `ms_article_tag` VALUES (3, 1, 8);
INSERT INTO `ms_article_tag` VALUES (4, 9, 7);
INSERT INTO `ms_article_tag` VALUES (5, 10, 7);
INSERT INTO `ms_article_tag` VALUES (6, 10, 8);
INSERT INTO `ms_article_tag` VALUES (7, 10, 5);
INSERT INTO `ms_article_tag` VALUES (8, 10, 6);
INSERT INTO `ms_article_tag` VALUES (1405564731321802753, 1405564731300831233, 5);
INSERT INTO `ms_article_tag` VALUES (1405909844761800706, 1405909844724051969, 5);
INSERT INTO `ms_article_tag` VALUES (1405916999787233281, 1405916999732707330, 5);
— —————————-
— Table structure for ms_category
— —————————-
DROP TABLE IF EXISTS `ms_category`;
CREATE TABLE `ms_category` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`avatar` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
`category_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
`description` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_category
— —————————-
INSERT INTO `ms_category` VALUES (1, ‘/static/category/front.png’, ‘前端’, ‘前端是什么,大前端’);
INSERT INTO `ms_category` VALUES (2, ‘/static/category/back.png’, ‘后端’, ‘后端最牛叉’);
INSERT INTO `ms_category` VALUES (3, ‘/static/category/lift.jpg’, ‘生活’, ‘生活趣事’);
INSERT INTO `ms_category` VALUES (4, ‘/static/category/database.png’, ‘数据库’, ‘没数据库,啥也不管用’);
INSERT INTO `ms_category` VALUES (5, ‘/static/category/language.png’, ‘编程语言’, ‘好多语言,该学哪个?’);
— —————————-
— Table structure for ms_comment
— —————————-
DROP TABLE IF EXISTS `ms_comment`;
CREATE TABLE `ms_comment` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`content` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
`create_date` bigint(0) NOT NULL,
`article_id` int(0) NOT NULL,
`author_id` bigint(0) NOT NULL,
`parent_id` bigint(0) NOT NULL,
`to_uid` bigint(0) NOT NULL,
`level` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
PRIMARY KEY (`id`) USING BTREE,
INDEX `article_id`(`article_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1405209691876790275 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_comment
— —————————-
INSERT INTO `ms_comment` VALUES (53, ‘写的好’, 123213213213, 1, 1, 0, 1, ‘1’);
INSERT INTO `ms_comment` VALUES (54, ‘111’, 123123123123, 1, 1, 53, 1, ‘2’);
INSERT INTO `ms_comment` VALUES (56, ‘222’, 12312, 1, 1, 0, 1, ‘1’);
INSERT INTO `ms_comment` VALUES (1405204547248377858, ‘123’, 1623861846172, 1, 1, 53, 1, ‘2’);
INSERT INTO `ms_comment` VALUES (1405205050975899650, ‘123123’, 1623861966270, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405205572185280513, ‘3333’, 1623862090534, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405206087392612353, ‘7777’, 1623862213367, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405206147568291842, ‘7777’, 1623862227714, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405206347246522370, ‘666’, 1623862275315, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405208637198131202, ‘99999999999999999999’, 1623862821278, 1, 1, 0, 0, ‘1’);
INSERT INTO `ms_comment` VALUES (1405209691876790274, ‘66666666666666666’, 1623863072732, 1, 1, 1405208637198131202, 1, ‘2’);
— —————————-
— Table structure for ms_permission
— —————————-
DROP TABLE IF EXISTS `ms_permission`;
CREATE TABLE `ms_permission` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
`path` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
`description` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_permission
— —————————-
INSERT INTO `ms_permission` VALUES (1, ‘查询权限列表’, ‘/admin/permission/permissionList’, ‘查询权限列表’);
INSERT INTO `ms_permission` VALUES (2, ’11’, ’11’, ‘111’);
INSERT INTO `ms_permission` VALUES (7, ‘1213’, ‘123’, ‘123’);
INSERT INTO `ms_permission` VALUES (8, ‘删除权限’, ‘/admin/permission/add’, ‘删除权限’);
— —————————-
— Table structure for ms_sys_log
— —————————-
DROP TABLE IF EXISTS `ms_sys_log`;
CREATE TABLE `ms_sys_log` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`create_date` bigint(0) NULL DEFAULT NULL,
`ip` varchar(15) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
`method` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
`module` varchar(10) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
`nickname` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
`operation` varchar(25) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
`params` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
`time` bigint(0) NULL DEFAULT NULL,
`userid` bigint(0) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_sys_log
— —————————-
— —————————-
— Table structure for ms_sys_user
— —————————-
DROP TABLE IF EXISTS `ms_sys_user`;
CREATE TABLE `ms_sys_user` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`account` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘账号’,
`admin` bit(1) NULL DEFAULT NULL COMMENT ‘是否管理员’,
`avatar` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘头像’,
`create_date` bigint(0) NULL DEFAULT NULL COMMENT ‘注册时间’,
`deleted` bit(1) NULL DEFAULT NULL COMMENT ‘是否删除’,
`email` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘邮箱’,
`last_login` bigint(0) NULL DEFAULT NULL COMMENT ‘最后登录时间’,
`mobile_phone_number` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘手机号’,
`nickname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘昵称’,
`password` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘密码’,
`salt` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘加密盐’,
`status` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ‘状态’,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1404448588146192387 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_sys_user
— —————————-
INSERT INTO `ms_sys_user` VALUES (1, ‘admin’, b’1′, ‘http://localhost:8080/static/img/logo.b3a48c0.png’, 20210622223122, b’0′, ’11’, 20210630223130, ’12’, ‘李四’, ’15f08f86435b060236fa9ccea751e9e5′, ’12’, ‘1’);
INSERT INTO `ms_sys_user` VALUES (1404446129264832513, ‘lisi’, b’1′, ‘/static/img/logo.b3a48c0.png’, 1623681025218, b’0′, ”, 1623681025218, NULL, ‘李四’, ‘1d01d52c40f4ff57ad3f93a06daf21d5’, ”, ”);
INSERT INTO `ms_sys_user` VALUES (1404448463944462338, ‘12213’, b’1′, ‘/static/img/logo.b3a48c0.png’, 1623681581855, b’0′, ”, 1623681581855, NULL, ‘123’, ‘8628d1f407f72e10ac947a032fe5ad29’, ”, ”);
INSERT INTO `ms_sys_user` VALUES (1404448588146192386, ‘123’, b’1′, ‘/static/img/logo.b3a48c0.png’, 1623681611474, b’0′, ”, 1623681611474, NULL, ‘123’, ‘5e112646dbf3570f8e23d0cf1027ede1’, ”, ”);
— —————————-
— Table structure for ms_tag
— —————————-
DROP TABLE IF EXISTS `ms_tag`;
CREATE TABLE `ms_tag` (
`id` bigint(0) NOT NULL AUTO_INCREMENT,
`avatar` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
`tag_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 11 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
— —————————-
— Records of ms_tag
— —————————-
INSERT INTO `ms_tag` VALUES (5, ‘/static/tag/java.png’, ‘springboot’);
INSERT INTO `ms_tag` VALUES (6, ‘/static/tag/java.png’, ‘spring’);
INSERT INTO `ms_tag` VALUES (7, ‘/static/tag/java.png’, ‘springmvc’);
INSERT INTO `ms_tag` VALUES (8, ‘/static/tag/css.png’, ’11’Navicat for Premium 9.0.2激活);
SET FOREIGN_KEY_CHECKS = 1;
一键复制 编辑 原始数据 按行查看 历史 今天的文章
Navicat for Premium 9.0.2激活(张瑞临1 / 个人博客项目.gitee-modal {width: 500px !important; })分享到此就结束了,感谢您的阅读。
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/104967.html