Springboot的简单学习

最新推荐文章于 2024-05-13 22:56:21 发布

L-JankinLee

最新推荐文章于 2024-05-13 22:56:21 发布

阅读量511

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/m0_62671297/article/details/132982543

版权

引用文章SpringBoot框架_星悦糖的博客-CSDN博客

1、创建一个 Spring MVC 的 Spring BootController

（1）创建SpringBootController 类

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

（2）启动Application类中的main方法

通过在控制台的输出，可以看到启动 SpringBoot 框架，会启动一个内嵌的 tomcat，端
口号为 8080，上下文根为空。

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

2、在 SpringBootController 中定义属性，并使用@Value 注解或者自定义配置值，并对其方法进行测试

案例演示：

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

.properties方式

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

（2）在 SpringBootController 中定义属性，并使用@Value 注解或者自定义配置值，并对其方法进行测试

（3）重新运行 Application，在浏览器中进行测试

3、@ConfigurationProperties使用

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

案例演示：

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

（2）application.properties 配置文件

（3）在 SpringBootController 中注入 ConfigInfo 配置类

（4）修改 SpringBootController 类中的测试方法

（5）重新运行 Application，在浏览器中进行测试

4、Spring Boot 前端使用 JSP

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

（2）在 pom.xml 的 build 标签中要配置以下信息
SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则
访问不到。其实官方已经更建议使用模板技术。

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

（4）在 com.abc.springboot.controller 包下创建 JspController 类

（5）在 src/main 下创建一个 webapp 目录，然后在该目录下新建index.jsp 页面

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

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

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

5、Spring Boot 集成 MyBatis

我发现主要是通过controller层调用service层，再service层调用mapper层实现的

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

（1）创建新的数据库springboot并向表中插入数据

（2）创建一个新的 SpringBoot 的 Module

创建项目的过程省略

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

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

（5）开发代码（代码生成器）

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

（A）在 web 包下创建 StudentController 并编写代码

（B）在 service 包下创建 service 接口并编写代码

（C）在 service.impl 包下创建 service 接口并编写代码

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

（E）在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解
@Mapper 作用：mybatis 自动扫描数据持久层的映射文件及 DAO 接口的关系

（F）默认情况下，Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下，所
以我们需要在 pom.xml 文件中配置 resource

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

6、DAO的其他开发方式

方式一：

（A）注释掉 StudentMapper 接口上的@Mapper 注解

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

或者

方式二：

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

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

7、Spring Boot 事务支持

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

在入口类中使用注解@EnableTransactionManagement开启事务支持
在访问数据库的service方法上添加注解@Transactional即可
在上述案例的基础上，通过 SpringBoot +MyBatis 实现对数据库学生表的更新操作，在 service 层的方法中构建异常，查看事务是否生效：

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

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

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

（4）在Application类上加@EnableTransactionManagement开启事务支持。

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

8、Spring Boot 下的 Spring MVC（注解）

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

（1）@Controller：Spring MVC 的注解，处理 http 请求

（2）@RestController ：@Controller 与@ResponseBody 的组合注解

如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当
于添加了@ResponseBody 注解 ，用于返回字符串或json数据。

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

（3）@RequestMapping：支持 Get 请求，也支持 Post 请求。

（4）@GetMapping ：只支持 Get 请求，主要用于查询操作。

（5）@PostMapping：只支持Post请求，主要用于新增数据。

（6）@PutMapping：只支持put请求，主要用于修改数据

（7）@DeleteMapping：只支持delete请求，通常用与删除数据

（8）综合案例：

（A）创建一个 MVCController，里面使用上面介绍的各种注解接收不同的请求

（B）启动应用，在浏览器中输入不同的请求进行测试

（C）结合POSTMan工具测试其他请求类型

9、SpringBoot实现RESTFUL

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

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

10、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 应用，访问测试