SpringBoot框架-程序员宅基地

技术标签: spring boot  java  restful  mvc  springboot  

目录 

1.1 简介

1.2 特性

1.3 四大核心

2 springboot入门案例

2.1 SpringBoot 项目开发步骤

 2.2  创建一个 Spring MVC 的 Spring BootController 

2.3  分析

2.4 核心配置文件格式

2.5  Spring Boot 前端使用 JSP

3 SpringBoot框架Web开发

 3.1  Spring Boot 集成 MyBatis 

 3.2 DAO 的其它开发方式

 3.3 Spring Boot 事务支持

3.4  Spring Boot 下的 Spring MVC(注解)

 3.5 SpringBoot实现RESTFUL

3.6  Spring Boot 集成 Redis 

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 请求 
  • 请求路径不要出现动词:

        

  •  分页、排序等操作,不需要使用斜杠传参数

        

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 应用,访问测试

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/friggly/article/details/123888590

智能推荐

Sample Probability Space_probability space例题-程序员宅基地

文章浏览阅读66次。Sample Probability SpaceA simple probability space consist of a tuple (Ω\OmegaΩ,ε\varepsilonε,p)Ω\OmegaΩ is a finite set (with cardinality k= ∣\mid∣Ω\OmegaΩ∣\mid∣)ε\varepsilonε = { A : A ⊆\subseteq⊆ Ω\OmegaΩ } consist of all finite subsetsEach events _probability space例题

python分布式服务系统框架_Cola:一个分布式爬虫框架 - 系统架构 - Python4cn(news, jobs)...-程序员宅基地

文章浏览阅读348次。由于早先写的WeiboCrawler问题很多,而且当时我有提到,其实可以实现一个通用的爬虫框架。最近由于要抓取新的数据,于是我就写了这个cola。下面的文字来自wiki。Cola是一个分布式的爬虫框架,用户只需编写几个特定的函数,而无需关注分布式运行的细节。任务会自动分配到多台机器上,整个过程对用户是透明的。依赖由于Cola配置文件使用的yaml,所以Cola只依赖于pyyaml,安装easy_i..._cola爬虫

名悦集团国庆出行自驾游攻略-程序员宅基地

文章浏览阅读75次。在这个买车已经不是什么难事的年代,大多数人出行都会选择自驾方式,但自驾出游必然要面临一系列的问题以及做足准备工作。名悦集团小编给大家总结出了这次国庆假期出行自驾游攻略,为了保证自驾过程的安全顺利,玩得更加痛快,临行前的车辆检查时必不可少的,这些项目可以自己检查,如果实在是懒或者不懂,可以在临行前去4S店做个基础保养,以让爱车在最佳车况陪伴自己和家人朋友开始这段愉快的旅程。1.轮胎轮胎的检查是自驾前需要关键的检查之一,在自驾的旅程上不管是轮胎没气还是爆胎,都是非常令人揪心的,如果是在高速或者...

Android 输入法框架源码分析总结(1)_android 输入法源码-程序员宅基地

文章浏览阅读3.6k次,点赞3次,收藏7次。参考文档 https://blog.csdn.net/huangyabin001/article/details/28434989https://blog.csdn.net/huangyabin001/article/details/28435093#commentshttps://blog.csdn.net/jieqiong1/article/details/712629871..._android 输入法源码

Ubuntu下使用nnUNet 训练自己的数据集(只管实现,不讲原理,通俗易懂)_nnunet训练自己的数据集-程序员宅基地

本文介绍了如何在Ubuntu下使用nnUNet训练自己的数据集,不涉及原理解析,只提供实现步骤。包括nnUNet简介、修改训练参数和文件位置等操作。详细内容可参考Tina的博文。

SSM实现秒杀系统案例-程序员宅基地

文章浏览阅读9.9k次,点赞10次,收藏88次。对于抢购系统来说,首先要有可抢购的活动,而且这些活动具有促销性质,这种大型活动的负载可能是平时的几十倍,所以通过增加硬件、优化瓶颈代码等手段是很难达到目标的,所以抢购系统得专门设计。在这里我们说的库存不是真正意义上的库存,其实是该促销可以抢购的数量,真正的库存在基础库存服务。用户点击『提交订单』按钮后,在抢购系统中获取了资格后才去基础库存服务中扣减真正的库存;而抢购系统控制的就是资格/剩余数。传统方案利用数据库行锁,但是在促销高峰数据库压力过大导致服务不可用,目前采用redis集群(16分片)缓存促销信息,

随便推点

正则表达式匹配各种括号内内容_正则表达式 匹配多个括号-程序员宅基地

文章浏览阅读2.8w次,点赞10次,收藏9次。用正则表达式匹配两个字符中间的文本String skh ="(?<=\\《)[^\\》]+";//用于匹配《》里面的文本String str="但实际上《kajdwdej》孙大伟多";//测试字符串Pattern pattern=Pattern.compile(skh); Matcher matcher=pattern.matcher(str); boolean is=matche_正则表达式 匹配多个括号

Android 中的Shape_linear radial sweep分别代表的什么-程序员宅基地

文章浏览阅读553次。之前一直看项目用过这个东西,但是自己都不怎么熟悉,大概就知道可以画一些圆角之类的~ 今天就来好好了解一下吧~Shape里面有很多属性,依次学习一下第一步~首先来写一个Button这个布局文件就不贴了...太简单了~ (PS:说贴出来的站出来,我保证不打死你!)接下来开始学习第一个属性:Solid:(填充)在Drawable里面创建一个butt_linear radial sweep分别代表的什么

graphpad细胞增殖曲线_如何用GraphPad Prism绘制剂量反应曲线?-程序员宅基地

文章浏览阅读6.1k次。上图是Sci文献中的dose–response curves (剂量反应曲线),横坐标是药物GS-Se-SG浓度的对数值,纵坐标是Rrelative cell viability(相对细胞活性,% of control),从图注中可以知道IC50为5.1 μM。那么什么是IC50呢?IC50 (half maximal inhibitory concentration)是指被测量的拮抗剂的半抑制浓..._graphpad细胞增殖曲线

二叉查找树(非递归、递归遍历)_二叉排序树非递归查找-程序员宅基地

文章浏览阅读658次。二叉查找树(含递归、非递归遍历)_二叉排序树非递归查找

spark-sql 查询报错:Invalid method name: ‘get_table_req‘_invalid method name: 'get_table_req-程序员宅基地

文章浏览阅读3.1k次。spark-sql> select * from zps_d001 limit 1;Error in query: org.apache.hadoop.hive.ql.metadata.HiveException: Unable to fetch table zps_xxx. Invalid method name: 'get_table_req'org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.H_invalid method name: 'get_table_req

unknown mutation type:-程序员宅基地

文章浏览阅读1.7w次。我这边使用得是vue+elementvue得状态组成actions 这个是异步请求 通过异步请求得话 然后在调用 mutations.jsmutations.js 将数据提交到这里 this.$commit(‘test’,testTemp)index.js 这个是将数据初始化getters 这个是将 this.$store.getters.test 就能获取到了 testTemp写法是这个写法最后得原因是因为我这在 index.js 和mutation.js 为定义常量##_unknown mutation type

推荐文章

热门文章

相关标签