springboot入门

Not_Point

已于 2022-04-08 10:47:48 修改

阅读量1.2k

点赞数

文章标签： springboot

于 2022-04-07 20:11:30 首次发布

本文链接：https://blog.csdn.net/m0_55871462/article/details/124025227

版权

SpringBoot

第1章 Spring Boot 框架入门

1.1 Spring Boot 简介

Spring Boot 是 Spring 家族中的一个全新的框架，它用来简化 Spring 应用程序的创建和开发过程，也可以说 Spring Boot 能简化我们之前采用 SpringMVC + Spring + MyBatis 框架进行开发的过程。在以往我们采用 SpringMVC + Spring + MyBatis 框架进行开发的时候，搭建和整合三大框架，我们需要做很多工作，比如配置 web.xml，配置 Spring，配置 MyBatis，并将它们整合在一起等，而 Spring Boot 框架对此开发过程进行了革命性的颠覆，完全抛弃了繁琐的 xml 配置过程，采用大量的默认配置简化我们的开发过程。所以采用 Spring Boot 可以非常容易和快速地创建基于 Spring 框架的应用程序，它让编码变简单了，配置变简单了，部署变简单了，监控变简单了。正因为 Spring Boot 它化繁为简，让开发变得极其简单和快速，所以在业界备受关注。 Spring Boot 在国内的关注趋势图：http://t.cn/ROQLquP

1.2 Spring Boot 的特性

➢ 能够快速创建基于 Spring 的应用程序

➢ 能够直接使用 java main 方法启动内嵌的 Tomcat 服务器运行 Spring Boot 程序，不需要部署 war 包文件

➢ 提供约定的 starter POM 来简化 Maven 配置，让 Maven 的配置变得简单

➢ 自动化配置，根据项目的 Maven 依赖配置，Spring boot 自动配置 Spring、Spring mvc 等

➢ 提供了程序的健康检查等功能

➢ 基本可以完全不使用 XML 配置文件，采用注解配置

1.3 Spring Boot 四大核心

自动配置
起步依赖
Actuator
命令行界面

第2章 Spring Boot 入门案例

2.1 第一个 SpringBoot 项目

2.1.1 开发步骤

（1）创建一个 Module，选择类型为 Spring Initializr 快速构建

（2）设置 GAV 坐标及 pom 配置信息

（3）选择 Spring Boot 版本及依赖会根据选择的依赖自动添加起步依赖并进行自动配置

（4）设置模块名称、Content Root 路径及模块文件的目录点击 Finish，如果是第一次创建，在右下角会提示正在下载相关的依赖

（5）项目创建完毕，如下

（6）项目结构

static：存放静态资源，如图片、CSS、JavaScript 等

templates：存放 Web 页面的模板文件

application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如服务端口，数据库连接配置等

2.2 入门案例

2.2.2 创建一个新的 Module，选择类型为 Spring Initializr

2.2.3 指定 GAV 及 pom 配置信息

2.2.4 选择 Spring Boot 版本及依赖会根据选择的依赖自动添加起步依赖并进行自动配置

2.2.5 修改 Content Root 路径及文件所在目录

2.2.6 对 pom.xml 文件进行解释

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://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.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.bjpowernode.springboot</groupId>
    <artifactId>001-springboot-first</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <name>001-springboot-first11</name>
    <description>Demo project for Spring Boot1111</description>

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

    <dependencies>
        <!--SpringBoot框架web项目起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--SpringBoot框架测试起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--SpringBoot框架编译打包的插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.2.7 对 SpringBoot 项目结构进行说明

➢ .mvn|mvnw|mvnw.cmd：使用脚本操作执行 maven 相关命令，国内使用较少，可删除

➢ .gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容

➢ static|templates：后面模板技术中存放文件的目录

➢ application.properties：SpringBoot 的配置文件，很多集成的配置都可以在该文件中进行配置，例如：Spring、springMVC、Mybatis、Redis 等。目前是空的

➢ static：存放静态资源，如图片、CSS、JavaScript 等 templates：存放 Web 页面的模板文件 application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如服务端口，数据库连接配置等

➢ Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，SpringBoot 就启动了

2.2.8 创建一个 Spring MVC 的 Spring BootController

SpringBootController 类所在包：com.bjpowernode.springboot.web package com.bjpowernode.springboot.web;

package com.bjpowernode.springboot.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class IndexController {

    @RequestMapping(value = "/index")
    public @ResponseBody Object index(){
        return "Hello SpringBoot Web Project!";
    }
}

注意：新创建的类一定要位于 Application 同级目录或者下级目录，否则 SpringBoot 加载不到。

2.2.9 在 IDEA 中右键，运行 Application 类中的 main 方法通过在控制台的输出，可以看到启动 SpringBoot 框架，会启动一个内嵌的 tomcat，端口号为 8080，上下文根为空

2.2.10 在浏览器中输入 http://localhost:8080/springBoot/say 访问

2.3 入门案例分析

➢ Spring Boot 的父级依赖 spring-boot-starter-parent 配置之后，当前的项目就是 Spring Boot 项目

➢ spring-boot-starter-parent 是一个 Springboot 的父级依赖，开发 SpringBoot 程序都需要继承该父级项目，它用来提供相关的 Maven 默认依赖，使用它之后，常用的 jar 包依赖可以省去 version 配置

➢ Spring Boot 提供了哪些默认 jar 包的依赖，可查看该父级依赖的 pom 文件

➢ 如果不想使用某个默认的依赖版本，可以通过 pom.xml 文件的属性配置覆盖各个依赖项，比如覆盖 Spring 版本 5.0.0.RELEASE

➢ @SpringBootApplication 注解是 Spring Boot 项目的核心注解，主要作用是开启 Spring 自动配置，如果在 Application 类上去掉该注解，那么不会启动 SpringBoot 程序

➢ main 方法是一个标准的 Java 程序的 main 方法，主要作用是作为项目启动运行的入口

➢ @Controller 及 @ResponseBody 依然是我们之前的 Spring MVC，因为 Spring Boot 的里面依然是使用我们的 Spring MVC + Spring + MyBatis 等框架

2.4 Spring Boot 的核心配置文件

Spring Boot 的核心配置文件用于配置 Spring Boot 程序，名字必须以 application 开始

2.4.1 核心配置格式

（7） .properties 文件（默认采用该文件）

在 002-springboot-springmvc 项目基础上，进行修改项目名称：003-springboot-port-context-path 通过修改 application.properties 配置文件，在修改默认 tomcat 端口号及项目上下文件根键值对的 properties 属性文件配置方式

#设置内嵌 Tomcat 端口号
server.port=8090 
#配置项目上下文根 
server.servlet.context-path=/springboot

配置完毕之后，启动浏览器测试页面显示结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GvfVxE5B-1649333231313)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220406112613960.png)]

（8） .yml 文件项目名称：004-springboot-yml，在 003 项目基础之上 yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 后缀也可以使用 yaml 后缀

注意：当两种格式配置文件同时存在，使用的是.properties 配置文件，为了演示 yml，可以先将其改名，重新运行 Application，查看启动的端口及上下文根

2.4.2 多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体步骤如下

（9）项目名称：005-springboot-multi-environment 为每个环境创建一个配置文件，命名必须以 application-环境标识.properties|yml

application-dev.properties

#开发环境   
#设置内嵌 Tomcat 默认端口号 
server.port=8080 
#设置项目的上下文根 
server.servlet.context-path=/005-springboot-multi-environment-dev

application-product.properties

#生产环境 
#配置内嵌 Tomcat 默认端口号 
server.port=80 
#配置项目上下文根 
server.servlet.context-path=/005-springboot-multi-environment-product

application-test.properties

#测试环境 
#配置内嵌 Tomcat 端口号 
server.port=8081 
#配置项目的上下文根 
server.servlet.context-path=/005-springboot-multi-environment-test

在总配置文件 application.properties 进行环境的激活

#SpringBoot 的总配置文件 
#激活开发环境 
#spring.profiles.active=dev 
#激活测试环境 
#spring.profiles.active=test
#激活生产环境 
spring.profiles.active=product

等号右边的值和配置文件的环境标识名一致，可以更改总配置文件的配置，重新运行 Application，查看启动的端口及上下文根

（10）项目名称：006-springboot-multi-environment 为每个环境创建一个配置文件，命名必须以 application-环境标识.properties|yml SpringBoot 总配置文件：

application.yml

#springboot 总配置文件 
#激活开发环境 
spring: 
	profiles: 
		active: dev  
#激活测试环境 
spring: 
	profiles:
		active: test 
#激活生产环境
spring: 
	profiles: 
		active: product

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

#设置开发环境配置 server: #设置 Tomcat 内嵌端口号  port: 8081  servlet:  #设置上下文根    context-path: /dev

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

#设置测试环境配置server:  port: 8082  servlet:    context-path: /test

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

#设置生产环境配置server:  port: 9090  servlet:    context-path: /product

2.5 Spring Boot 前端使用 JSP

2.5.1 配置pom.xml 文件

在 pom.xml 文件中配置以下依赖项

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://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.3.4.RELEASE</version>        <relativePath/> <!-- lookup parent from repository -->    </parent>    <groupId>com.bjpowernode.springboot</groupId>    <artifactId>009-springboot-custom-configuration-properties</artifactId>    <version>0.0.1-SNAPSHOT</version>    <name>009-springboot-custom-configuration-properties</name>    <description>Demo project for Spring Boot</description>    <properties>        <java.version>1.8</java.version>    </properties>    <dependencies>    <dependency>         <groupId>org.apache.tomcat.embed</groupId>         <artifactId>tomcat-embed-jasper</artifactId>    </dependency>    <!--如果要使用 servlet 必须添加该以下两个依赖-->    <!-- servlet 依赖的 jar 包-->    <dependency>     <groupId>javax.servlet</groupId>     <artifactId>javax.servlet-api</artifactId>    </dependency>    <dependency>     <groupId>javax.servlet.jsp</groupId>     <artifactId>javax.servlet.jsp-api</artifactId>     <version>2.3.1</version>    </dependency>    <!--如果使用 JSTL 必须添加该依赖-->    <!--jstl 标签依赖的 jar 包 start-->        <dependency>         <groupId>javax.servlet</groupId>         <artifactId>jstl</artifactId>        </dependency>    </dependencies>    <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                <artifactId>spring-boot-maven-plugin</artifactId>            </plugin>        </plugins>    </build></project>

2.5.2 配置pom.xml的build标签

在 pom.xml 的 build 标签中要配置以下信息

SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则访问不到。其实官方已经更建议使用模板技术（后面会讲模板技术）

<!--    SpringBoot框架集成jsp，指定jsp文件编译的路径META-INF/resources--><resources>    <resource>        <!--指定源文件路径-->        <directory>src/main/webapp</directory>        <!--指定编译的路径-->        <targetPath>META-INF/resources</targetPath>        <includes>            <include>*.*</include>        </includes>    </resource>    <resource>        <directory>src/main/resources</directory>        <includes>            <include>**/*.*</include>        </includes>    </resource></resources>

2.5.3 配置application.properties 文件

在 application.properties 文件配置 Spring MVC 的视图展示为 jsp，这里相当于 Spring MVC 的配置

#视图解析器spring.mvc.view.prefix=/spring.mvc.view.suffix=.jsp

集成完毕之后，剩下的步骤和我们使用 Spring MVC 一样 application.yml 格式的配置文件

#SpringBoot 核心配置文件 #指定内嵌 Tomcat 端口号 server: port: 8090 servlet: context-path: / #配置 SpringMVC 视图解析器 #其中：/ 表示目录为 src/main/webapp spring: mvc: view: prefix: / suffix: .jsp

2.5.4 编写控制层

在 com.abc.springboot.controller 包下创建 JspController 类，并编写代码

package com.bjpowernode.springboot.web;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {    @RequestMapping(value = "/index")    public String index(Model model){        model.addAttribute("data","SpringBoot框架集成JSP页面");        return "index";    }}

2.5.5 配置webapp 目录

在 src/main 下创建一个 webapp 目录，然后在该目录下新建 index.jsp 页面如果在webapp目录下右键，没有创建jsp的选项，可以在Project Structure中指定webapp 为 Web Resource Directory

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rRfmyCht-1649333231315)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220406224817168.png)]

2.5.6 编写视图层

在 jsp 中获取 Controller 传递过来的数据 2.5.10 重新运行 Application，通过浏览器访问测试

<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head>    <title>Title</title></head><body><h1>${data}</h1></body></html>

2.5.7 测试运行

重新运行 Application，通过浏览器访问测试

第3章 Spring Boot 框架 Web 开发

3.1 Spring Boot 集成 MyBatis

3.1.1 案例思路

通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作数据库参考：springboot.sql 脚本文件

3.1.2 实现步骤

（1）准备数据库

➢ 启动 mySQL 服务器，通过 Navicat 连接

➢ 创建新的数据库 springboot，指定数据库字符编码为 utf-8

➢ 向表中插入数据

➢ 创建一个新的 SpringBoot 的 Module

➢ 指定 GAV 坐标

➢ 选择 SpringBoot 版本以及 web 依赖

➢ 修改 Content root 以及 Mudule file location

（3）在 pom.xml 中添加相关 jar 依赖

<!--MyBatis整合springboot框架起步依赖--><dependency>    <groupId>org.mybatis.spring.boot</groupId>    <artifactId>mybatis-spring-boot-starter</artifactId>    <version>2.0.1</version></dependency><!--MySQL驱动--><dependency>    <groupId>mysql</groupId>    <artifactId>mysql-connector-java</artifactId>    <!--<version>5.1.38</version>--></dependency>

（4）在 Springboot 的核心配置文件 application.properties 中配置数据源

#连接数据库信息spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driverspring.datasource.url=jdbc:mysql://192.168.80.129:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghaispring.datasource.username=rootspring.datasource.password=root

（5）开发代码

➢ 使用 Mybatis 反向工程生成接口、映射文件以及实体 bean

package com.bjpowernode.springboot.model;@Datapublic class Student {    private Integer id;    private String stuName;    private Integer stuAge;}

➢ 在 web 包下创建 StudentController 并编写代码

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.model.Student;import com.bjpowernode.springboot.service.StudentService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controllerpublic class StudentController {    @Autowired    private StudentService studentService;    @RequestMapping(value = "/student/detail")    public @ResponseBody Object studentDetail(Integer id){        Student student = studentService.queryStudentById(id);        return student;    }}

➢ 在 service 包下创建 service 接口并编写代码

package com.bjpowernode.springboot.service;import com.bjpowernode.springboot.model.Student;public interface StudentService {    /**     * 根据学生标识获取学生详情     * @param id     * @return     */    Student queryStudentById(Integer id);}

➢ 在 service.impl 包下创建 service 接口并编写代码

package com.bjpowernode.springboot.service.impl;import com.bjpowernode.springboot.mapper.StudentMapper;import com.bjpowernode.springboot.model.Student;import com.bjpowernode.springboot.service.StudentService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Servicepublic class StudentServiceImpl implements StudentService {    @Autowired    private StudentMapper studentMapper;    @Override    public Student queryStudentById(Integer id) {        return studentMapper.selectByPrimaryKey(id);    }}

➢ 如果在 web 中导入 service 存在报错，可以尝试进行如下配置解决

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FLjeenQZ-1649333231316)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220406231008655.png)]

➢ 在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解 @Mapper

作用：mybatis 自动扫描数据持久层的映射文件及 DAO 接口的关系

package com.bjpowernode.springboot.mapper;import com.bjpowernode.springboot.model.Student;import org.apache.ibatis.annotations.Mapper;@Mapperpublic interface StudentMapper {    int deleteByPrimaryKey(Integer id);    int insert(Student record);    int insertSelective(Student record);    Student selectByPrimaryKey(Integer id);    int updateByPrimaryKeySelective(Student record);    int updateByPrimaryKey(Student record);}

➢ 注意：默认情况下，Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下，所以我们需要在 pom.xml 文件中配置 resource src/main/java **/*.xml

<resources>    <resource>        <directory>src/main/java</directory>        <includes>            <include>**/*.xml</include>        </includes>    </resource>    <resource>        <directory>src/main/resources</directory>        <includes>            <include>**/*.*</include>        </includes>    </resource></resources>

（6）启动 Application 应用，浏览器访问测试运行

3.1.3 DAO 其它开发方式

（7）在运行的主类上添加注解包扫描 @MapperScan(“com.abc.springboot.mapper”) 注释掉 StudentMapper 接口上的@Mapper 注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JflIH9Ut-1649333231317)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220406231419454.png)]

在运行主类 Application 上加@MapperScan(“com.abc.springboot.mapper”)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FNP0HvTN-1649333231318)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220406231519616.png)]

或

@SpringBootApplication //Mybatis 提供的注解：扫描数据持久层的 mapper 映谢配置文件,DAO 接口上就不用加@Mapper //basePackages 通常指定到数据持久层包即可 @MapperScan(basePackages = "com.abc.springboot.mapper") public class Application {	...}

测试运行

（8）将接口和映射文件分开

因为 SpringBoot 不能自动编译接口映射的 xml 文件，还需要手动在 pom 文件中指定，所以有的公司直接将映射文件直接放到 resources 目录下

➢ 在 resources 目录下新建目录 mapper 存放映射文件，将 StudentMapper.xml 文件移到 resources/mapper 目录下

➢ 在 application.properties 配置文件中指定映射文件的位置，这个配置只有接口和映射文件不在同一个包的情况下，才需要指定

#指定mybatis映射文件的路径mybatis.mapper-locations=classpath:mapper/*.xml

3.2 Spring Boot 事务支持

Spring Boot 使用事务非常简单，底层依然采用的是 Spring 本身提供的事务管理

➢ 在入口类中使用注解 @EnableTransactionManagement 开启事务支持

➢ 在访问数据库的 Service 方法上添加注解 @Transactional 即可

3.2.1 案例思路

通过 SpringBoot +MyBatis 实现对数据库学生表的更新操作，在 service 层的方法中构建异常，查看事务是否生效

3.2.2 实现步骤

在 StudentController 中添加更新学生的方法

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.model.Student;import com.bjpowernode.springboot.service.StudentService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controllerpublic class StudentController {    @Autowired    private StudentService studentService;    @RequestMapping(value = "update")    public @ResponseBody Object update(Integer id, String studentName){        Student student = new Student();        student.setId(id);        student.setStuName(studentName);        int modifyCount = studentService.modifyStudentById(student);        return "修改的结果：" + modifyCount;    }    @RequestMapping(value = "/student/detail")    public @ResponseBody Object studentDetail(Integer id){        Student student = studentService.queryStudentById(id);        return student;    }}

在 StudentService 接口中添加更新学生方法

int modifyStudentById(Student student);

在 StudentServiceImpl 接口实现类中对更新学生方法进行实现，并构建一个异常，同时在该方法上加@Transactional 注解

package com.bjpowernode.springboot.service.impl;import com.bjpowernode.springboot.mapper.StudentMapper;import com.bjpowernode.springboot.model.Student;import com.bjpowernode.springboot.service.StudentService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;@Servicepublic class StudentServiceImpl implements StudentService {    @Autowired    private StudentMapper studentMapper;    @Transactional    @Override    public int modifyStudentById(Student student) {        int modifyCount = studentMapper.updateByPrimaryKeySelective(student);        int a = 10/0;        return modifyCount;    }    @Override    public Student queryStudentById(Integer id) {        return studentMapper.selectByPrimaryKey(id);    }}

在Application类上加@EnableTransactionManagement 开启事务支持

package com.bjpowernode.springboot;import org.mybatis.spring.annotation.MapperScan;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.transaction.annotation.EnableTransactionManagement;@SpringBootApplication@MapperScan(basePackages = "com.bjpowernode.springboot.mapper")@EnableTransactionManagement    //开启事务，可选项public class Application {    public static void main(String[] args) {        SpringApplication.run(Application.class, args);    }}

启动 Application，通过浏览器访问进行测试

3.3 Spring Boot 下的 Spring MVC

Spring Boot 下的 Spring MVC 和之前的 Spring MVC 使用是完全一样的，主要有以下注解

3.3.1 @Controller

Spring MVC 的注解，处理 http 请求

3.3.2 @RestController

Spring 4 后新增注解，是@Controller 注解功能的增强

是 @Controller 与@ResponseBody 的组合注解

如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当于添加了@ResponseBody 注解

用于返回字符串或 json 数据

3.3.3 @RequestMapping（常用）

支持 Get 请求，也支持 Post 请求

3.3.4 @GetMapping

RequestMapping 和 Get 请求方法的组合只支持 Get 请求 Get 请求主要用于查询操作

3.3.5 @PostMapping

RequestMapping 和 Post 请求方法的组合只支持 Post 请求 Post 请求主要用户新增数据

3.3.6 @PutMapping

RequestMapping 和 Put 请求方法的组合只支持 Put 请求 Put 通常用于修改数据

3.3.7 @DeleteMapping

RequestMapping 和 Delete 请求方法的组合只支持 Delete 请求通常用于删除数据

3.4Spring Boot 实现 RESTful

3.4.1 认识 RESTFul

REST（英文：Representational State Transfer，简称 REST）一种互联网软件架构设计的风格，但它并不是标准，它只是提出了一组客户端和服务器交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次，REST 这个词，是 Roy Thomas Fielding 在他 2000 年的博士论文中提出的。任何的技术都可以实现这种理念，如果一个架构符合 REST 原则，就称它为 RESTFul 架构比如

我们要访问一个 http 接口：http://localhost:8080/boot/order?id=1021&status=1

采用 RESTFul 风格则 http 地址为：http://localhost:8080/boot/order/1021/1

3.4.2 Spring Boot 开发 RESTFul

Spring boot 开发 RESTFul 主要是几个注解实现

（1） @PathVariable

获取 url 中的数据 该注解是实现 RESTFul 最主要的一个注解

（2） @PostMapping

接收和处理 Post 方式的请求

（3） @DeleteMapping

接收 delete 方式的请求，可以使用 GetMapping 代替

（4） @PutMapping

接收 put 方式的请求，可以用 PostMapping 代替

（5） @GetMapping

接收 get 方式的请求

3.4.4 请求冲突的问题

➢ 改路径

➢ 改请求方式

创建 RESTfulController 类，结合 Postman 进行测试说明

@RestControllerpublic class RESTfulController {    /**     * id:订单标识 * status：订单状态 * 请求路径： http://localhost:9090/015-springboot-restful-url-conflict/springBoot/orde r/1/1001 * @param id * @param status * @return     */    @GetMapping(value = "/springBoot/order/{id}/{status}")    public Object queryOrder(@PathVariable("id") Integer id, @PathVariable("status") Integer status) {        Map map = new HashMap();        map.put("id", id);        map.put("status", status);        return map;    }    /**     * id:订单标识 * status：订单状态 * 请求路径： http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1/or der/1001 * @param id * @param status * @return     */    @GetMapping(value = "/springBoot/{id}/order/{status}")    public Object queryOrder1(@PathVariable("id") Integer id, @PathVariable("status") Integer status) {        Map map = new HashMap();        map.put("id", id);        map.put("status", status);        return map;    }	/*query1 和 query2 两个请求路径会发生请求路径冲突问题*/    /**     * id:订单标识 * status：订单状态 * 请求路径： http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1001 /order/1 * @param id * @param status * @return     */    @GetMapping(value = "/springBoot/{status}/order/{id}")    public Object queryOrder2(@PathVariable("id") Integer id, @PathVariable("status") Integer status) {        Map map = new HashMap();        map.put("id", id);        map.put("status", status);        return map;    }    /**     * id:订单标识 * status：订单状态 * 请求路径： http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1001 /order/1 * @param id * @param status * @return     */    @PostMapping(value = "/springBoot/{status}/order/{id}")    public Object queryOrder3(@PathVariable("id") Integer id, @PathVariable("status") Integer status) {        Map map = new HashMap();        map.put("id", id);        map.put("status", status);        return map;    }    /** * query1 和 query2 两个请求路径会发生请求路径冲突问题 * query3 与 query1 和 query2 发生请求冲突 * 注意：虽然两个路径写法改变了，但是由于传递的两个参数都是 int 值，所以不知道该交给 哪个请求进行处理 * 就会出现匹配模糊不清的异常，所以要想解决冲突，有两种方式：     * 1.修改请求路径     * 2.修改请求方式     */}

3.4.5 RESTful 原则

➢ 增 post 请求、删 delete 请求、改 put 请求、查 get 请求

➢ 请求路径不要出现动词例如：查询订单接口 /boot/order/1021/1（推荐） /boot/queryOrder/1021/1（不推荐）

➢ 分页、排序等操作，不需要使用斜杠传参数例如：订单列表接口 /boot/orders?page=1&sort=desc 一般传的参数不是数据库表的字段，可以不采用斜杠

第5章 Spring Boot 使用拦截器

5.1 回顾 SpringMVC 使用拦截器步骤

➢ 自定义拦截器类，实现 HandlerInterceptor 接口

➢ 注册拦截器类

➢ 按照 SpringMVC 方式编写一个拦截器类，实现 HandlerInterceptor 接口

public class UserInterceptor implements HandlerInterceptor {    @Override    public boolean preHandle(HttpServletRequest request,                             HttpServletResponse response, Object handler) throws Exception {        //编写登录拦截业务逻辑        //返回 true 通过        //返回 false 被拦截        System.out.println("--------登录拦截器---------");        return true;    }    @Override    public void postHandle(HttpServletRequest request,                           HttpServletResponse response, Object handler, ModelAndView modelAndView)            throws Exception {    }    @Override    public void afterCompletion(HttpServletRequest request,                                HttpServletResponse response, Object handler, Exception ex) throws            Exception {    }}

5.2 Spring Boot 使用拦截器步骤

5.2.1 创建一个 SpringBoot 框架 Web 项目

5.2.2 实现一个登录拦截器

编写一个拦截器类 UserInterceptor继承HandlerInterceptor 接口

重写 preHandle(),postHandle(),afterCompletion()方法.

public class UserInterceptor implements HandlerInterceptor {    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,                             Object handler) throws Exception {        System.out.println("--------编写拦截规则-------");        //编写拦截规则        //true：通过        //false：不通过        //从 session 中获取结果        Integer code = (Integer) request.getSession().getAttribute("code");        if (null == code) {            response.sendRedirect(request.getContextPath() + "/user/error");            return false;        }        return true;    }    @Override    public void postHandle(HttpServletRequest request, HttpServletResponse response,                           Object handler, ModelAndView modelAndView) throws Exception {    }      @Override    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,                                Object handler, Exception ex) throws Exception {    }}

5.2.3 创建一个控制层

@RestControllerpublic class UserController {    @RequestMapping(value = "/user/account")    public Object queryAccount() {        return "帐户可用余额：900 元";    }    @RequestMapping(value = "/user/verifyRealName")    public Object verifyRealName(HttpServletRequest request) {        request.getSession().setAttribute("code",0);        return "用户实名认证成功";    }    @RequestMapping(value = "/user/error")    public Object error() {        return "用户没有实名认证";    }}

5.2.4 @Configuration 定义配置类-拦截器

在项目中创建一个 config 包，创建一个配置类 InterceptorConfig ，并实现 WebMvcConfigurer 接口，覆盖接口中的 addInterceptors 方法，并为该配置类添加 @Configuration 注解，标注此类为一个配置类，让 Spring Boot 扫描到，这里的操作就相当于 SpringMVC 的注册拦截器，@Configuration 就相当于一个 applicationContext-mvc.xml

    @Configuration //用于定义配置类，可替换 xml 文件；定义一个拦截器，相当于之前的mvc 里的配置public class InterceptorConfig implements WebMvcConfigurer {    @Override    public void addInterceptors(InterceptorRegistry registry) {        //定义需要拦截的路径        String[] addPathPatterns = {                "/user/**",        };        //定义不需要拦截的路径        String[] excludePathPatterns = {                "/user/error",                "/user/verifyRealName"        };        registry.addInterceptor(new UserInterceptor()) //添加要注册的拦截        器对象                .addPathPatterns(addPathPatterns) //添加需要拦截的路径                .excludePathPatterns(excludePathPatterns); //添加不需要拦        截的路径    }}

第9章 Spring Boot 打包与部署

9.1 Spring Boot 程序 war 包部署

9.1.1 创建 Spring Boot Web 项目

创建一个新的 Module
添加 SpringBoot 解析 jsp 依赖

<!--SpringBoot 只解析 JSP 页面依赖--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-tomcat</artifactId>    <scope>provided</scope></dependency>

在 pom.xml 文件中配置 jsp 文件解析目录

        <!-- SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下，否则不能访问-->        <resources>            <resource>                <!--源文件位置-->                <directory>src/main/webapp</directory>                <!--指定编译到 META-INF/resources 目录下，该目录不能随便编写-->                <targetPath>META-INF/resources</targetPath>                <!--指定包含文件-->                <includes>                    <include>**/*.*</include>                </includes>            </resource>        </resources>

创建 webapp 并指定为 web 资源文件夹

在 application.properties 配置文件中配置 jsp 的前后缀

#设置 jsp 的前/后缀spring.mvc.view.prefix=/spring.mvc.view.suffix=.jsp

创建 IndexController 提供方法分别返回字符串及跳转页面

package com.bjpowernode.springboot.web;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controllerpublic class IndexController {    @RequestMapping(value = "/index")    public @ResponseBody Object index(){        return "index";    }}

在 src/main/webapp 目录下创建 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head>    <title>Index</title></head><body>${data},打 war 包!</body></html>

9.1.2 打 War 包

程序入口类需扩展继承 SpringBootServletInitializer类并覆盖 configure 方法

@SpringBootApplicationimport org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.builder.SpringApplicationBuilder;import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;public class Application extends SpringBootServletInitializer {    public static void main(String[] args) {        SpringApplication.run(Application.class, args);    }    @Override    protected SpringApplicationBuilder    configure(SpringApplicationBuilder builder) {        //参数为当前 SpringBoot 启动类        return builder.sources(Application.class);    }}

在 pom.xml 中添加（修改）打包方式为 war

<packaging>war</packaging>

在 pom.xml 中配置 springboot 打包的插件(默认自动加)

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

在 pom.xml 中配置将配置文件编译到类路径

<resources>    <resource>        <!--源文件夹-->        <directory>src/main/webapp</directory>        <!--目标文件夹-->        <targetPath>META-INF/resources</targetPath>        <!--包含的文件-->        <includes>            <include>**/*.*</include>        </includes>    </resource>    <!--mybatis 的 mapper.xml-->    <resource>        <directory>src/main/java</directory>        <includes>            <include>**/*.xml</include>        </includes>    </resource>    <!--src/main/resources 下的所有配置文件编译到 classes 下面去-->    <resource>        <directory>src/main/resources</directory>        <includes>            <include>**/*.*</include>        </includes>    </resource></resources>

在 pom.xml 的 build 标签下通过 finalName 指定打 war 包的名字

<finalName>MyWar</finalName>

通过 Maven package 命令打 war 包到 target 目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G5ZTINJT-1649333231319)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407162603470.png)]

9.1.3 部署到 Tomcat 服务器上测试运行

将 target 目录下生成的 war 包拷贝到 tomcat 的 webapps 目录，并启动 tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OlSN24OG-1649333231320)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407162845681.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfYE0cGK-1649333231320)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407162919627.png)]

通过浏览器访问

9.2 Spring Boot 程序打 Jar 包与运行

因为 SpringBoot 默认打包方式就是 jar 包,所以我们直接执行 Maven 的 package 命令就行了

9.2.1 在 pom.xml 文件中添加 Tomcat 解析 jsp 依赖

<!--SpringBoot项目编译打包的插件--><plugin>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-maven-plugin</artifactId>    <version>1.4.2.RELEASE</version></plugin>

9.2.2 在 pom.xml 文件中添加 resources 配置

<resources>    <resource>        <!--源文件夹-->        <directory>src/main/webapp</directory>        <!--目标文件夹-->        <targetPath>META-INF/resources</targetPath>        <!--包含的文件-->        <includes>            <include>**/*.*</include>        </includes>    </resource>    <!--mybatis 的 mapper.xml-->    <resource>        <directory>src/main/java</directory>        <includes>            <include>**/*.xml</include>        </includes>    </resource>    <!--src/main/resources 下的所有配置文件编译到 classes 下面去-->    <resource>        <directory>src/main/resources</directory>        <includes>            <include>**/*.*</include>        </includes>    </resource></resources>

9.2.3 修改 pom.xml 文件中打包插件的版本

默认 SpingBoot 提供的打包插件版本为 2.2.2.RELEASE，这个版本打的 jar 包 jsp 不能访问，我们这里修改为 1.4.2.RELEASE（其它版本测试都有问题）

<!--SpringBoot项目编译打包的插件--><plugin>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-maven-plugin</artifactId>    <version>1.4.2.RELEASE</version></plugin>

9.2.4 修改 application.properties 配置文件

server.port=9090server.servlet.context-path=/springboot#设置 jsp 的前/后缀spring.mvc.view.prefix=/spring.mvc.view.suffix=.jsp

9.2.5 在 com.abc.springboot.web 包下创建 IndexController

package com.bjpowernode.springboot.web;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import java.util.HashMap;import java.util.Map;@Controllerpublic class IndexController {    @RequestMapping(value = "/abc")    public String abc(Model model) {        model.addAttribute("data","SpringBoot 框架打 jar 运行");        return "abc";    }    @RequestMapping(value = "/abc/json")    public @ResponseBody    Object json() {        Map<String,Object> paramMap = new HashMap<String, Object>();        paramMap.put("code","10000");        return paramMap;    }}

9.2.6 创建 webapp 并指定为 web 资源目录

9.2.7 通过 maven package 打包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oYHSPPBu-1649333231321)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407163807367.png)]

9.2.8 通过 java 命令执行 jar 包，相当于启动内嵌 tomcat

将 target 下的 jar 包拷贝到某一个目录，在该目录下执行 java -jar jar 包名称

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xRvvrRi3-1649333231321)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407163848400.png)]

9.2.9 浏览器访问测试

第13章附录

13.1 SpringBoot 工程下使用 Mybatis 反向工程

13.1.1 拷贝 Mybatis 反向工程配置文件到项目的根目录下

获取目录：GeneratorMapper.xml

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FiVceyia-1649333231322)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407164136247.png)]

13.1.2 根据项目及表的情况，修改 GeneratorMapper.xml 配置

红色标准的地方是需要确认修改的地方，尤其注意

➢ 如果使用高版本，驱动类变为：com.mysql.cj.jdbc.Driver

➢ url 后面应该加属性 nullCatalogMeansCurrent=true，否则生成有问题当前版本 MySQL 数据库为 5.7.18

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE generatorConfiguration        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"><generatorConfiguration>    <!-- 指定连接数据库的 JDBC 驱动包所在位置，指定到你本机的完整路径 -->    <classPathEntry location="D:\mysql-connector-java-5.1.38.jar"/>    <!-- 配置 table 表信息内容体，targetRuntime 指定采用 MyBatis3 的版本 -->    <context id="tables" targetRuntime="MyBatis3">        <!-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 -->        <commentGenerator>            <property name="suppressAllComments" value="true"/>        </commentGenerator>        <!-- 配置数据库连接信息 -->        <jdbcConnection driverClass="com.mysql.jdbc.Driver"                        connectionURL="jdbc:mysql://192.168.80.129:3306/springboot"                        userId="root"                        password="123456">        </jdbcConnection>        <!-- 生成 model 类，targetPackage 指定 model 类的包名， targetProject 指定        生成的 model 放在 eclipse 的哪个工程下面-->        <javaModelGenerator targetPackage="com.bjpowernode.springboot.model"                            targetProject="src/main/java">            <property name="enableSubPackages" value="false"/>            <property name="trimStrings" value="false"/>        </javaModelGenerator>        <!-- 生成 MyBatis 的 Mapper.xml 文件，targetPackage 指定 mapper.xml 文件的        包名， targetProject 指定生成的 mapper.xml 放在 eclipse 的哪个工程下面 -->        <sqlMapGenerator targetPackage="com.bjpowernode.springboot.mapper"                         targetProject="src/main/java">            <property name="enableSubPackages" value="false"/>        </sqlMapGenerator>        <!-- 生成 MyBatis 的 Mapper 接口类文件,targetPackage 指定 Mapper 接口类的包        名， targetProject 指定生成的 Mapper 接口放在 eclipse 的哪个工程下面 -->        <javaClientGenerator type="XMLMAPPER"                             targetPackage="com.bjpowernode.springboot.mapper" targetProject="src/main/java">            <property name="enableSubPackages" value="false"/>        </javaClientGenerator>        <!-- 数据库表名及对应的 Java 模型类名 -->        <table tableName="t_student" domainObjectName="Student"               enableCountByExample="false"               enableUpdateByExample="false"               enableDeleteByExample="false"               enableSelectByExample="false"               selectByExampleQueryId="false"/>    </context></generatorConfiguration>

13.1.3 在 pom.xml 文件中添加 mysql 反向工程依赖

<plugin>    <groupId>org.mybatis.generator</groupId>    <artifactId>mybatis-generator-maven-plugin</artifactId>    <version>1.3.6</version>    <configuration>        <!--配置文件的位置-->        <configurationFile>GeneratorMapper.xml</configurationFile>        <verbose>true</verbose>        <overwrite>true</overwrite>    </configuration></plugin><plugin>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-maven-plugin</artifactId></plugin>

13.1.4 双击红色选中命令，生成相关文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TWSOM99-1649333231323)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407164422263.png)]

13.2 SpringBoot 项目热部署

在实际开发中，我们修改某些代码逻辑功能或页面都需要重启应用，这无形中降低了开发效率，热部署是指当我们修改代码后，服务能自动重启加载新修改的内容，而不需要重启应用，这样大大提高了我们开发的效率。通常适用于修改页面之后不需要重启服务。 Spring Boot 热部署通过在 pom.xml 中添加一个 spring-boot-devtools 实现。

<!--SpringBoot 热部署依赖--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-devtools</artifactId>    <optional>true</optional></dependency>

该热部署依赖在实际使用中会有一些小问题，明明已经重启，但没有生效，这种情况下，手动重启一下程序；特别是分布式开发，比如 dubbo 开发框架，有点问题，需要手动重启修改完毕后，需要选中项目，在 Build 选项中选择 Build Module

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mOA2ceSk-1649333231323)(C:\Users\ming’s\AppData\Roaming\Typora\typora-user-images\image-20220407164822848.png)]

Not_Point

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springboot入门

SpringBoot第1章 Spring Boot 框架入门1.1 Spring Boot 简介Spring Boot 是 Spring 家族中的一个全新的框架，它用来简化 Spring 应用程序的创建和开发过程，也可以说 Spring Boot 能简化我们之前采用 SpringMVC + Spring + MyBatis 框架进行开发的过程。在以往我们采用 SpringMVC + Spring + MyBatis 框架进行开发的时候，搭建和整合三大框架，我们需要做很多工作，比如配置 web.
复制链接

扫一扫