Spring Boot
20 分钟 读完 (大约 3056 个字) 阅读次数: 0次访问

Spring Boot快速入门--你好Spring Boot

spring boot可以让你的开发更甜蜜~~**

Build Anything with Spring Boot：

Spring Boot is the starting point for building all Spring-based applications. Spring Boot is designed to get you up and running as quickly as possible, with minimal upfront nfiguration of Spring.

Spring Boot 简化了 spring 应用开发的框架

官方文档: 世界上最好的文档来自官方

一.使用 Spring Boot有什么好处?以及简单的搭建过程

其实就是简单、快速、方便！平时如果我们需要搭建一个 Spring Web 项目的时候需要怎么做呢？

  • 1）配置 web.xml，加载 Spring 和 Spring mvc
  • 2）配置数据库连接、配置 Spring 事务
  • 3）配置加载配置文件的读取，开启注解
  • 4）配置日志文件
  • …
  • 配置完成之后部署 Tomcat 调试
  • …

现在非常流行微服务，如果我这个项目仅仅只是需要发送一个邮件，如果我的项目仅仅是生产一个积分；我都需要这样折腾一遍!

但是如果使用 Spring Boot 呢？
很简单，我仅仅只需要非常少的几个配置就可以迅速方便的搭建起来一套 Web 项目或者是构建一个微服务！

1.开发环境:

idea

jdk1.8

windows 10

Mysql

2.创建项目

使用idea new一个 Spring Lnitializr > 设置group Artifact >选择web>勾选web>设置项目路径还有名称>Finish

第一次创建会有点慢,它需要下载很多依赖

创建好之后的包默认生成了以下>

  • SpringbootApplication： 一个带有 main() 方法的类，用于启动应用程序

  • SpringbootApplicationTests：一个空的 Junit 测试了，它加载了一个使用 Spring Boot 字典配置功能的 Spring 应用程序上下文

  • application.properties：一个空的 properties 文件，可以根据需要添加配置属性

  • pom.xml： Maven 构建说明文件

3.创建一个controller包,再创建HelloController类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.carson.springboot.controller;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("hello")
    public String hello(){
        return "Spring boot!";
    }
}

@RestController 注解： 该注解是 @Controller 和 @ResponseBody 注解的合体版

4.启动SpringbootApplication:

人家启动成功的图标:

再看看我的😭:

有可能是分辨率还是什么关系?

启动SpringbootApplication:

SpringbootApplication启动后,它内置了tomcat ,不需要我们另外进行配置,我们可以直接访问 controller 中的 方法

端口号默认是 8080 可能你的不是,但是他会再控制台输出:

这是页面:

5.解析以下 Spring Boot 项目

pom.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.carson</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

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

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

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

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

</project>

<parent> :这个标签是在配置 Spring Boot 的父级依赖：

1
2
3
4
5
6
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

spring-boot-starter-parent 是一个特殊的 starter ，它用来提供相关的 Maven 默认依赖，使用它之后，常用的包依赖就可以省去 version 标签。

>应用入口类

Spring Boot 项目通常有一个名为 *Application 的入口类，入口类里有一个 main 方法， 这个 main 方法其实就是一个标准的 Javay 应用的入口方法。

springboot入口

@SpringBootApplication 是 Spring Boot 的核心注解，它是一个组合注解，该注解组合了：

@Configuration、@EnableAutoConfiguration、@ComponentScan； 若不是用 @SpringBootApplication 注解也可以使用这三个注解代替。

  • 其中，@EnableAutoConfiguration 让 Spring Boot 根据类路径中的 jar 包依赖为当前项目进行自动配置，例如，添加了 spring-boot-starter-web 依赖，会自动添加 Tomcat 和 Spring MVC 的依赖，那么 Spring Boot 会对 Tomcat 和 Spring MVC 进行自动配置。
  • Spring Boot 还会自动扫描 @SpringBootApplication 所在类的同级包以及下级包里的 Bean ，所以入口类建议就配置在 grounpID + arctifactID 组合的包名下（这里为 cn.wmyskxz.springboot 包）

>Spring Boot 的配置文件

Spring Boot 使用一个全局的配置文件 application.properties 或 application.yml，放置在【src/main/resources】目录或者类路径的 /config 下。

Spring Boot 不仅支持常规的 properties 配置文件，还支持 yaml 语言的配置文件。yaml 是以数据为中心的语言，在配置数据的时候具有面向对象的特征。

Spring Boot 的全局配置文件的作用是对一些默认配置的配置值进行修改。

我把 application.properties 删掉了,我创建了 application.yml , 因为我感觉yml的语法更加的适合我

我这里使用 application.yml 进行配置(两者在语法上不同):

1
2
3
4
5
6
7
serber:
  port: 8080
  servlet:
    context-path: /hello
student:
    name: carson
    age: 18

我们同样的将 Tomcat 默认端口设置为 8080 ，并将默认的访问路径从 “/” 修改为 “/hello”,并设置自己的信息

pom.xml:

1
2
3
4
5
6
<!-- 配置文件 处理器-->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-configuration-processor</artifactId>
          <optional>true</optional>
      </dependency>

导入配置文件处理器,写yml会有提示

先去创建一个类 StudentProperties :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.carson.springboot.domain;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "student")
public class StudentProperties {

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

我们可以把配置信息封装成一个类，首先在我们的 name 和 age 前加一个 student 前缀，然后新建一个 StudentProperties 的类用来封装这些信息，并用上两个注解：

  • @Component：表明当前类是一个 Java Bean/放在容器里,和配置文件相关配置进行绑定
  • @ConfigurationProperties(prefix = “student”)：表示获取前缀为 sutdent 的配置信息,默认从全局配置文件中获取

我们的Controller修改成以下:

1
2
3
4
5
6
7
8
@Autowired
   private StudentProperties studentProperties;

   @RequestMapping("/hello")
   public String hello(){
       return studentProperties.getName() + studentProperties.getAge();
   	//会在页面显示我们的信息
   }

>Spring Boot 热部署

在目前的 Spring Boot 项目中，当发生了任何修改之后我们都需要重新启动才能够正确的得到效果，这样会略显麻烦，Spring Boot 提供了热部署的方式，当发现任何类发生了改变，就会通过 JVM 类加载的方式，加载最新的类到虚拟机中，这样就不需要重新启动也能看到修改后的效果了。

  • 做法也很简单，修改 pom.xml 即可！

我们往 pom.xml 中添加一个依赖就可以了：

1
2
3
4
5
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
</dependency>

重新启动 Spring Boot ，然后修改任意代码，就能观察到控制台的自动重启现象

关于idea Spring Boot 项目的简单搭建 已经结束

二.Spring Boot 使用

上面已经完成了 Spring Boot 项目的简单搭建，我们仅仅需要进行一些简单的设置，写一个 HelloController 就能够直接运行了，不要太简单…接下来我们再深入了解一下 Spring Boot 的使用。

1.使Spring Boot 支持 JSP

Spring Boot 的默认视图支持是 Thymeleaf 模板引擎，但是这个我们不熟悉啊，我们还是想要使用 JSP 怎么办呢？

  • 第一步：修改 pom.xml 增加对 JSP 文件的支持
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- servlet依赖. -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

<!-- tomcat的支持.-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
  • 第二步：配置试图重定向 JSP 文件的位置

修改 application.yml 文件，将我们的 JSP 文件重定向到 /WEB-INF/views/ 目录下(设置前缀和后缀)：

1
2
3
4
5
6
spring:
   mvc:
     view:
       prefix: /WEB-INF/views/
       suffix: .jsp
       //如果你学过ssm 那么你能感觉出来这是 前缀 和 后缀
  • 第三步：修改 HelloController

修改 @RestController 注解为 @Controller ，然后将 hello 方法修改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.carson.springboot.controller;


import com.carson.springboot.domain.StudentProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.DateFormat;
import java.util.Date;

/**
 *  @RestController 注解： 该注解是 @Controller 和 @ResponseBody 注解的合体版
 *
 * */
@Controller
public class HelloController {

//    @Autowired
//    private StudentProperties studentProperties;

    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("now", DateFormat.getDateTimeInstance().format(new Date()));
        return "hello";
    }
}
  • 第四步：新建 hello.jsp 文件

在【src/main】目录下依次创建 webapp>WEB-INF>views 目录，并创建一个 hello.jsp 文件：

hello.jsp

1
2
3
4
5
6
7
8
9
10
11
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>

hello jsp! 现在时间是 ${now}

</body>
</html>
  • 第五步：刷新网页

因为我们部署了热部署功能，所以只需要等待控制台重启信息完成之后再刷新网页就可以看到正确效果了：

2.集成 MyBatis

  • 第一步：修改 pom.xml 增加对 MySql和 MyBatis 的支持
1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>

<!-- mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.21</version>
</dependency>
  • 第二步：新增数据库链接参数

我这里使用我之前 ssm 整合时的 user 表:

yml文件>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
serber:
  port: 8080
  servlet:
    context-path: /list
student:
    name: carson
    age: 18
spring:
   mvc:
     view:
       prefix: /WEB-INF/views/
       suffix: .jsp
   datasource:
     url: jdbc:mysql:///ssm
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.Driver
   jpa:
     hibernate:
       ddl-auto: update

url中的localhost ,可以用/// 代替

hibernate下面有几个参数:

  • validate 加载 Hibernate 时，验证创建数据库表结构

  • create 每次加载 Hibernate ，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。

  • create-drop 加载 Hibernate 时创建，退出是删除表结构

  • update 加载 Hibernate 自动更新数据库结构

    如果你想保留表结构的数据，使用 update 即可。

  • 第三步：创建 Student 实体类和 StudentMapper 映射类

在【com.carson.springboot】下的【domain】包，然后在其下创建一个 User 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.carson.springboot.domain;

import lombok.*;

import java.math.BigDecimal;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class User {

    private Long id;
    private String username;
    private String password;
    private int age;
    private BigDecimal salary;
    
    /*各种 setter getter tostring  全参,无参构造*/
}

在【com.carson.springboot】下创建mapper包，然后在其下创建一个 UserMapper映射类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.carson.springboot.mapper;

import com.carson.springboot.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
	//sql语句直接写在注解上
    @Select("select * from user")
    List<User>  list();
}
  • 第四步：编写 StudentController

在【com.carson.springboot】下新建一个【controller】包，然后在其下创建一个UserController ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.carson.springboot.controller;

import com.carson.springboot.domain.User;
import com.carson.springboot.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @RequestMapping("list")
    public String list(Model model){
        List<User> users = userMapper.list();
        model.addAttribute("users",users);
        return "list";
    }
}

第五步：编写 listStudent.jsp 文件

我们简化一下 JSP 的文件，仅显示两个字段的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
    <title>list</title>
</head>

<body>

<table align='center' border='1' cellspacing='0'>
    <tr>
        <td>id</td>
        <td>name</td>
        <td>age</td>
        <td>salary</td>
        <td>password</td>
    </tr>
    <c:forEach items="${users}" var="s" varStatus="st">
        <tr>
            <td>${s.id}</td>
            <td>${s.username}</td>
            <td>${s.age}</td>
            <td>${s.salary}</td>
            <td>${s.password}</td>
        </tr>
    </c:forEach>
</table>

</body>
</html>
  • 第六步：重启服务器运行

因为往 pom.xml 中新增加了依赖的包，所以自动重启服务器没有作用，我们需要手动重启一次，

然后在地址输入：localhost:8080/list查看效果：

总结

以下我遇到的错误:

这里说我的数据源有问题👇

我的yml配置文件之前是这样的:

1
2
3
4
5
6
7
8
9
10
11
12
13
spring:
   mvc:
     view:
       prefix: /WEB-INF/views/
       suffix: .jsp
   datasource:
     url: jdbc:mysql:///ssm
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.Driver
jpa: 这里
  hibernate:
    ddl-auto: update

jpa这个字段单独出来了,它应该是跟 datasource和mvc字段 同级, 而不是跟spring同级,

yml的空格是严格的

改正:

1
2
3
4
5
6
7
8
9
10
11
12
13
spring:
   mvc:
     view:
       prefix: /WEB-INF/views/
       suffix: .jsp
   datasource:
     url: jdbc:mysql:///ssm
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.Driver
   jpa:
     hibernate:
       ddl-auto: update

这次的spring boot学习过程,还算顺利,终究要感谢网路上这么多优秀的前辈,他们写的博客非常优秀,以至于给我的学习过程给予很大的帮助

终于知道了spring boot的强大,相对我的上一篇博客写的ssm框架整合,少了很多配置文件,看起来很清爽

# Spring Boot

喜欢这篇文章？打赏一下作者吧

Spring Boot--开发Web应用-Thymeleaf(一)
SSM框架整合回顾(一)
关注我

分类

标签云

Druid Hadoop Hbase Interceptor SSM Scala Servlet Spring Spring Boot Thymeleaf WebFlow sql 微服务 我的博客搭建过程 数据结构 算法 闲聊 黑科技

最新文章

归档

标签

Druid 1
Hadoop 1
Hbase 1
Interceptor 1
SSM 1
Scala 2
Servlet 1
Spring 1
Spring Boot 4
Thymeleaf 2
WebFlow 1
sql 1
微服务 1
我的博客搭建过程 1
数据结构 1
算法 1
闲聊 1
黑科技 1

最新文章

归档

标签

Druid 1
Hadoop 1
Hbase 1
Interceptor 1
SSM 1
Scala 2
Servlet 1
Spring 1
Spring Boot 4
Thymeleaf 2
WebFlow 1
sql 1
微服务 1
我的博客搭建过程 1
数据结构 1
算法 1
闲聊 1
黑科技 1
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×