论坛 › DevOps与敏捷开发 › SpringBoot（看这一篇就够了）

忿忿的泥巴坨 发表于 2024-7-31 20:56:56

SpringBoot（看这一篇就够了）

https://i-blog.csdnimg.cn/direct/1bfe7de3a8b24281940340914d9d4a0a.png
SpringBoot

Spring的缺点

Spring是一个非常良好的轻量级框架，以IOC（控制反转）和AOP（面向切面）为思想内核，极大简化了JAVA企业级项目的开发。
固然Spring的组件代码是轻量级的，但它的配置却是重量级的。使用Spring进行项目开发需要在配置文件中写很多代码，全部这些配置都代表了开发时的斲丧。
除此之外，Spring项目的依赖管理也是一件耗时耗力的事变。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严峻拦阻项目的开发进度。好比Spring5.0以上只能使用Junit4.12以上的版本。
总结起来，Spring的缺点就是：


[*]配置过于繁琐。
[*]引入的依赖过多，版本控制复杂。
什么是SpringBoot？

SpringBoot对Spring的缺点进行改善和优化，基于约定大于配置的思想，简化了Spring的开发，所谓简化是指简化了Spring中大量的配置文件和繁琐的依赖引入。所以SpringBoot是一个服务于框架的框架，它不是对Spring功能的增强，而是提供了一种快速使用Spring框架的方式
SpringBoot的优点：


[*]配置简朴
[*]依赖引入简朴
[*]提供了一些大型项目的非功能特性，如嵌入式服务器，安全指标，健康监测等。
主动配置
SpringBoot项目主动提供最优配置，同时可以修改默认值满意特定的要求。
起步依赖
SpringBoot的依赖是基于功能的，而不是平凡项目的依赖是基于JAR包的。SpringBoot将完成一个功能所需要的全部坐标打包到一起，并完成了版本适配，我们在使用某功能时只需要引入一个依赖即可。
Springboot3 版本要求

然使用SpringBoot是需要肯定版本要求的：
工具版本要求IDEA2021.2.1+Java17+Maven3.5+Tomcat10.0+Servlet5.0+GraalVM（原生镜像功能） Community 22.3+Native Build Tools（原生镜像功能）0.9.19+ Springboot的三种构建方式

官网搭建

接下来我们搭建一个SpringBoot项目，并引入SpringMVC的功能，首先我们可以通过官网搭建项目：
1.访问start.spring.io
2.生成SpringBoot项目
https://i-blog.csdnimg.cn/direct/9ce6e05e4e874e678388be904cf2ec8e.png
   SpringBoot版本阐明：


[*]SNAPSHOT：快照版，表示开发版本，随时大概修改；
[*]M1（Mn）：M1是milestone的缩写，也就是里程碑版本；
[*]RC1（RCn）：RC1是release candidates的缩写，也就是发布预览版；
[*]Release：正式版，也大概没有任何后缀也表示正式版
SpringBoot打包类型阐明：


[*]使用SpringMVC开发的是一个web项目，但由于在SpringBoot中直接嵌入了Tomcat等Web容器，所以在使用SpringBoot做Web开发时不需要部署War文件，只需要打成Jar包即可。
3.解压生成的SpringBoot项目
4.在Idea中打开解压的SpringBoot项目即可
通过IDEA脚手架搭建

我们也可以在IDEA中使用脚手架工具搭建项目：
1.在IDEA中新建项目，项目类型为Spring Initializr，写项目名、存放位置、语言类型、项目类型、JDK版本等。点击下一步。
   注意：这里肯定要将项目类型改为Maven
https://i-blog.csdnimg.cn/direct/0cea497f8450497896f72dfd11cc1eb4.png
2. 选择SpringBoot版本和需要的起步依赖，创建。
https://i-blog.csdnimg.cn/direct/2e446acecbec429e9673bc53e5877152.png
3.完成项目搭建
通过Maven搭建项目

不管是通过官网，照旧通过脚手架搭建项目，都需要连接SpringBoot官网，但国内与SpringBoot官网连接并不稳固，此时我们也可以使用Maven手动搭建SpringBoot项目：
1.创建新项目
https://i-blog.csdnimg.cn/direct/12290ba3b38e43c5b79defaecc78c2b1.png
2.在pom中添加项目的父工程、起步依赖、插件、依赖和插件的下载所在
<!-- 父工程 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.1.2</version>
</parent>
<!-- 起步依赖 -->
<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
</dependencies>


<!-- 插件 -->
<build>
<plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>
3.编写启动类
@SpringBootApplication
public class SpringBootApp {
public static void main(String[] args) {
    SpringApplication.run(SpringBootApp.class, args);
   }
}
4.编写配置文件application.properties
#日志格式
logging.pattern.console=%d{MM/dd HH:mm:ss.SSS} %clr(%-5level) ---[%-15thread] %cyan(%-50logger{50}):%msg%n
#端口号
server.port=8889
5.运行启动类主方法，启动项目
SpringBoot的项目结构

https://i-blog.csdnimg.cn/direct/7cc5d02f934c40fca73bfb2782ac0b3b.png
src.main.java
这个目录下存放的是Java代码，在我们写好的包名下，SprinBoot生成了一个启动类，启动类的作用是启动SpringBoot项目，运行启动类的main方法即可启动SpringBoot项目。
src.main.resources
这个目录下存放的是配置文件和页面相关的代码，SpringBoot默认在static目录中存放静态资源，如css、js、图片等等。而templates中存放模板引擎，如jsp、thymeleaf等。
由于SpringBoot极大简化了Spring配置，所以只有一个application.properties配置文件，Spring的主动配置功能使得大部分的配置都有默认配置，该文件的功能是覆盖默认配置信息，该文件不写任何信息都可以启动项目。
启动后默认端口号为8080，我们可以覆盖该配置：
server.port=8888
src.test.java
这个目录下编写的是测试代码
pom文件
1.SpringBoot项目必须继续spring-boot-starter-parent，即全部的SpringBoot项目都是spring-boot-starter-parent的子项目。spring-boot-starter-parent中定义了常用配置、依赖、插件等信息，供SpringBoot项目继续使用。
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.1.2</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
2.SpringBoot项目中可以定义起步依赖，起步依赖不是以jar包为单元，而是以功能为单元
<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
</dependencies>
3.spring-boot-maven-plugin插件是将项目打包成jar包的插件。该插件打包后的SpringBoot项目无需依赖web容器，可以直接使用JDK运行
<build>
<plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>
编写一个测试代码

之前搭建的SpringBoot项目已经都整合了SpringMVC，我们编写一个控制器进行测试：
@Controller
public class MyController {
@RequestMapping("/hello")
@ResponseBody
public String hello(){
    System.out.println("hello springboot!");
    return "hello springboot!";
   }
}
启动类在启动时会做注解扫描(@Controller、@Service、@Repository…)，扫描位置为同包大概同级包下的注解，所以我们要在启动类同级或同级包下编写代码。
https://i-blog.csdnimg.cn/direct/a0721dbcd51f4a10a2d544c255d4e7f4.png
启动项目，访问http://localhost:8889/hello
YAML文件

SpringBoot项目中，大部分配置都有默认值，但如果想更换默认配置的话，可以使用application.properties文件进行配置。properties文件是键值对类型的文件，之前不停在使用，所以我们不再对properties文件进行论述。
   https://docs.spring.io/spring-boot/docs/3.1.2/reference/htmlsingle/#appendix.application-properties
可以查找配置文件如何覆盖SpringBoot项目的默认配置。
除了properties文件外，SpringBoot还支持YAML文件进行配置。YAML文件的扩展名为.yml或.yaml。SpringBoot默认会从resources目录下加载application.properties或application.yml文件。
YAML文件的基本要求如下：


[*]巨细写敏感
[*]使用缩进代表层级关系
[*]同级配置必须对齐，上下级配置必须缩进，但缩进的空格数不限。
[*]相同的部分只出现一次
[*]冒号和值之间必须要有空格
好比使用properties文件配置tomcat端口以及项目路径：
server.port=8888
server.servlet.context-path=/jjy 而使用YAML文件配置tomcat端口：
server:
servlet:
   context-path: /jjy
port: 8888
自定义配置文件

配置简朴数据
语法:
数据名: 值
示例代码：
email: jjy@qq.com
配置对象数据
语法：
对象:
    属性名1: 属性值
    属性名2: 属性值
# 或者
对象: {属性名1: 属性值,属性名2: 属性值}
示例代码：
# 邮箱1my1:email: jjy@qq.com
password: jjy# 邮箱2my2: {email: jjyss@qq.com,password: jjyss} 配置聚集数据
语法
集合:
    - 值1
    - 值2
   
# 或者
集合: [值1,值2]
示例代码
# 城市city1:- beijing- shanghai- tianjin- chongqingcity2: # 聚集中的元素是对象sxt:- address: beijing   mobile: 13888888888   email: jjy@qq.com
- address: shanghai   mobile: 13777777777   email: jjyss@qq.com- address: guangzhou   mobile: 13666666666   email: jjyaa@qq.com @Value读取配置文件

读取自定义配置时，我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上，用法如下：
配置文件
email: jjy@qq.com
my1:email: jjy@qq.com
password: ijjycity1:- beijing- shanghai- tianjin- chongqingsxt:- address: beijing   mobile: 13888888888   email: jjy@qq.com
- address: shanghai   mobile: 13777777777   email: jjysss@qq.com- address: guangzhou   mobile: 13666666666   email: jjyaaa@qq.com 读取配置文件数据
@Controller
public class YmlController1 {
@Value("${email}")
private String email;


@Value("${my1.password}")
private String password;


@Value("${city1}")
private String city1;


@Value("${sxt.mobile}")
private String mobile;


@RequestMapping("/yml1")
@ResponseBody
public String yml1(){
    return email+":"+password+":"+city1+":"+mobile;
   }
}
   @Value只能映射简朴数据类型，不能将yaml文件中的对象、聚集映射到属性中。
@ConfigurationProperties读取配置文件

通过@ConfigurationProperties(prefifix="对象")可以将配置文件中的配置主动与实体进行映射，如许可以将yml文件中配置的对象属性直接映射到Bean当中。
配置文件
user:
id: 10001
username: shangxuetang
address:
   - beijing
   - tianjin
   - shanghai
   - chongqing
grades:
   - subject: math
    score: 100
   - subject: english
    score: 90
实体类
public class Grade {
private String subject;
private double score;
// 省略getter/setter/tostring
}
读取配置文件
@Controller
@ConfigurationProperties(prefix = "user")
public class YmlController2 {
private int id;
private String username;
private List<String> address;
private List<Grade> grades;


@RequestMapping("/yml2")
@ResponseBody
public String yml2(){
    System.out.println(id);
    System.out.println(username);
    System.out.println(address);
    System.out.println(grades);
    return "hello springboot!";
   }


public int getId() {
    return id;
   }


public void setId(int id) {
    this.id = id;
   }


public String getUsername() {
    return username;
   }


public void setUsername(String username) {
    this.username = username;
   }


public List<String> getAddress() {
    return address;
   }


public void setAddress(List<String> address) {
    this.address = address;
   }


public List<Grade> getGrades() {
    return grades;
   }


public void setGrades(List<Grade> grades) {
    this.grades = grades;
   }
}

SpringBoot整合Web开发

由于SpringBoot项目没有web.xml文件，所以无法在web.xml中注册web组件，SpringBoot有自己的方式注册web组件。
注册方式一

1.编写servlet
@WebServlet("/first")
public class FirstServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response){
    System.out.println("First Servlet........");
   }
}
2.启动类扫描web组件
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
public static void main(String[] args) {
    SpringApplication.run(Springbootdemo2Application.class, args);
   }
}
注册方式二

编写servlet
public class SecondServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response){
    System.out.println("Second Servlet........");
   }
}
使用配置类注册servlet
@Configuration
public class ServletConfig {
//ServletRegistrationBean可以注册Servlet组件，将其放入Spring容器中即可注册Servlet
@Bean
public ServletRegistrationBean getServletRegistrationBean(){
    // 注册Servlet组件
    ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
    // 添加Servlet组件访问路径
    bean.addUrlMappings("/second");
    return bean;
   }
}
SpringBoot整合Web开发_Filter

注册方式一

编写filter
@WebFilter(urlPatterns = "/first")
public class FirstFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException { }
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    System.out.println("进入First Filter");
    filterChain.doFilter(servletRequest,servletResponse);
    System.out.println("离开First Filter");
   }
@Override
public void destroy() { }
}
启动类扫描web组件
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
public static void main(String[] args) {
    SpringApplication.run(Springbootdemo2Application.class, args);
   }
}
注册方式二

编写filter
public class SecondFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException { }

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    System.out.println("进入Second Filter");
    filterChain.doFilter(servletRequest,servletResponse);
    System.out.println("离开Second Filter");
   }


@Override
public void destroy() { }
}
使用配置类注册filter
@Configuration
public class FilterConfig {
@Bean
public FilterRegistrationBean getFilterRegistrationBean(){
    // 注册filter组件
    FilterRegistrationBean bean = new FilterRegistrationBean(new SecondFilter());
    // 添加过滤路径
    bean.addUrlPatterns("/second");
    return bean;
   }
}
SpringBoot整合Web开发_Listener

注册方式一

编写Listener
@WebListener
public class FirstListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
    System.out.println("First Listener Init......");
   }


@Override
public void contextDestroyed(ServletContextEvent sce) {


   }
}
启动类扫描web组件
@SpringBootApplication
//SpringBoot启动时扫描注册注解标注的Web组件
@ServletComponentScan
public class Springbootdemo2Application {
public static void main(String[] args) {            
    SpringApplication.run(Springbootdemo2Application.class, args);
   }
}
注册方式二

编写Listener
public class SecondListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
    System.out.println("Second Listener Init......");
   }

@Override
public void contextDestroyed(ServletContextEvent sce) {

   }
}
使用配置类注册Listener
@Configuration
public class ListenerConfig {
@Bean
public ServletListenerRegistrationBean getServletListenerRegistrationBean(){
    ServletListenerRegistrationBean bean = new ServletListenerRegistrationBean(new SecondListener());
    return bean;
   }
}
SpringBoot整合Web开发_静态资源

SpringBoot项目中没有WebApp目录，只有src目录。在src/main/resources下面有static和templates两个文件夹。SpringBoot默认在static目录中存放静态资源，而在templates中放动态页面。
   SpringBoot不推荐JSP作为动态页面，推荐使用Thymeleaf技术编写动态页面。templates目录是存放Thymeleaf页面的目录，稍后我们讲解Thymeleaf技术。
接下来我们在resources/static中编写html静态页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试HTML</title>
<script src="/js/page1.js"></script>
<link rel="stylesheet" href="/css/page1.css" />
</head>
<body>
<p>我的HTML</p>
<img src="/img/img.png">
</body>
</html>
目录结构
https://i-blog.csdnimg.cn/direct/aa1bba1a3644443a93aabc09c23c81fd.png
SpringBoot整合Web开发_静态资源其他存放位置

除了/resources/static目录，SpringBoot还会扫描以下位置的静态资源：


[*]/resources/META‐INF/resources/
[*]/resources/resources/
[*]/resources/public/
https://i-blog.csdnimg.cn/direct/d8b95250c2f84291ab0a532a99e954e8.png
我们还可以在配置文件自定义静态资源位置
https://i-blog.csdnimg.cn/direct/d9d9533f2953463a8beb963b256ef281.png
在SpringBoot配置文件进行自定义静态资源位置配置
spring:
web:
   resources:
    static-locations: classpath:/suibian/,classpath:/static/
   注意：
该配置会覆盖默认静态资源位置，如果还想使用之前的静态资源位置，还需要配置在后面。
SpringBoot2.5之前的配置方式为：spring.resources.static-locations
SpringBoot整合Web开发_JSP

在SpringBoot中不推荐使用JSP作为动态页面，如果我们要想使用JSP编写动态页面，需要手动添加webapp目录。


[*]由于SpringBoot自带tomcat无法解析JSP，需要在pom文件添加JSP引擎
<!--添加jsp引擎，SpringBoot内置的Tomcat不能解析JSP-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>


[*]将webapp标志为web目录
https://i-blog.csdnimg.cn/direct/d116d682ae9e4b94b4b133e4ff275759.png
[*]创建webapp目录，编写JSP文件
https://i-blog.csdnimg.cn/direct/22dae12774ce4038adb46cd87e0e092a.png
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>MYJSP</title>
</head>
<body>
MYJSP
</body>
</html>


[*]启动项目，访问http://localhost:8080/myJsp.jsp
SpringBoot整合MyBatis

Spring整合MyBatis时需要进行大量配置，而SpringBoot整合MyBatis则可以简化很多配置：
1.准备数据库
CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`sex` varchar(10) DEFAULT NULL,
`address` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;


insert into `student`(`id`,`name`,`sex`,`address`) values (1,'百战程序员','男','北京'),(2,'北京尚学堂','女','北京');

2.在pom中添加MyBatis起步依赖和Mysql驱动依赖
<dependencies>
<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>3.0.2</version>
</dependency>
<!-- mysql依赖 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- mybatis测试起步依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter-test</artifactId>
    <version>3.0.2</version>
    <scope>test</scope>
</dependency>
</dependencies>
3.编写实体类
public class Student {
private int id;
private String name;
private String sex;
private String address;

// 省略构造方法/getter/setter/tostring
}
4.编写Mapper
@Mapper
public interface StudentMapper {
List<Student> findAll();

@Select("select * from student where id = #{id}")
Student findById(int id);
}
5.编写Mapper映射文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jjy.springbootmybatis.mapper.StudentMapper">
<select id="findAll" resultType="student">
   select * from student
</select>
</mapper>
6.编写配置文件
# 配置数据源
spring:
datasource:
   driver-class-name: com.mysql.cj.jdbc.Driver
   url: jdbc:mysql:///student?serverTimezone=UTC
   username: root
   password: root

#mybatis配置
mybatis:
# 映射文件位置
mapper-locations: com/jjy/springbootdemo7/mapper/*Mapper.xml
# 别名
type-aliases-package: com.jjy.springbootdemo7.pojo

logging:
pattern:
   console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---[%-15thread] %cyan(%-50logger{50}):%msg%n'
SpringBoot单元测试

写了MyBatis相关代码后，我们要测试MyBatis代码是否正确。需要进行单元测试。SpringBoot单元测试要比Spring更简朴。
1.SpringBoot项目在构建时，默认引入单元测试的起步依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
2.在src.test.java下创建测试类，也可以让idea主动创建测试类，打开要测试的类：
ctrl+shift+t --> create new test
https://i-blog.csdnimg.cn/direct/d5712e50d43642faab40bf8ef3327ecd.png
3.编写测试类
// 测试类注解，可以在运行测试代码时加载容器
@SpringBootTest
class StudentMapperTest {
@Autowired
private StudentMapper studentMapper;


@Test
void findAll() {
    List<Student> all = studentMapper.findAll();
    all.forEach(System.out::println);
   }


@Test
void findById() {
    Student student = studentMapper.findById(1);
    System.out.println(student);
   }
}
SpringBoot热部署

热部署，就是在应用正在运行的时候升级软件，却不需要重新启动应用。即修改完代码后不需要重启项目即可生效。在SpringBoot中，可以使用DevTools工具实现热部署
1.添加DevTools依赖
<!-- 热部署工具 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>

[*]在idea中设置主动编译
点击File–>Settings–>Compiler
https://i-blog.csdnimg.cn/direct/8ffa953fbf75484caa30e8ece491b587.png
3.开启答应在运行中修改文件
点击File–>Settings–>Advanced Settings，勾选Allow auto-make to start even if developed application is currently running
https://i-blog.csdnimg.cn/direct/785569ea38444459a9c6db0c1ad0bbf6.png
此时热部署即可生效
SpringBoot定时任务

定时任务即系统在特定时间实行一段代码。Spring Boot默认已经整合了Spring Task定时任务，只需要添加相应的注解即可完成。
1.在启动类中加入@EnableScheduling注解即可开启定时任务
@SpringBootApplication
@EnableScheduling
public class Demo1Application {
public static void main(String[] args) {
    SpringApplication.run(Demo1Application.class, args);
   }
}
2.编写定时任务
@Component
public class MyTask {
// 定时任务方法，每秒执行一次
@Scheduled(cron="* * * * * *")
public void task1() {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    System.out.println(sdf.format(new Date()));
   }
}
   @Scheduled 是 Spring Framework 中的一个注解，它用于标志一个方法，使其成为一个定时任务，按照肯定的时间间隔或特定的时间点实行。cron 参数是一个字符串，用于定义任务实行的筹划。Cron 表达式由六或七个字段组成，每个字段代表不同的时间单元：
秒 (0 - 59)
分钟 (0 - 59)
小时 (0 - 23，24小时制)
日期 (1 - 31)
月份 (1 - 12 或 JAN-DEC)
星期几 (0 - 7，7 或 0 表示星期天，大概使用 SUN-SAT)
年份（可选字段）
cron="* * * * * " 表示：
秒： 表示每秒钟都会触发一次。
分钟：* 表示每分钟的每秒钟都会触发。
小时：* 表示每小时的每分钟都会触发。
日期：* 表示每月的每天都会触发。
月份：* 表示每年的每个月都会触发。
星期几：* 表示每周的每一天都会触发。
这意味着任务将每秒钟实行一次，这通常是不必要的，除非有特定的需求需要如此高频率的实行。通常，我们会根据实际需要来调解这个表达式，以克制过度实行任务。
3.启动项目，定时任务方法按照配置定时实行。
SpringBoot内容协商机制

https://i-blog.csdnimg.cn/direct/9c1b7ef2aea24e1783b6674997259509.png
如果我们的Java服务为欣赏器和安卓手机同时提供服务，欣赏器盼望接受的哀求是JSON格式，安卓客户端盼望吸取的哀求是XML格式，这个时候是否需要写两个方法？
不需要！SpringBoot的内容协商机制可以解决这个问题。
内容协商机制：根据客户端吸取本领不同，SpringBoot 返回不同媒体类型的数据。
Spring默认支持内容协商机制，但SpringBoot默认只支持返回Json数据，所以需要导入jackson-dataformat-xml让SpringBoot支持返回xml数据
1.引入依赖
<!-- 引入支持返回 xml 数据格式 -->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
2.编写控制器
@Controller
public class ConsultController {
@Autowired
private StudentMapper studentMapper;

@RequestMapping("/student/findById")
@ResponseBody
public Student findById(Integer id){
    Student student = studentMapper.findById(id);
    return student;
   }
}
3.进行测试，SpringBoot的内容协商机制是根据哀求头不同，返回不同格式的数据，所以需要我们能够修改哀求头，我们使用postman进行测试：
https://i-blog.csdnimg.cn/direct/b9efbf0e416145228b225f6977854191.png
https://i-blog.csdnimg.cn/direct/0c111662f2f64c44808f17fcf77c3212.png
SpringBoot内容协商机制_基于哀求参数

SpringBoot默认根据哀求头不同，返回不同的数据格式。我们还可以配置基于哀求参数的内容协商，也就是哀求参数值不同，返回不同的数据：
1.配置SpringBoot基于哀求参数的内容协商
#开启请求参数内容协商模式
spring.mvc.contentnegotiation.favor-parameter=true
#请求参数内容协商模式的参数名
spring.mvc.contentnegotiation.parameter-name=format
2.在postman进行测试：
https://i-blog.csdnimg.cn/direct/f0977fb8e85f4e5f95b7130c9b79e686.png
https://i-blog.csdnimg.cn/direct/c144e21e0fbc44a9a803688379a7e991.png
SpringBoot国际化

国际化：（Internationalization 简称 I18n，其中“I”和“n”分别为首末字符，18 则为中间的字符数）。是指软件能同时应对不同国家和地域的用户访问，并根据用户地域和语言风俗，提供相应的、符合用具阅读风俗的页面和数据，例如，为中国用户提供汉语界面表现，为美国用户提供英语界面表现。接下来我们来说一下在SpringBoot项目中，如何进行国际化配置：
1、编写国际化资源文件
SpringBoot国际化资源文件的文件名规范为：基本名_语言代码_国家或地域代码。例如：


[*] 美国英语：messages_en_US.properties：
[*] 中国汉语：messages_zh_CN.properties。
我们在 src/main/resources中，按照国际化资源文件定名格式分别创建以下三个文件：
[*] messages.properties：无语言设置时生效
[*] messages_en_US.properties：美国英语时生效
[*] messages_zh_CN.properties：中文时生效
https://i-blog.csdnimg.cn/direct/7f6360e6d7474713a8212d12b267fc92.png
编写三个文件：
# messages.properties
welcome=欢迎使用{0}(默认)


# messages_en_US.properties
welcome=welcome to {0}


# messages_zh_CN.properties
welcome=欢迎使用{0}(中文)

   注意，这里要将项目配置文件的编码方式改成UTF-8，否则会出现乱码
https://i-blog.csdnimg.cn/direct/89b6ffdd825e4f6cb9fd890a31556aa4.png
2、在配置文件指定国际资源文件的基本名
spring:
messages:
   basename: messages
3、编写控制器
@Controller
public class I18nController {
@Autowired
private MessageSource messageSource;

@RequestMapping("/welcome")
@ResponseBody
public String welcome(HttpServletRequest request) {
    // 获取请求来源的地区
    Locale locale = request.getLocale();
    /**
   * 使用国际化
   * 第一个参数是国际化文件的key，
   * 第二个参数value中的占位符数据
   * 第三个是区域
   */
    String welcome = messageSource.getMessage("welcome", new Object[]{"springboot"}, locale);
    return welcome;
   }
}
4、在欣赏器测试国际化
先在默认情况下访问/welcome，之后切换欣赏器环境，再次访问/welcome
https://i-blog.csdnimg.cn/direct/fd3843ba12c54bc2990ff97a82f0b0b7.png
SpringBoot国际化_在Thymeleaf中进行国际化

在Thymeleaf页面中获取国际化资源数据的方式如下：
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8"/>
<title>Title</title>
</head>
<body>
<h1 th:text="#{welcome('springboot')}">欢迎</h1>
<h1>[[#{welcome('springboot')}]]</h1>
</body>
</html>
SpringBoot参数校验

简朴数据类型

SpringBoot自带了validation工具可以从后端对前端传来的参数进行校验，用法如下：
1.引入validation起步依赖
<!-- 参数校验 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
2.编写Controller
// 该控制器开启参数校验
@Validated
@Controller
public class TestController {
@RequestMapping("/t1")
@ResponseBody
// 在参数前加校验注解，该注解的意思是字符串参数不能为null
public String t1(@NotBlank String username){
    System.out.println(username);
    return "请求成功！";
   }
}
3.访问http://localhost:8080/t1，发现当没有传来参数时，会抛出ConstraintViolationException异常。
4.在校验参数的注解中添加message属性，可以更换异常信息。
// 该控制器开启参数校验
@Validated
@Controller
public class TestController {
@RequestMapping("/t1")
@ResponseBody
// 在参数前加校验注解，该注解的意思是字符串参数不能为null
public String t1(@NotBlank(message = "用户名不能为空") String username){
    System.out.println(username);
    return "请求成功！";
   }
}
异常处理

当抛出ConstraintViolationException异常后，我们可以使用SpringMVC的异常处理器，也可以使用SpringBoot自带的异常处理机制。
当步伐出现了异常，SpringBoot会使用自带的BasicErrorController对象处理异常。该处理器会默认跳转到/resources/templates/error.html页面。
编写异常页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>错误页面</title>
</head>
<body>
<h1>服务器开小差了！</h1>
</body>
</html>
参数校验_校验相关注解

注解作用@NotNull判定包装类是否为null@NotBlank判定字符串是否为null大概是空串(去掉首尾空格)@NotEmpty判定聚集是否为空@Length判定字符的长度(最大大概最小)@Min判定数值最小值@Max判定数值最大值@Email判定邮箱是否合法 @RequestMapping("/t2")
@ResponseBody
public String t2(
    @NotBlank @Length(min = 1, max = 5) String username,
    @NotNull @Min(0) @Max(150) Integer age,
    @NotEmpty @RequestParam List<String> address,
    @NotBlank @Email String email) {
System.out.println(username);
System.out.println(age);
System.out.println(address);
System.out.println(email);
return "请求成功！";
}
参数校验_对象类型

SpringBoot也可以校验对象参数中的每个属性，用法如下：
1.添加实体类
public class Student {
@NotNull(message = "id不能为空")
private Integer id;
@NotBlank(message = "姓名不能为空")
private String name;
// 省略getter/setter/tostring
}
2.编写控制器
@Controller
public class TestController2 {
@RequestMapping("/t3")
@ResponseBody
// 校验的对象参数前添加@Validated，并将异常信息封装到BindingResult对象中
public String t3(@Validated Student student,BindingResult result) {
    // 判断是否有参数异常
    if (result.hasErrors()) {
      // 所有参数异常
      List<ObjectError> list = result.getAllErrors();
      // 遍历参数异常，输出异常信息
      for (ObjectError err : list) {
      FieldError fieldError = (FieldError) err;
      System.out.println(fieldError.getDefaultMessage());
       }
      return "参数异常";
   }
    System.out.println(student);
    return "请求成功！";
   }
}
SpringBoot指标监控

添加Actuator功能

Spring Boot Actuator可以资助步伐员监控和管理SpringBoot应用，好比健康查抄、内存使用情况统计、线程使用情况统计等。我们在SpringBoot项目中添加Actuator功能，即可使用Actuator监控项目，用法如下：
1.在被监控的项目中添加Actuator起步依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
2.编写配置文件
#开启所有监控端点
management:
endpoints:
   web:
    exposure:
   include: '*'
   
3.访问项目：http://localhost:8080/actuator
通过URL可以调用actuator的功能：
URL查看的数据/env环境属性/health健康查抄/mappings表现全部的@RequestMapping路径/loggers日志/info定制信息/metrics查看内存、CPU核心等系统参数/trace用户哀求信息 例如查询健康数据，访问http://localhost:8080/actuator/health
Spring Boot Admin

https://i-blog.csdnimg.cn/direct/b25f1e64600f4641b76ffae6d84b9154.png
Actuator使用JSON格式展示了大量指标数据，倒霉于我们查看，我们可以使用可视化工具Spring Boot Admin查看actuator生成指标数据。Spring Boot Admin是一个独立的项目，我们需要创建并运行该项目。
创建Spring Boot Admin服务端项目
1.创建SpringBoot项目，添加SpringMVC和Spring Boot Admin服务端起步依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
<version>3.1.3</version>
</dependency>
2.修改配置文件
# 端口号
server.port=9090
# 日志格式
logging.pattern.console=%d{HH:mm:ss.SSS} %clr(%-5level) ---[%-15thread] %cyan(%-50logger{50}):%msg%n
3.修改启动类
@SpringBootApplication
@EnableAdminServer //开启Spring Boot Admin服务端
public class MyadminApplication {
public static void main(String[] args) {
    SpringApplication.run(MyadminApplication.class, args);
   }
}
连接Spring Boot Admin项目
在被监控的项目中连接Spring Boot Admin项目，才能使用Spring Boot Admin查看指标数据。
被监控项目添加Spring Boot Admin客户端起步依赖
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>3.1.3</version>
</dependency>
修改配置文件
#Spring boot admin访问地址
spring.boot.admin.client.url=http://localhost:9090
此时Spring Boot Admin即可连接被监控的项目
SpringBoot日志管理

Logback

SpringBoot默认使用Logback组件作为日志管理。Logback是log4j创始人设计的一个开源日志组件。在SpringBoot中已经整合了Logback的依赖，所以我们不需要额外的添加其他依赖：
Logback配置用法如下：
1.在/resources下添加Logback配置文件logback.xml
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
<!--定义日志文件的存储地址-->
<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个字符宽度%msg：日志消息，%n是换行符-->
      <pattern>%d{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{yy99-MM-dd}.log</FileNamePattern>
      <MaxHistory>30</MaxHistory>
    </rollingPolicy>
    <layout class="ch.qos.logback.classic.PatternLayout">
      <!--格式化输出：%d表示时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
      <pattern>%d{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="info">
    <appender-ref ref="Stdout"/>
    <appender-ref ref="RollingFile"/>
</root>
</configuration>

   注：Logback配置文件名为logback-test.xml或logback.xml，如果classpath下没有这两个文件，LogBack会主动进行最小化配置。
打印自定义日志

如果想在运行时打印自定义日志，只需要引入Logger对象即可：
@Controller
public class LogbackController {
private final static Logger logger = LoggerFactory.getLogger(LogbackController.class);

@RequestMapping("/printLog")
@ResponseBody
public String showInfo(){
    logger.info("记录日志");
    return "Hello Logback";
   }
}
如果日志过多，可以屏蔽一些包的日志，在配置文件中配置
#屏蔽org包中的日志输出
logging.level.org=off
SpringBoot项目部署

项目打包

SpringBoot项目是依赖于Maven构建的，但打包时如果只依赖Maven打包工具则会打包不完整，我们还需要在SpringBoot项目中引入SpringBoot打包插件 ：
<build>
<plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>
此时再使用Maven插件打包：
https://i-blog.csdnimg.cn/direct/1e3d782bd37f4f72bc477249fb25140e.png
运行jar包：
1.进入jar包所在目录，使用cmd打开命令行窗口
2.输入命令：
   java -jar jar包名
多环境配置

在真实开发中，在不同环境下运行项目往往会进行不同的配置，好比开发环境使用的是开发数据库，测试环境使用的是测试数据库，生产环境使用的是生产数据库。SpringBoot支持不同环境下使用不同的配置文件，用法如下：
配置文件名：
application-环境名.properties/yml
如：
application-dev.properties/yml 开发环境配置文件
# 开发环境端口号为8080
server:
port: 8080
application-test.properties/yml 测试环境配置文件
# 测试环境端口号为8081
server:
port: 8081
application-prod.properties/yml 生产环境配置文件
# 生产环境端口号为80
server:
port: 80
运行jar包时选择环境：
java -jar jar包名 --spring.profiles.active=环境名
Dockerfile制作镜像

为了节约资源，在生产环境中我们更多的是使用Docker容器部署SpringBoot应用，首先我们准备Docker环境：
1.准备一台centos7系统的假造机，连接假造机。
2.关闭假造机防火墙
# 关闭运行的防火墙
systemctl stop firewalld.service

# 禁止防火墙自启动
systemctl disable firewalld.service
3.安装Docker
# 安装Docker
yum -y install docker

# 启动docker
systemctl start docker
4.由于SpringBoot中嵌入了Web容器，所以在制作SpringBoot项目的镜像时无需依赖Web容器，基于JDK制作镜像即可，接下来我们使用Dockerfile制作镜像：
5.进入opt目录
cd /opt
6.使用rz命令将项目Jar包上传至假造机
7.编写DockerFile
cat <<EOF > Dockerfile
# 基于JDK17
FROM openjdk:17
# 作者
MAINTAINER itbaizhan
# 拷贝到容器opt目录
ADD springbootdemo9-0.0.1-SNAPSHOT.jar /opt
#保留端口
EXPOSE 8080
# 启动容器后执行的命令
CMD java -jar /opt/springbootdemo9-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
EOF
8.构建镜像
docker build -t springbootdocker .
9.查看全部的镜像，出现springbootdocker代表镜像构建成功
docker images

10.使用镜像启动容器
docker run -d -p 8080:8080 springbootdocker
11.访问项目
Maven插件制作镜像

除了DockerFile，我们还可以使用Maven插件制作镜像。使用方法如下：
1.开启远程docker服务
# 修改docker配置文件
vim /lib/systemd/system/docker.service


# 在ExecStart=后添加配置，远程访问docker的端口为2375
ExecStart=/usr/bin/dockerd-current -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \
   --add-runtime docker-runc=/usr/libexec/docker/docker-runc-current \
   --default-runtime=docker-runc \
   --exec-opt native.cgroupdriver=systemd \
   --userland-proxy-path=/usr/libexec/docker/docker-proxy-current \
   --init-path=/usr/libexec/docker/docker-init-current \
   --seccomp-profile=/etc/docker/seccomp.json \
   $OPTIONS \
   $DOCKER_STORAGE_OPTIONS \
   $DOCKER_NETWORK_OPTIONS \
   $ADD_REGISTRY \
   $BLOCK_REGISTRY \
   $INSECURE_REGISTRY \
   $REGISTRIES




# 重启docker
systemctl daemon-reload
systemctl restart docker
2.在项目的pom文件中添加docker-maven-plugin插件
<!-- docker-maven-plugin-->
<plugin>
<groupId>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>1.2.2</version>
<configuration>
    <!-- Docker路径 -->
    <dockerHost>http://192.168.1.25:2375</dockerHost>
    <!-- Dockerfile定义 -->
    <baseImage>openjdk:17</baseImage>
    <!-- 作者 -->
    <maintainer>itbaizhan</maintainer>
    <resources>
      <resource>
      <!-- 复制jar包到docker容器指定目录 -->
      <targetPath>/</targetPath>
      <!-- 从哪个包拷贝文件，target包 -->
      <directory>${project.build.directory}</directory>
      <!-- 拷贝哪个文件 -->
      <include>${project.build.finalName}.jar</include>
      </resource>
    </resources>
    <workdir>/</workdir>
    <entryPoint>["java", "-jar", "${project.build.finalName}.jar","--spring.profiles.active=dev"]</entryPoint>
    <forceTags>true</forceTags>
    <!-- 镜像名 -->
    <imageName>${project.artifactId}</imageName>
    <!-- 镜像版本 -->
    <imageTags>
      <imageTag>${project.version}</imageTag>
    </imageTags>
</configuration>
</plugin>

3.使用maven的package命令给项目打包
https://i-blog.csdnimg.cn/direct/919d9316fbd44c6880465371766313f1.png
4.用maven的docker插件制作镜像
https://i-blog.csdnimg.cn/direct/4bbb752ee602432288685376591a426a.png
5.查看镜像是否构建成功
docker images

6.使用镜像启动容器
docker run -d -p 8081:8080 demo1:0.0.1-SNAPSHOT
7.访问项目
SpringBoot3新特性

与之前版本的改动

我们在使用SpringBoot3的时候，肯定要注意以下几个方面的改动：


[*] JDK要求最低版本Java17
[*] SpringBoot3底层默认的Spring版本是Spring6
[*] 新增了一些起步依赖，有一些起步依赖进行了调解，但改动不大。
[*] 主动配置包位置发生了变化
SpringBoot2.x
https://i-blog.csdnimg.cn/direct/e24c7e152af942b1ac06a027e80c3339.png
SpringBoot3.x
https://i-blog.csdnimg.cn/direct/3fb892dc972c4aecbb2b7113573e66de.png


[*]jakarta api迁移
由于JavaEE已经变动为Jakarta EE，包名以 javax开头的需要相应地变动为jakarta
SpringBoot2.x
https://i-blog.csdnimg.cn/direct/8e2b7c5bdabb47f9bf59fb5f3da65ab7.png
SpringBoot3.x
https://i-blog.csdnimg.cn/direct/afc0e3c3814c4637941c5256431776dd.png
ProblemDetails

RFC 7807
之前的项目如果出现异常，默认跳转到error页面。大概是抛出500异常。
https://i-blog.csdnimg.cn/direct/141581c0d02e4a3295511e86d409f539.png
https://i-blog.csdnimg.cn/direct/a2df5766fa7f46f9a62ca429df828e5f.png
但是对于前后端分离的项目，Java步伐员不负责页面跳转，只需要把错误信息交给前端步伐员处理即可。而RFC 7807规范就是将异常信息转为JSON格式的数据。这个JSON数据包含五个部分


[*] type: 问题形貌文档所在，如果不存在，则"about:blank"
[*] title: 简短的形貌问题
[*] status: http 状态码，好比400、401、500等
[*] detail: 详细阐明发生问题的原因
[*] instance: 问题发生的URL所在
{
"type": "https://pack.com/probs/out-of-credit",
"title": "你没有足够的信用。",
"status": 601,
"detail": "你现在的余额是30，但是要花50。",
"instance": "/account/12345/msgs/abc"
}
前端步伐员拿到这串JSON数据进行处理就可以了。
ProblemDetails
SpringBoot中提供了一个类ProblemDetailsExceptionHandler，他会把错误信息转为RFC 7807规范并返回。
可以看到ProblemDetailsExceptionHandler是一个异常处理器
https://i-blog.csdnimg.cn/direct/4c87508184ae478b873d8fc37f64bd04.png
它会处理以下异常
https://i-blog.csdnimg.cn/direct/ec56c0717af943a5bf299b4c24384318.png
接下来我们就使用ProblemDetails处理异常，哀求方式异常也属于ProblemDetails处理的异常，我们就模拟改异常的发生。
ProblemDetails默认是不开启的，要想开启需要进行如下配置：
spring.mvc.problemdetails.enabled=true
编写一个控制器方法
@Controller
public class ProblemDetailsController {
@GetMapping("/testProblem")
@ResponseBody
public String testProblem(){
    return "hello";
   }
}
用POST方式访问该方法：
https://i-blog.csdnimg.cn/direct/4bff06d2ef29489584b7905b7186bbcc.png
原生镜像

JAVA语言的实行原理


[*] 计算机语言：
计算机能够直接实行的指令。这种指令和系统及硬件有关。
[*] 计算机高级语言：
在遵循语法的条件下，写一个文本文件，之后使用某种方式，把文本转换为计算机指令实行。
我们编写的都是计算机高级语言，而将计算机高级语言转为计算机语言运行，有两种方式：


[*] 动态解释(JIT)：解释实行，运行时翻译为机器码。（好比Python，也称为解释型语言）
https://i-blog.csdnimg.cn/direct/e4c36032dfd646d3aada3f2f6c57e2fa.png
[*] 静态编译(AOT)：步伐在实行前全部被翻译为机器码，可以直接运行二进制文件。（好比C++，也称为解释型语言）
https://i-blog.csdnimg.cn/direct/02b6ff87c7734028820c5615cdb5b27c.png
这两种方式各有优缺点，动态解释代码运行效率较低，但可以跨平台运行。
静态编译代码运行效率较高，但不能跨平台运行，而且编译代码比较浪费时间，调试成本高。
JAVA语言：先编译，后解释实行
https://i-blog.csdnimg.cn/direct/64dd44cfe519474a9bb27cfe9316fa6e.png
   注意，JVM并不是单纯依赖解释器解释假造指令，JVM中既有解释器，还有即时编译器。


[*] 解释器可以将字节码文件解释为机器指令，立即实行。
[*] 即时编译器可以将字节码文件编译为机器指令，存在内存中，编译完成后直接实行本地机器指令即可。
当Java假造器启动后，解释器首先发挥作用，不必期待即时编译器全部编译完成后再实行。随着时间的推移，编译器把越来越多的代码编译成本地代码，此时运行本地机器指令，获得更高的实行效率。
固然这种启动方式很良好，但他的启动照旧比AOT方式慢。在当前微服务、云原生盛行的时代，JAVA 步伐显得越来越痴肥，固然使用AOT也有诸多缺点，好比打包时间长、舍弃平台无关性、反射、动态代理的分析本领有限。但是JAVA必定会向AOT发展，否则在云原生时代，可以能被其他后起之秀慢慢蚕食市场。
Native Image 和 GraalVM

Native Image
Native Image(原生镜像)是一种将Java代码提前编译为二进制文件的技术，即本机可实行文件。在Windows中就是.exe文件，它脱离了Java步伐员运行时对JVM的依赖，运行时效率极高。
Spring推荐使用SpringBoot3+GraalVM官方构建工具实现原生镜像构建。
GraalVM
GraalVM是一个高性能跨语言假造机，其目的是提拔Java和其他使用JVM语言编写步伐的实行速度，同时也为JavaScript、Python和很多其他流行语言提供运行时环境。起始于2011年Oracle实验室的一个研究项目。
https://i-blog.csdnimg.cn/direct/0b5208edff3c4840847ee075bc07fa85.png
   GraalVM可以直接当做JVM使用，也可以对Java等多种语言实现静态编译，生成Java项目的原生镜像。
生成原生镜像

接下来我们就生成SpringBoot3项目的原生镜像：
1.安装GraalVM


[*]解压windows版的GraalVM
[*]配置环境变量JAVA_HOME和Path
2.创建SpringBoot项目
创建时的JDK肯定要选择GraalVM
https://i-blog.csdnimg.cn/direct/b5da2d2dfda04438a426d5cb0d4da37b.png
添加依赖时肯定要选择GraalVM
https://i-blog.csdnimg.cn/direct/0205ee836c8d4dd3aee095f96bb627a0.png
编写控制器
@Controller
public class HelloController {
@ResponseBody
@RequestMapping("/hello")
public String hello(){
    return "Hello Native Image";
   }
}
3.通过安装VisualStudio安装C++开发环境，固然GraalVM可以生成原生镜像，但底层是调用C++的方式生成的.exe可实行文件。
https://i-blog.csdnimg.cn/direct/7633608d1ab5411dac2d38d1834d0c41.png
https://i-blog.csdnimg.cn/direct/7b409db1d796462fa168008c1c1275ef.png
4.使用maven将SpringBoot项目打包成可实行文件
https://i-blog.csdnimg.cn/direct/117260d003b64d8c9b42730b8f3e32fa.png
生成Linux原生镜像

1.准备Linux假造机，连接假造机
2.安装C++开发环境
yum install -y gcc glibc-devel zlib-devel
3.安装GraalVM
# 创建空文件夹
mkdir -p /usr/local/java

# 进入文件夹
cd /usr/local/java

# 上传GraalVM到Linux虚拟机

# 解压GraalVM
tar -zxvf graalvm-jdk-17_linux-x64_bin.tar.gz
4.配置GraalVM环境变量
# 打开环境变量配置文件
vim/etc/profile

# 添加如下内容
export JAVA_HOME=/usr/local/java/graalvm-jdk-17.0.8+9.1
export PATH=$PATH:$JAVA_HOME/bin

# 使环境变量生效
source /etc/profile

# 查看Java版本
java -version
如果Java版本没有改动，卸载掉Linux系统自带的JDK即可：
# 查看系统自带的Java
rpm -qa|grep java

# 卸载JAVA
rpm -e --nodeps java版本
5.安装Maven
# 创建空文件夹
mkdir -p /usr/local/maven

# 进入文件夹
cd /usr/local/maven

# 上传Maven到Linux虚拟机

# 解压Maven
tar -xvf apache-maven-3.8.8-bin.tar.gz
6.配置Maven环境变量
# 打开环境变量配置文件
vim/etc/profile

# 添加如下内容
export M2_HOME=/usr/local/maven/apache-maven-3.8.8
export PATH=$PATH:$M2_HOME/bin

# 使环境变量生效
source /etc/profile

# 查看Maven版本
mvn -version
7.修改SpringBoot项目pom文件
<!-- 添加如下内容，使maven给项目打包时生成原生镜像 -->
<profiles>
<profile>
    <id>native</id>
    <properties>
      <repackage.classifier>exec</repackage.classifier>
      <native-buildtools.version>0.9.13</native-buildtools.version>
    </properties>
    <build>
      <plugins>
      <plugin>
          <groupId>org.graalvm.buildtools</groupId>
          <artifactId>native-maven-plugin</artifactId>
          <extensions>true</extensions>
          <executions>
            <execution>
            <id>build-native</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
            </execution>
          </executions>
      </plugin>
      </plugins>
    </build>
</profile>
</profiles>
8.把项目压缩成zip文件
9.把项目的压缩文件上传到假造机上
10解压项目
# 安装unzip
yum install unzip
# 解压项目
upzip springbootdemo10.zip
10.进入项目，实行mvn clean package -DskipTests -Pnative，生成原生镜像
如果我的内容对你有资助，请点赞，批评，收藏。创作不易，各人的支持就是我对峙下去的动力
https://img-blog.csdnimg.cn/direct/858a8fb61850410ba0cc528f25da33ae.jpeg

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

查看完整版本: SpringBoot（看这一篇就够了）