0


SpringBoot框架

1.1 简介

springboot是spring家族中的一个全新框架,用来简化spring程序的创建和开发过程。在以往我们通过SpringMVC+Spring+Mybatis框架进行开发的时候,我们需要配置web.xml,spring配置,mybatis配置,然后整合在一起,而springboot抛弃了繁琐的xml配置过程,采用大量默认的配置来简化我们的spring开发过程。

SpringBoot化繁为简,使开发变得更加的简单迅速。

1.2 特性

  • 能够快速创建基于spring的程序
  • 能够直接使用Java main方法启动内嵌的Tomcat服务器运行springboot程序,不需要部署war包
  • 提供约定的starter POM来简化Maven配置,让Maven的配置变得简单
  • 自动化配置,根据项目的Maven依赖配置,springboot自动配置spring、springmvc等
  • 提供了程序的健康检查功能
  • 基本可以完全不使用xml配合文件,采用注解配置

1.3 四大核心

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

2 springboot入门案例

2.1 SpringBoot 项目开发步骤

    (1)创建一个 Module,选择类型为Spring Initializr 快速构建

    (2)设置 GAV 坐标及 pom 配置信息 

    (3)选择 Spring Boot 版本及依赖 

    (4)设置模块名称、Content Root 路径及模块文件的目录,然后点击finish即可

    (5)项目结构如下:

    **static**:存放静态资源。如图片、CSS、JavaScript 等 
     **templates**:存放 Web 页面的模板文件 
    ** application.properties/application.yml** 用于存放程序的各种依赖模块的配置信息,比如 服务端口,数据库连接配置等
   **  .gitignore**:使用版本控制工具 git 的时候,设置一些忽略提交的内容 
     **Application.java**:SpringBoot 程序执行的入口,执行该程序中的 main 方法,启动当前SpringBoot项目。

    (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 
http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
 <modelVersion>4.0.0</modelVersion> 
 <!--继承 SpringBoot 框架的一个父项目,所有自己开发的 Spring Boot 都必须的继承--> 
 <parent> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-starter-parent</artifactId> 
     <version>2.2.1.RELEASE</version> 
     <relativePath/> <!-- lookup parent from repository --> 
 </parent> 
 
 <!--当前项目的 GAV 坐标--> 
 <groupId>com.bjpowernode.springboot</groupId> 
 <artifactId>002-springboot-springmvc</artifactId> 
 <version>1.0.0</version> 
 
 <!--maven 项目名称,可以删除--> 
 <name>002-springboot-springmvc</name> 
 <!--maven 项目描述,可以删除--> 
 <description>Demo project for Spring Boot</description> 
 
 <!--maven 属性配置,可以在其它地方通过${}方式进行引用--> 
 <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 框架的测试起步依赖,例如:junit 测试,如果不需要的话可以删除--> 
     <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 创建一个 Spring MVC 的 Spring BootController

  (1)创建SpringBootController 类

 **   注意:新创建的类一定要位于 Application 同级目录或者下级目录,否则 SpringBoot 加

载不到。 **

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 SpringBootController { 
 
 @RequestMapping(value = "/springBoot/say") 
 public @ResponseBody String say() { 
     return "Hello,springBoot!"; 
 } 
} 
    (2)启动Application类中的main方法

    通过在控制台的输出,可以看到启动 SpringBoot 框架,会启动一个内嵌的 tomcat,端

口号为 8080,上下文根为空 。

     (3)在浏览器中输入 http://localhost:8080/springBoot/say进行访问 

2.3 分析

     (1)spring-boot-starter-parent 是一个 Springboot 的父级依赖,开发 SpringBoot 程序都需

要继承该父级项目,它用来提供相关的 Maven 默认依赖,使用它之后,常用的 jar
包依赖可以省去 version 配置
(2)Spring Boot 提供了一些默认的jar 包的依赖,可查看该父级依赖的 pom 文件
(3)如果不想使用某个默认的依赖版本,可以通过 pom.xml 文件的属性配置覆盖各个
依赖项,比如覆盖 Spring 版本:

 <properties> 
     <spring-framework.version>5.0.0.RELEASE</ spring-framework.version > 
 </properties> 
    (4)** @SpringBootApplication** 注解是 Spring Boot 项目的核心注解,主要作用是**开启

Spring 自动配置,如果在 Application 类上去掉该注解,那么不会启动 SpringBoot程序
(5)main 方法是一个标准的 Java 程序的 main 方法,是boot项目启动运行的入口
(6)
@Controller 及 @ResponseBody **依然是我们之前的 Spring MVC,因为 Spring Boot
的里面依然是使用我们的 Spring MVC + Spring + MyBatis 等框架

2.4 核心配置文件格式

    (1).properties 文件(默认采用该文件) 

通过修改 application.properties 配置文件,修改默认 tomcat 端口号及项目上下文件根:

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

页面显示结果:

    (2) .yml 文件 :

    项目名称:004-springboot-yml

    yml 是一种 yaml 格式的配置文件,主要采用一定的空格、换行等格式排版进行配置。它能够直观的被计算机识别数据序列化格式,容易被人类阅读,yaml 类似于 xml,但是语法比 xml 简洁很多,值与前面的冒号配置项必须要有一个空格, yml 后缀也可以使用 yaml 后缀 。

   ** 注意:当两种格式配置文件同时存在时,使用的是.properties 配置文件。**

    (3)多环境配置(**.properties方式**)

    在实际开发的过程中,我们的项目会经历很多的阶段(开发->测试->上线),每个阶段

的配置也会不同,例如:端口、上下文根、数据库等,那么这个时候为了方便在不同的环境
之间切换,SpringBoot 提供了多环境配置
,具体步骤如下 :

    项目名称: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 
    (4)多环境配置(**.yml方式**)

** application-dev.yml**

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

application-product.yml

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

application-test.yml

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

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

#springboot 总配置文件 
 
#激活开发环境 
#spring: 
# profiles: 
#  active: dev 
 
 
#激活测试环境 
#spring: 
# profiles: 
#  active: test 
 
#激活生产环境 
spring: 
 profiles: 
  active: product 
    (5)Spring Boot 自定义配置

    在 SpringBoot 的核心配置文件中,除了使用内置的配置项之外,我们还可以在自定义配

置,然后采用如下注解去读取配置的属性值:

    **(A)@Value注解 用于逐个读取application.properties中的配置**

** 案例演示:**

** (1) **在核心配置文件 applicatin.properties 中,添加两个自定义配置项 school.name 和
website。在 IDEA 中可以看到这两个属性不能被 SpringBoot 识别,背景是桔色的 :

.properties方式

** .yml方式**

#设置端口号及上下文根 
server: 
 port: 9090 
 servlet: 
  context-path: / 
 
school: 
 name: ssm 
websit: http://www.baidu.com 
    (2)在 SpringBootController 中定义属性,并使用@Value 注解或者自定义配置值,并对其方法进行测试
@Controller 
public class SpringBootController { 
 
 @Value("${school.name}") 
 private String schoolName; 
 
 @Value("${websit}") 
 private String websit; 
 
 @RequestMapping(value = "/springBoot/config") 
 public @ResponseBody String say() { 
 return schoolName + "------" + websit; 
 } 
} 
    (3)重新运行 Application,在浏览器中进行测试 

     **(B)@ConfigurationProperties**

  **  作用:**将整个文件映射成一个对象,用于自定义配置项比较多的情况 。

    **案例演示:**

** (1)**在 com.abc.springboot.config 包下创建 ConfigInfo 类,并为该类加上 Component 和
ConfigurationProperties 注解,并在 ConfigurationProperties 注解中添加属性 prefix,可以区分同名配置 。

@Data
@Component 
@ConfigurationProperties(prefix = "school") 
public class ConfigInfo { 
 
 private String name; 
 
 private String websit; 
} 

** (2)application.properties 配置文件**

#设置内嵌 Tomcat 端口号 
server.port=9090 
 
#设置上下文根 
server.servlet.context-path=/config 
 
school.name=ssm 
school.websit=http://www.baidu.com 
    (3)在 SpringBootController 中注入 ConfigInfo 配置类 
@Autowired 
private ConfigInfo configInfo; 
    (4)修改 SpringBootController 类中的测试方法
@RequestMapping(value = "/springBoot/config") 
public @ResponseBody String say() { 
 return configInfo.getName() + "=======" + configInfo.getWebsit(); 
} 
    (5)重新运行 Application,在浏览器中进行测试 

     **(C)警告解决**

    在 ConfigInfo 类中使用了 ConfigurationProperties 注解后,IDEA 会出现一个警告,不影响程序的执行。

    点击 open documentnation 跳转到网页,在网页中提示需要加一个依赖,我们将这

个依赖拷贝,粘贴到 pom.xml 文件中 即可。

<!--解决使用@ConfigurationProperties 注解出现警告问题--> 
<dependency> 
  <groupId>org.springframework.boot</groupId> 
  <artifactId>spring-boot-configuration-processor</artifactId> 
  <optional>true</optional> 
</dependency> 
    **(D)中文乱码**

如果在 SpringBoot 核心配置文件中有中文信息,会出现乱码: 
  • 一般在配置文件中,不建议出现中文(注释除外)
  • 如果出现中文,可以先转化为 ASCII 码

2.5 Spring Boot 前端使用 JSP

     (1)在 pom.xml 文件中配置以下依赖项
<!--引入 Spring Boot 内嵌的 Tomcat 对 JSP 的解析包,不加解析不了 jsp 页面--> 
<!--如果只是使用 JSP 页面,可以只添加该依赖--> 
<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> 
    (2)在 pom.xml 的 build 标签中要配置以下信息 
     SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问,否则

访问不到。其实官方已经更建议使用模板技术。

<!-- 
 SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问,否则访问
不到。 
 其它官方已经建议使用模版技术
--> 
<resources> 
 <resource> 
     <!--源文件位置--> 
     <directory>src/main/webapp</directory> 
     <!--指定编译到 META-INF/resources,该目录不能随便写--> 
     <targetPath>META-INF/resources</targetPath> 
     <!--指定要把哪些文件编译进去,**表示 webapp 目录及子目录,*.*表示所有文件--> 
     <includes> 
         <include>**/*.*</include> 
     </includes> 
 </resource> 
</resources> 
    (3)在 application.properties 文件配置 Spring MVC 的视图展示为jsp,这里相当于 Spring MVC 的配置。
#SpringBoot 核心配置文件 
#指定内嵌 Tomcat 端口号 
server.port=8090 
 
#配置 SpringMVC 视图解析器 
#其中:/ 表示目录为 src/main/webapp 
spring.mvc.view.prefix=/ 
spring.mvc.view.suffix=.jsp 
    (4)在 com.abc.springboot.controller 包下创建 JspController 类
@Controller 
public class SpringBootController { 
 
 @RequestMapping(value = "/springBoot/jsp") 
 public String jsp(Model model) { 
 
     model.addAttribute("data","SpringBoot 前端使用 JSP 页面!"); 
 
 return "index"; 
 } 
} 
    (5)在 src/main 下创建一个 webapp 目录,然后在该目录下新建index.jsp 页面 

    注意: 如果在webapp目录下右键,没有创建jsp的选项,可以在Project Structure中指定webapp为 Web Resource Directory 。

     (6)在 index.jsp 中获取 Controller 传递过来的数据 

     (7)重新运行 Application,通过浏览器访问测试 

3 SpringBoot框架Web开发

通过实际代码案例进行梳理:

3.1 Spring Boot 集成 MyBatis

通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作的实现步骤:

(1)创建新的数据库springboot并向表中插入数据

(2)创建一个新的 SpringBoot 的 Module

    创建项目的过程省略

(3)在 pom.xml 中添加相关 jar 依赖

<!--MyBatis 整合 SpringBoot 的起步依赖--> 
<dependency> 
 <groupId>org.mybatis.spring.boot</groupId> 
 <artifactId>mybatis-spring-boot-starter</artifactId> 
 <version>2.0.0</version> 
</dependency> 

<!--MySQL 的驱动依赖--> 
<dependency> 
 <groupId>mysql</groupId> 
 <artifactId>mysql-connector-java</artifactId> 
</dependency> 

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

#配置内嵌 Tomcat 端口号 
server.port=9090 
 
#配置项目上下文根 
server.servlet.context-path=/010-springboot-web-mybatis 
 
#配置数据库的连接信息 
#注意这里的驱动类有变化 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 
 
spring.datasource.username=root 
spring.datasource.password=root

(5)开发代码(代码生成器)

使用 Mybatis 反向工程生成接口、映射文件以及实体 bean,具体步骤参见附录 1

     (A)在 web 包下创建 StudentController 并编写代码
@Controller 
public class StudentController { 
 
 @Autowired 
 private StudentService studentService; 
 
 @RequestMapping(value = "/springBoot/student") 
 public @ResponseBody Object student() { 
 
 Student student = studentService.queryStudentById(1); 
 
 return student; 
 } 
} 
    (B)在 service 包下创建 service 接口并编写代码 
public interface StudentService { 
 
 /** 
 * 根据学生标识获取学生详情 
 * @param id 
 * @return 
 */ 
 Student queryStudentById(Integer id); 
}
    (C)在 service.impl 包下创建 service 接口并编写代码
@Service 
public class StudentServiceImpl implements StudentService { 
 

 @Autowired 
 private StudentMapper studentMapper; 
 
 @Override 
 public Student queryStudentById(Integer id) { 
 return studentMapper.selectByPrimaryKey(id); 
 } 
} 
    (D)如果在 web 中导入 service 存在报错,可以尝试进行如下配置解决 

    (E) 在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解 

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

@Mapper 
public interface StudentMapper { 
}
    (F)默认情况下,Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下,所

以我们需要在 pom.xml 文件中配置 resource 。

<resources> 
 <resource> 
 <directory>src/main/java</directory> 
 <includes> 
     <include>**/*.xml</include> 
 </includes> 
 </resource> 
</resources>
    (G)启动 Application 应用,浏览器访问测试运行

3.2 DAO 的其它开发方式

方式一:

(A)注释掉 StudentMapper 接口上的@Mapper 注解

(B)在运行的主类上添加注解包扫描MapperScan("com.abc.springboot.mapper")

@SpringBootApplication 
@MapperScan("com.abc.springboot.mapper") 
public class Application { 

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

方式二:

    因为 SpringBoot 不能自动编译接口映射的 xml 文件,还需要手动在 pom 文件中指定,

所以有的公司直接将映射文件直接放到 resources 目录下 ,在 resources 目录下新建目录 mapper 存放映射文件,将 StudentMapper.xml 文件移到resources/mapper 目录下:

    在 **application.properties 配置文件中指定映射文件的位置**,这个配置只有接口和映

射文件不在同一个包的情况下,才需要指定:

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

3.3 Spring Boot 事务支持

springboot事务底层依然采用的是 Spring 本身提供的事务管理。

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

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

     在上述案例的基础上,通过 SpringBoot +MyBatis 实现对数据库学生表的更新操作,在 service 层的方法中构建异常,查看事务是否生效:
    
      (1)在 StudentController 中添加更新学生的方法
    
@RequestMapping(value = "/springboot/modify") 
public @ResponseBody Object modifyStudent() { 
 
 int count = 0; 
 try { 
 Student student = new Student(); 
 student.setId(1); 
 student.setName("Jack"); 
 student.setAge(33); 
 count = studentService.modifyStudentById(student); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 return "fail"; 
 } 
 
 return count; 
} 
    (2)在 StudentService 接口中添加更新学生方法
int modifyStudentById(Student student); 
    (3)在 StudentServiceImpl 接口实现类中对更新学生方法进行实现,并构建一个异常,同时在该方法上加@Transactional 注解。
@Override 
@Transactional //添加此注解说明该方法添加的事务管理 
public int update(Student student) { 
 
 int updateCount = studentMapper.updateByPrimaryKeySelective(student); 
 
 System.out.println("更新结果:" + updateCount); 
 
 //在此构造一个除数为 0 的异常,测试事务是否起作用 
 int a = 10/0; 
 
 return updateCount; 
} 
    (4)在Application类上加@EnableTransactionManagement开启事务支持。

@EnableTransactionManagement 可选,但是业务方法上必须添加@Transactional 事务才生效

@SpringBootApplication 
@MapperScan(basePackages = "com.abc.springboot.mapper") 
@EnableTransactionManagement //开启事务支持(可选项,但@Transactional 必须添加) 
public class Application { 

3.4 Spring Boot 下的 Spring MVC(注解)

springboot下的springMVC主要有以下注解:

    (1)@Controller:Spring MVC 的注解,处理 http 请求

    (2)@RestController :@Controller 与@ResponseBody 的组合注解 

    如果一个 Controller 类添加了@RestController,那么该 Controller 类下的所有方法都相当

于添加了@ResponseBody 注解 ,用于返回字符串或json数据。

创建 MyRestController 类,演示@RestController 替代@Controller + @ResponseBody

@RestController 
public class MyRestController { 
 @Autowired 
 private StudentService studentService; 
 
 @RequestMapping("/boot/stu") 
 public Object stu(){ 
 return studentService.getStudentById(1); 
 } 
} 
    (3)@RequestMapping:支持 Get 请求,也支持 Post 请求 。
     (4)@GetMapping :只支持 Get 请求,主要用于查询操作。

    (5)@PostMapping:只支持Post请求,主要用于新增数据。

    (6)@PutMapping:只支持put请求,主要用于修改数据

    (7)@DeleteMapping:只支持delete请求,通常用与删除数据

    **(8)综合案例:**

**(A)创建一个 MVCController,里面使用上面介绍的各种注解接收不同的请求 **

//RestController 注解相当于加了给方法加了@ResponseBody 注解,所以是不能跳转页面的,只能返回字符串或者 json 数据 
@RestController 
public class MVCController { 
 
 @GetMapping(value = "/query") 
 public String get() { 
 return "@GetMapping 注解,通常查询时使用"; 
 } 
 
 
 @PostMapping(value = "/add") 
 public String add() { 
 return "@PostMapping 注解,通常新增时使用"; 
 } 
 
 @PutMapping(value = "/modify") 
 public String modify() { 
 return "@PutMapping 注解,通常更新数据时使用"; 
 } 
 
 @DeleteMapping(value = "/remove") 
 public String remove() { 
 return "@DeleteMapping 注解,通常删除数据时使用"; 
 } 
} 

(B)启动应用,在浏览器中输入不同的请求进行测试

(C)结合POSTMan工具测试其他请求类型

3.5 SpringBoot实现RESTFUL

    **(1)简介**

    它是一种互联网软件设计的风格,它只是提出了一组客户端和服务器交互时的架构理念和设计原则,基于这种理念和原则设计的接口可以更简洁,更有层次。

比如我们要访问一个 http 接口:http://localhost:8080/boot/order?id=1021&status=1
采用 RESTFul 风格则 http 地址为:http://localhost:8080/boot/order/1021/1

    **(2)开发RESTFUL**,主要用到以下注解:
  • @PathVariable :获取 url 中的数据,该注解是实现 RESTFul 最主要的一个注解
  • ** **@PostMapping :接收和处理post方式的请求
  • @DeleteMapping:接收delete方式的请求,可以用GetMapping代替
  • @PutMapping :接收put方式的请求,可以用 PostMapping 代替
  • @GetMapping :接收get方式请求 (3)案例:使用 RESTful 风格模拟实现对学生的增删改查操作

该项目集成了 MyBatis、spring、SpringMVC,通过模拟实现对学生的增删改查操作

pom.xml文件

<dependencies> 
 <!--SpringBoot 框架 web 项目起步依赖--> 
 <dependency> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-starter-web</artifactId> 
 </dependency> 
 
 <!--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> 
 </dependency> 
</dependencies> 
 
<build> 
 <!--指定配置资源的位置--> 
 <resources> 
     <resource> 
         <directory>src/main/java</directory> 
         <includes> 
             <include>**/*.xml</include> 
         </includes> 
     </resource> 
 </resources> 
 
 <plugins> 
     <!--mybatis 代码自动生成插件--> 
     <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> 
 </plugins> 
</build> 

application. properties核心配置文件

#配置内嵌 Tomcat 端口号 
server.port=8090 
 
#配置项目上下文根 
server.servlet.context-path=/
 
#配置数据库的连接信息 
#注意这里的驱动类有变化 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 
 
spring.datasource.username=root 
spring.datasource.password=root

通过逆向工程生成 DAO

创建 RESTfulController

@RestController 
public class RESTfulController { 
 
 /** 
 * 添加学生 
 * 请求地址:
http://localhost:9090/014-springboot-restful/springBoot/student/wangpeng/23 
 * 请求方式:POST 
 * @param name 
 * @param age 
 * @return 
 */ 
 @PostMapping(value = "/springBoot/student/{name}/{age}") 
 public Object addStudent(@PathVariable("name") String name, @PathVariable("age") Integer age) { 
 
 Map<String,Object> retMap = new HashMap<String, Object>(); 
 retMap.put("name",name); 
 retMap.put("age",age); 
 
 
 return retMap; 
 } 
 
 /** 
 * 删除学生 
 * 请求地址:
http://localhost:9090/014-springboot-restful/springBoot/student/1 
 * 请求方式:Delete 
 * @param id 
 * @return 
 */ 
 @DeleteMapping(value = "/springBoot/student/{id}") 
 public Object removeStudent(@PathVariable("id") Integer id) { 
 
 return "删除的学生 id 为:" + id; 
 } 
 
 /** 
 * 修改学生信息 
 * 请求地址:
http://localhost:9090/014-springboot-restful/springBoot/student/2 
 * 请求方式:Put 
 * @param id 
 * @return 
 */ 
 @PutMapping(value = "/springBoot/student/{id}") 
 public Object modifyStudent(@PathVariable("id") Integer id) { 
 
 return "修改学生的 id 为" + id; 
 } 
 
 @GetMapping(value = "/springBoot/student/{id}") 
 public Object queryStudent(@PathVariable("id") Integer id) { 
 
 return "查询学生的 id 为" + id; 
 } 
} 

使用 Postman 模拟发送请求,进行测试 :

     (4)请求冲突的问题

** 解决方案:<1>修改路径 <2>修改请求方式**

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

@RestController 
public 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<String,Object> map = new HashMap<String,Object>(); 
 
 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<String,Object> map = new HashMap<String,Object>(); 
 
 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 
 */ 
 @GetMapping(value = "/springBoot/{status}/order/{id}") 
 public Object queryOrder2(@PathVariable("id") Integer id, 
 @PathVariable("status") Integer status) { 
 Map<String,Object> map = new HashMap<String,Object>(); 
 
 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<String,Object> map = new HashMap<String,Object>(); 
 
 map.put("id",id); 
 map.put("status",status); 
 
 return map; 
 } 
 
 
 
 
 /** 
 * query1 和 query2 两个请求路径会发生请求路径冲突问题 
 * query3 与 query1 和 query2 发生请求冲突 
 * 注意:虽然两个路径写法改变了,但是由于传递的两个参数都是 int 值,所以不知道该交给
哪个请求进行处理 
 * 就会出现匹配模糊不清的异常,所以要想解决冲突,有两种方式: 
 * 1.修改请求路径 
 * 2.修改请求方式 
 */ 
} 
    (5)RESTful 原则
  • 增 post 请求、删 delete 请求、改 put 请求、查 get 请求

  • 请求路径不要出现动词:

      ![](https://img-blog.csdnimg.cn/e683c802905848afaf3d35709fe68e54.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_16,color_FFFFFF,t_70,g_se,x_16)
    
  • 分页、排序等操作,不需要使用斜杠传参数

     ![](https://img-blog.csdnimg.cn/705f107f530f48f5a623d7cbe7df79bb.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_19,color_FFFFFF,t_70,g_se,x_16)
    

3.6 Spring Boot 集成 Redis

    完善根据学生 id 查询学生的功能:**先从 redis 缓存中查找,如果找不到,再从数据库中

查找,然后放到 redis 缓存中。**

具体实现步骤:

(A)首先通过 MyBatis 逆向工程生成实体 bean 和数据持久层 :

(B)在 pom.xml 文件中添加 redis 依赖

<!-- 加载 spring boot redis 包 --> 
<dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-data-redis</artifactId> 
</dependency> 

(C)Spring Boot 核心配置文件application.properties 如下:

#配置内嵌 Tomcat 端口号 
server.port=9090 
 
#配置项目上下文根 
server.servlet.context-path=/016-springboot-redis 
 
#配置连接 MySQL 数据库信息 
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=UTF8&useJDBCCompliantTimezoneShift=true&useLegacyDa
tetimeCode=false&serverTimezone=GMT%2B8 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.username=root 
spring.datasource.password=root
 
#配置 redis 连接信息 
spring.redis.host=127.0.0.1 
spring.redis.port=6379 
#spring.redis.password=root

(D)启动redis服务

(E)RedisController类

@RestController 
public class RedisController { 
 
 @Autowired 
 private StudentService studentService; 
 
 /** 
 * 请求地址:
http://localhost:9090/016-springboot-redis//springboot/allStudentCount 
 * @param request 
 * @return 
 */ 
 @GetMapping(value = "/springboot/allStudentCount") 
 public Object allStudentCount(HttpServletRequest request) { 
 
 Long allStudentCount = studentService.queryAllStudentCount(); 
 
 return "学生总人数:" + allStudentCount; 
 } 
} 

(F)StudentService 接口

public interface StudentService { 
 
 /** 
 * 获取学生总人数 
 * @return 
 */ 
 Long queryAllStudentCount(); 
} 

(G)在 StudentServiceImpl 中注入 RedisTemplate,并编写根据 id获取学生的方法

    配置了上面的步骤,Spring Boot 将自动配置 RedisTemplate,在需要操作 redis 的类中注入 redisTemplate 即可。 
    注意:Spring Boot 帮我们注入 RedisTemplate 类,泛型里面只能写 <String, String>、<Object, Object>或者什么都不写。
@Service 
public class StudentServiceImpl implements StudentService { 
 
 @Autowired 
 private StudentMapper studentMapper; 
 
 @Autowired 
 private RedisTemplate<Object,Object> redisTemplate; 
 
 @Override 
 public Long queryAllStudentCount() { 
 
 //设置 redisTemplate 对象 key 的序列化方式 
 redisTemplate.setKeySerializer(new StringRedisSerializer()); 
 
 //从 redis 缓存中获取总人数 
 Long allStudentCount = (Long) redisTemplate.opsForValue().get("allStudentCount"); 
 //判断是否为空 
 if ( allStudentCount==null) { 
 //去数据库查询,并存放到 redis 缓存中 
 
 allStudentCount = studentMapper.selectAllStudentCount(); 
 
redisTemplate.opsForValue().set("allStudentCount",allStudentCount,15,TimeUnit.SECONDS); 
 } 
 return allStudentCount; 
 } 
} 

(H)StudentMapper 接口

@Mapper
public interface StudentMapper {
 /** 
 * 获取学生总人数 
 * @return 
 */ 
 Long selectAllStudentCount(); 
}

**(I)StudentMapper 映射文件 **

<!--获取学生总人数--> 
<select id="selectAllStudentCount" resultType="java.lang.Long"> 
 select count(*) from  t_student 
</select> 

(J)启动类 Application

在 SpringBoot 启动类上添加扫描数据持久层的注解并指定扫描包:

@SpringBootApplication 
@MapperScan(basePackages = "com.abc.springboot.mapper")//扫描数据持久层 
public class Application { 
 
 public static void main(String[] args) { 
 SpringApplication.run(Application.class, args); 
 } 
 
} 

(K)让 Student 类实现序列化接口(可选)

在类名上 Alt + 回车,如果没有提示生成序列化 id,那么需要做如下的配置 :

(L)启动 SpringBoot 应用,访问测试

标签: springboot mvc java

本文转载自: https://blog.csdn.net/friggly/article/details/123888590
版权归原作者 星悦糖 所有, 如有侵权,请联系我们删除。

“SpringBoot框架”的评论:

还没有评论