目录
1.SpringBoot介绍
1.1 什么是SpringBoot
Spring Boot是由Pivotal团队提供的全新框架，其中“Boot”的意思就是“引导”，Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速开发 Spring应用的方式。
1.2 SpringBoot 特点
- 嵌入的 Tomcat，无需部署 WAR 文件
Spring Boot 使用嵌入式的 Servlet 容器（例如 Tomcat、Jetty 或者 Undertow 等），应用无需打成 WAR 包 。
- 简化Maven配置
Spring Boot 提供了一系列的“starter”来简化 Maven 配置。
- 自动配置
Spring Boot 提供了大量的自动配置类，开发人员不需要任何 xml 配置即可实现 Spring 的所有配置
1.3 Javaweb、spring、springmvc和springboot有什么区别？
-
JavaWeb是 Java 语言的 Web 开发技术，主要用于开发 Web 应用程序，包括基于浏览器的客户端和基于服务器的 Web 服务器。
-
Spring是一个轻量级的开源开发框架，主要用于管理 Java 应用程序中的组件和对象，并提供各种服务，如事务管理、安全控制、面向切面编程和远程访问等。它是一个综合性框架，可应用于所有类型的 Java 应用程序。
-
SpringMVC是 Spring 框架中的一个模块，用于开发 Web 应用程序并实现 MVC（模型-视图-控制器）设计模式，它将请求和响应分离，从而使得应用程序更加模块化、可扩展和易于维护。
-
Spring Boot是基于 Spring 框架开发的用于开发 Web 应用程序的框架，它帮助开发人员快速搭建和配置一个独立的、可执行的、基于 Spring 的应用程序，从而减少了繁琐和重复的配置工作。
综上所述，JavaWeb是基于 Java 语言的 Web 开发技术，而 Spring 是一个综合性的开发框架，SpringMVC用于开发 Web 应用程序实现 MVC 设计模式，而 Spring Boot 是基于 Spring 的 Web 应用程序开发框架。
1.4 SpringBoot的Starter
- 使用Spring框架的问题？
-
依赖导入问题：每个项目都需要来单独维护自己所依赖的jar包，在项目中使用到什么功能就需要引入什么样的依赖。手动导入依赖容易出错，且无法统一集中管理
-
配置繁琐：在引入依赖之后需要做繁杂的配置，并且这些配置是每个项目来说都是必要的，例如web.xml配置数据库连接池配置、事务配置等等。这些配置重复且繁杂，在不同的项目中需要进行多次重复开发，这在很大程度上降低了我们的开发效率
而在SpringBoot出现之后，它为我们提供了一个强大的功能来解决上述的两个痛点，这就是SpringBoot的starter（启动器）。
- Starter是什么？
Spring Boot通过将我们常用的功能场景抽取出来，做成的一系列的启动器，我们只需要在项目中引入这些starter，相关的所有依赖就会全部被导入进来，并且我们可以抛弃繁杂的配置，例如：
-
spring-boot-starter-web：支持全栈式的 web 开发，包括了 tomcat 和 springMVC 等 jar包
-
spring-boot-starter-jpa：支持 spring 以 jpa方式操作数据库的 jar 包的集合
-
spring-boot-starter-redis：支持 redis 键值存储的数据库操作
在导入的starter之后，SpringBoot主要帮我们完成了两件事情：
-
相关依赖的自动导入
-
相关环境的自动配置
-
Starters命名
-
官方启动器命名：
- 前缀：spring-boot-starter-
- 规范：spring-boot-starter-模块名
- 举例：spring-boot-starter-web、spring-boot-starter-jdbc
-
第三方启动器命名：
- 后缀：-spring-boot-starter
- 规范：模块名-spring-boot-starter
- 举例：mybatis-spring-boot-starter
2.SpringBoot入门HelloWorld
- 构建 Spring Boot 项目
创建maven空项目
- 添加依赖
打开pom.xml，修改SpringBoot项目的依赖：
<!--继承springboot父工程-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.4</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- 项目源码及编译输出的编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<dependencies>
<!-- springboot的web启动器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
- 创建启动类
package com.by;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
- 编写controller
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
import java.util.Map;
@Controller
public class HelloWorld {
@RequestMapping("/hello")
@ResponseBody
public Map<String, Object> showHelloWorld() {
Map<String, Object> map = new HashMap<>();
map.put("msg", "HelloWorld");
return map;
}
}
启动类存放的位置：
- controller 同一个包下
- controller 的上一级包中
- 自定义banner(选做)
1、banner生成网站：http://www.bootschool.net/ascii
2、将生成的banner.txt复制到resources目录中，例如：
// _ooOoo_ //
// o8888888o //
// 88" . "88 //
// (| ^_^ |) //
// O\ = /O //
// ____/`---'\____ //
// .' \\| |// `. //
// / \\||| : |||// \ //
// / _||||| -:- |||||- \ //
// | | \\\ - /// | | //
// | \_| ''\---/'' | | //
// \ .-\__ `-` ___/-. / //
// ___`. .' /--.--\ `. . ___ //
// ."" '< `.___\_<|>_/___.' >'"". //
// | | : `- \`.;`\ _ /`;.`/ - ` : | | //
// \ \ `-. \_ __\ /__ _/ .-` / / //
// ========`-.____`-.___\_____/___.-`____.-'======== //
// `=---=' //
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
// 佛祖保佑 永不宕机 永无BUG //
3、测试
3.SpringBoot的全局配置文件
SpringBoot项目使用一个全局的配置文件application.properties或者是application.yml，在resources目录下或者类路径下的/config下，一般我们放到resources下
3.1 properties配置文件
- 修改tomcat的端口为8088
server.port=8888
- 修改访问项目时的名字
server.servlet.context-path=/springboot
3.2 yml配置文件
yml是 Spring Boot 中新增的一种配置文件格式。特点：具备天然的树状结构
- yml方式配置springboot
server:
port: 8090
servlet:
context-path: /springboot
3.3 yml与 properties的区别
-
配置文件的扩展名有变化
-
配置文件中的语法有变化：
1. 在 yml 中使用“ :”进行分割
2. 在 yml中缩进时不允许使用tab键，缩进的空格数不重要，只要是左对齐的一列数据，都是同一个层级
3. 每个Key的冒号后面一定要加一个空格
4.SpringBoot异常处理
4.1自定义错误页面
SpringBoot默认的处理异常的机制：SpringBoot 默认的已经提供了一套处理异常的机制。一旦程序中出现了异常 SpringBoot 会向/error 的 url 发送请求。
在 springBoot 中提供了一个叫 BasicErrorController 来处理/error 请求，然后跳转到默认显示异常的页面来展示异常信息
如 果我 们 需 要 将 所 有 的 异 常 同 一 跳 转 到 自 定 义 的 错 误 页 面 ， 需 要 再src/main/resources/templates 目录下创建 error.html 页面。
注意：名称必须叫 error
- controller
/**
* SpringBoot处理异常方式一：自定义错误页面
*/
@Controller
public class DemoController {
@RequestMapping("/show")
public String showInfo(){
String str = null;
str.length();
return "index";
}
@RequestMapping("/show2")
public String showInfo2(){
int a = 10/0;
return "index";
}
}
- 错误页面
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面</title>
</head>
<body>
出错了，请与管理员联系。。。
<span th:text="${error}"></span>
</body>
</html>
4.2 整合web访问全局异常处理器
- 处理思路
- 创建全局异常处理器
/**
* 通过实现HandlerExceptionResolver接口做全局异常处理
*/
@Component
public class GlobalException implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) {
ModelAndView mv = new ModelAndView();
//判断不同异常类型，做不同视图跳转
if(ex instanceof ArithmeticException){
mv.setViewName("error1");
}else if(ex instanceof NullPointerException){
mv.setViewName("error2");
}
mv.addObject("error", ex.toString());
return mv;
}
}
- 错误页面
error1.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面-ArithmeticException</title>
</head>
<body>
出错了，请与管理员联系。。。
<span th:text="${error}"></span>
</body>
</html>
error2.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>错误提示页面-NullPointerException</title>
</head>
<body>
出错了，请与管理员联系。。。
<span th:text="${error}"></span>
</body>
</html>
4.3 ajax全局异常处理
@ControllerAdvice
public class AjaxGlobalExceptionHandler {
/**
* 处理全局异常
* @param exception 异常
* @return Map<String, Object>
*/
@ResponseBody
@ExceptionHandler(value = Exception.class)
public Map<String, Object> errorHandler(Exception exception) {
Map<String, Object> map = new HashMapMap<>();
map.put("status", 500);
map.put("msg", exception.getMessage());
return map;
}
}
4.4 整合ajax全局异常处理
@ControllerAdvice
public class AjaxGlobalExceptionHandler {
/**
* 处理全局异常
* @param exception 异常
* @return Map<String, Object>
*/
@ResponseBody
@ExceptionHandler(value = Exception.class)
public Map<String, Object> errorHandler(Exception exception) {
Map<String, Object> map = new HashMapMap<>();
map.put("status", 500);
map.put("msg", exception.getMessage());
return map;
}
}
5.SpringBoot整合Junit
- Junit启动器
<!--junit启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
- 编写业务代码
- dao层
@Repository public class UserDaoImpl { public void saveUser(){ System.out.println("insert into users....."); } }
-
service层
@Service public class UserServiceImpl { @Autowired private UserDaoImpl userDaoImpl; public void addUser(){ this.userDaoImpl.saveUser(); } }- 启动类
@SpringBootApplication public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }
- 整合Junit
/**
* junit与spring整合(旧版)：
* @RunWith(SpringJUnit4ClassRunner.class)：让junit与spring环境进行整合
* @Contextconfiguartion("classpath:applicationContext.xml")
*
* junit与spring整合(新版)(可简写)：
* @RunWith(SpringJUnit4ClassRunner.class)
* @SpringBootTest(classes={App.class})
*/
@SpringBootTest //Spring Boot会自动配置环境
public class UserServiceTest {
@Autowired
private UserServiceImpl userServiceImpl;
@Test
public void testAddUser(){
this.userServiceImpl.addUser();
}
}
6.SpringBoot整合MyBatis
- 导入依赖(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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.2.RELEASE</version>
</parent>
<groupId>com.by</groupId>
<artifactId>04_springboot_mybatis</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- springBoot 的启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Mybatis 启动器 -->
<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>
<!-- druid 数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.9</version>
</dependency>
<!-- 添加 junit 环境的 jar 包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.0</version>
</dependency>
</dependencies>
</project>
- 配置数据源（application.properties）
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=1111
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
mybatis.type-aliases-package=com.by.pojo
logging.level.com.by.mapper=DEBUG
- 启动类
@SpringBootApplication
@MapperScan("com.by.mapper") // @MapperScan 用户扫描MyBatis的Mapper接口
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
7.SpringBoot整合日期转换器
7.1 添加日期转换器
import java.text.ParseException;
import java.util.Date;
import org.springframework.core.convert.converter.Converter;
import org.apache.commons.lang3.time.DateUtils;
public class DateConverter implements Converter<String, Date>{
@Override
public Date convert(String str) {
String[] patterns = new String[]{
"yyyy-MM-dd","yyyy-MM-dd hh:mm:ss","yyyy/MM/dd","yyyy/MM/dd hh:mm:ss",
"MM-dd-yyyy","dd-MM-yyyy"};
try {
Date date = DateUtils.parseDate(str, patterns);
return date;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
}
7.2 配置日期转换器
-
说明
WebMvcConfigurer配置类其实是
Spring内部的一种配置方式，采用JavaBean的形式来代替传统的xml配置文件形式针对框架进行个性化定制，例如：拦截器，类型转化器等等。 -
代码示例
import com.by.converter.DateConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Component
public class MyConfig implements WebMvcConfigurer {
@Override
public void addFormatters(FormatterRegistry registry) {
registry.addConverter(new DateConverter());
}
}
8.SpringBoot整合拦截器
8.1 添加拦截器
package com.by.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.by.pojo.Users;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoginInterceptor implements HandlerInterceptor{
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler)throws Exception {
Users user = (Users) request.getSession().getAttribute("user");
if(user!=null){
return true;
}
response.sendRedirect("/");
return false;
}
}
8.2 配置拦截器
修改MyConfig
@Component
public class MyConfig implements WebMvcConfigurer {
//<mvc:interceptors>
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/emp/**");
}
}
9.SpringBoot整合logback日志记录器
9.1 logback介绍
logback是log4j团队创建的开源日志组件，与log4j类似但是比log4j更强大，是log4j的改良版本。主要优势在于：
a) 更快的实现，logback内核重写过，是的性能有了很大的提升，内存占用也更小。
b) logback-classic对slf4j进行了更好的集成
c) 自动重新加载配置文件，当配置文件修改后，logback-classic能自动重新加载配置文件
d) 配置文件能够处理不同的情况，开发人员在不同的环境下（开发，测试，生产）切换的时候，不需要创建多个
文件，可以通过标签来实现
e) 自动压缩已经打出来的日志文件：RollingFileAppender在产生新文件的时候，会自动压缩已经打印出来的日志
文件。而且这个压缩的过程是一个异步的过程。
9.2 logback.xml
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
<property name="LOG_HOME" value="${catalina.base:-.}/logs/" />
<!-- 控制台输出 -->
<appender name="Stdout" class="ch.qos.logback.core.ConsoleAppender">
<!-- 日志输出编码 -->
<layout class="ch.qos.logback.classic.PatternLayout">
<!--
日志输出格式：
%d表示日期时间，
%thread表示线程名，
%-5level：级别从左显示5个字符宽度
%logger{50} 表示class的全名最长50个字符，否则按照句点分割
%msg：日志消息
%n是换行符
-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
</pattern>
</layout>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd}.log</FileNamePattern>
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<layout class="ch.qos.logback.classic.PatternLayout">
<!--
日志输出格式：
%d表示日期时间，
%thread表示线程名，
%-5level：级别从左显示5个字符宽度
%logger{50} 表示class的全名最长50个字符，否则按照句点分割
%msg：日志消息
%n是换行符
-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
</pattern>
</layout>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!-- 日志输出级别 -->
<root level="DEBUG">
<appender-ref ref="Stdout" />
<appender-ref ref="RollingFile" />
</root>
<!--日志异步到数据库 -->
<!-- <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
日志异步到数据库
<connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
连接池
<dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource">
<driverClass>com.mysql.jdbc.Driver</driverClass>
<url>jdbc:mysql://127.0.0.1:3306/databaseName</url>
<user>root</user>
<password>root</password>
</dataSource>
</connectionSource>
</appender> -->
</configuration>
10.Spring Boot部署
10.1 JAR包部署
步骤1：在pom中添加一个SpringBoot的构建的插件
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<!--自动检测项目中的 main 函数-->
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
步骤2：在maven视图中，选择“package”,在target中会产生xxx.jar包
步骤3：然后在cmd终端发布项目
java -jar xxx.jar
- Spring Boot 打成的 jar 和普通的 jar 有什么区别 ?
- Spring Boot 项目最终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过
java -jar xxx.jar命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。 - Spring Boot 的 jar 无法被其他项目依赖，主要还是他和普通 jar 的结构不同。普通的 jar 包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在
\BOOT-INF\classes目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用
- Spring Boot 项目最终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过
10.2 WAR包部署
步骤1：在pom.xml文件中将jar修改为war
<packaging>war</packaging>
步骤2：设置tomcat启动器依赖范围
maven依赖范围参考：资料/maven依赖作用范围.png
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<!--tomcat启动器依赖范围-->
<scope>provided</scope>
</dependency>
步骤3：设置war包的名字
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<configuration>
<warName>hello</warName>
</configuration>
</plugin>
步骤4：修改启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
10.3 多环境部署
Spring Boot可针对不同的环境创建不同的配置文件
- 什么是 Spring Profiles？
在项目的开发中，有些配置文件在开发、测试或者生产等不同环境中可能是不同的，例如数据库连接、redis的配置等等。那我们如何在不同环境中自动实现配置的切换呢？
Spring给我们提供了profiles机制给我们提供的就是来回切换配置文件的功能
Spring Profiles 允许用户根据配置文件（dev，test，prod 等）来注册 bean。因此，当应用程序在开发中运行时，只有某些 bean 可以加载，而在 PRODUCTION中，某些其他 bean 可以加载。假设我们的要求是 Swagger 文档仅适用于 QA 环境，并且禁用所有其他文档。这可以使用配置文件来完成。Spring Boot 使得使用配置文件非常简单
- 单个yml方式
yml支持多文档块的方式：
spring:
profiles.active: dev
# 开发环境配置
spring:
profiles: dev
server:
port: 8080
# 测试环境配置
spring:
profiles: test
server:
port: 8091
# 生产环境配置
spring:
profiles: prod
server:
port: 8092
- 多个yml方式
语法结构：application-{profile}.properties
profile:代表的就是一套环境
例：
application-dev.yml 开发环境 端口8090
server:
port: 8080
application-test.yml 测试环境 端口8091
server:
port: 8091
application-prod.yml 生产环境 端口8092
server:
port: 8092
- 运行项目
在application.yml 中激活指定的配置文件：
#激活指定的配置文件
spring.profiles.active=dev
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
