Spring Boot 2.x基础教程

Spring Boot 2.x基础教程

  • 一、简介
    • 1. Spring Boot 2.x 简介
    • 2. Spring Boot 2.x 特点
    • 3. Spring Boot 2.x 与 Spring Framework 的关系
  • 二、Spring Boot 2.x 环境搭建
    • 1. JDK环境安装与配置
    • 2. Maven环境安装与配置
    • 3. Spring Boot 2.x 项目创建
  • 三、核心功能
    • 1. 配置文件及其加载顺序
      • a. YAML 文件格式
      • b. 属性配置文件( .properties )
    • 2. 日志管理
      • a. Spring Boot 日志框架选用
      • b. 自定义日志
    • 3. Spring Boot 2 热部署实现
      • a. devtools的引入
      • b. 使用方法与注意事项
    • 4. Spring Boot 2.x 中的 AOP
      • a. 切面的定义和使用
  • 四、数据访问
    • 1. Spring Boot 2.x 与 JPA
      • a. JPA简介
      • b. Spring Boot 2.x 使用JPA基本配置
    • 2. Spring Boot 2.x 与 MyBatis
      • a. MyBatis 简介
      • b. Spring Boot 2.x 整合 MyBatis
    • 3. Spring Boot 2.x 与 Druid 数据源
      • a. Druid 简介
      • b. Spring Boot 2.x 整合 Druid
  • 五、Spring Boot 2.x 与 Web
    • 1. Spring Boot 2.x Web 封装
      • a. Spring Boot 自带web应用服务器
      • b. 四种常见的响应方式
        • 1. 返回 Model 层数据
        • 2. 直接返回字符串
        • 3. 返回 JSON 数据
        • 4. 返回 HTTP 状态码
    • 2. Spring Boot 2.x 与 JSP
      • a. JSP 简介
      • b. Spring Boot 2.x使用JSP
    • 3. Spring Boot 2.x 静态资源处理
      • a. 静态资源访问
  • 六、Spring Boot 2.x 高级特性
    • 1. Spring Boot 2.x Actuator 扩展
      • a. actuator 的作用
      • b. actuator 的使用方法
    • 2. Spring Boot 2.x 多环境配置
      • a. 执行环境分类
      • b. 配置文件的优先级
    • 3. Spring Boot 2.x 集成 Quartz
      • a. Quartz 的简介
      • b. Spring Boot 2.x 集成 Quartz

一、简介

1. Spring Boot 2.x 简介

Spring Boot是一个基于Spring框架的快速Web开发框架,采用约定大于配置的方式进行构建。简化了Spring应用程序的开发过程,并持续推出新的版本以满足当下开发的需要。

2. Spring Boot 2.x 特点

  • 简化Spring应用程序开发流程
  • 自动配置Spring应用程序
  • 内嵌Servlet容器,无需部署war包
  • 提供管理端点,便于监控应用程序运行状况
  • 支持各类组件的集成,如ORM、模板引擎等

3. Spring Boot 2.x 与 Spring Framework 的关系

Spring Boot是构建在Spring Framework之上的框架。其中,Spring Framework提供了基础的IoC、AOP、事件、数据访问、Web框架和测试等支持;而Spring Boot则对Spring Framework进行了封装,进一步简化了Spring应用程序的构建。

二、Spring Boot 2.x 环境搭建

1. JDK环境安装与配置

首先,需要安装Java Development Kit(JDK)。可以通过Oracle官网下载并安装最新版的JDK,然后在环境变量中配置JDK的安装路径。

     <dependency>
         <groupId>org.springframework.bootgroupId>
         <artifactId>spring-boot-starter-webartifactId>
         <version>2.5.0version>
     dependency>

2. Maven环境安装与配置

接下来,需要安装Maven。可以通过Apache官网下载并安装最新版的Maven,然后在环境变量中配置Maven的安装路径。

3. Spring Boot 2.x 项目创建

最后可以使用Spring Initializr创建Spring Boot项目。在Spring Initializr的官网(https://start.spring.io/)中,选择需要的项目配置和依赖项,然后点“生成”即可。生成的项目包含了基础的Spring Boot配置和依赖项,可以直接用于开发。

三、核心功能

1. 配置文件及其加载顺序

a. YAML 文件格式

# YAML配置文件示例
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: test

注释:通过YAML文件配置serverspring的相关属性,其中datasource为数据库连接属性配置。

b. 属性配置文件( .properties )

# .properties配置文件示例
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=test

注释:通过.properties配置文件配置serverspring的相关属性,其中datasource为数据库连接属性配置。

2. 日志管理

a. Spring Boot 日志框架选用

Spring Boot默认采用logback进行日志输出,你也可以切换为其他日志框架,比如Log4j2或者JUL等。

b. 自定义日志

使用Slf4j来封装日志内容,并搭配对应的日志框架进行输出。

// 引入Slf4j
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserService {

    public void login(String username, String password) {
        log.info("用户{}正在登录...", username);
        // do something
    }
}

注释:使用@Slf4j注解引入Slf4j日志封装,在需要输出日志的地方使用log.info等方法进行输出。

3. Spring Boot 2 热部署实现

a. devtools的引入

使用devtools可以实现Spring Boot项目的热部署功能,可以在开发阶段提高调试效率。


<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-devtoolsartifactId>
   <optional>trueoptional>
dependency>

注释:通过Maven引入devtools依赖。

b. 使用方法与注意事项

在配置文件中加入如下属性:

# 配置热部署属性
spring.devtools.restart.enabled=true
spring.devtools.restart.exclude=static/**,public/**

注意事项:在使用时,需要手动编译一次代码才能生效。

4. Spring Boot 2.x 中的 AOP

a. 切面的定义和使用

使用@Aspect注解定义切面类,使用@Before@After@Around等注解来定义不同类型的通知,并通过@Pointcut注解定义切点。如下:

// 定义切面类
@Aspect
@Service
@Slf4j
public class LogAspect {

    // 定义切点
    @Pointcut("execution(* com.example.demo.service..*.*(..))")
    public void point() {}

    // 定义前置通知
    @Before("point()")
    public void before() {
        log.info("before aspect.");
    }

    // 定义后置通知
    @After("point()")
    public void after() {
        log.info("after aspect.");
    }

    // 定义环绕通知
    @Around("point()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("before around aspect.");
        Object obj = joinPoint.proceed();
        log.info("after around aspect.");
        return obj;
    }
}

使用切面:

@Service
@Slf4j
public class UserService {

    @Autowired
    private UserDao userDao;

    // 使用切面
    @LogAspect
    public void login(String username, String password) {
        log.info("用户{}正在登录...", username);
        // do something
    }
}

注释:使用@Aspect注解定义切面类,通过@Pointcut注解定义切点,使用@Before@After@Around等注解来定义不同类型的通知,在需要使用切面的方法上加上自定义的注解即可。

四、数据访问

1. Spring Boot 2.x 与 JPA

a. JPA简介

JPA是 Java Persistence API 的缩写,是一套ORM规范,为开发者提供了一个简单优雅的方式来管理Java应用中的关系型数据。

b. Spring Boot 2.x 使用JPA基本配置

在Spring Boot项目中使用JPA,需要添加以下依赖:


<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>

同时在配置文件中进行数据库配置:

# jpa 数据库配置
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=test
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect

注释:通过Maven引入spring-boot-starter-data-jpa依赖,并在配置文件中进行数据库配置。

2. Spring Boot 2.x 与 MyBatis

a. MyBatis 简介

MyBatis是一种持久层ORM框架,它对JDBC的操作数据库的过程进行封装,提供了更加简单、易读、易维护的方式。

b. Spring Boot 2.x 整合 MyBatis

在Spring Boot项目中整合MyBatis,需要添加以下依赖:


<dependency>
   <groupId>org.mybatis.spring.bootgroupId>
   <artifactId>mybatis-spring-boot-starterartifactId>
   <version>2.1.3version>
dependency>

同时在配置文件中进行数据库配置:

# MyBatis及数据库配置
# MyBatis的mapper文件的路径 
mybatis.mapper-locations=classpath:mapper/*.xml
# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=test

注释:通过Maven引入mybatis-spring-boot-starter依赖,并在配置文件中进行数据库配置。

3. Spring Boot 2.x 与 Druid 数据源

a. Druid 简介

Druid 是阿里开源平台上一个数据库连接池实现,结合了 C3P0、DBCP 等 DB 连接池的优点,同时加入了日志监控。

b. Spring Boot 2.x 整合 Druid

在Spring Boot项目中整合Druid,需要添加以下依赖:


<dependency>
   <groupId>com.alibabagroupId>
   <artifactId>druid-spring-boot-starterartifactId>
   <version>1.2.5version>
dependency>

同时在配置文件中进行数据库配置:

# druid 数据库配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=test

# druid 配置
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.filters=stat,wall

注释:通过Maven引入druid-spring-boot-starter依赖,并在配置文件中进行数据库配置。

五、Spring Boot 2.x 与 Web

1. Spring Boot 2.x Web 封装

a. Spring Boot 自带web应用服务器

Spring Boot 默认会使用嵌入式 Tomcat 作为Web 应用服务器,而无需外部部署。当然,你也可以使用 Jetty 或 Undertow 作为替代品。

b. 四种常见的响应方式

在Spring Boot中通常会有以下4种常见的响应方式:

1. 返回 Model 层数据

@GetMapping("/model")
public String model(Model model) {
    model.addAttribute("name", "John");
    return "hello";
}

上面代码中,我们将Model对象中的属性"name"设置为"John",然后返回一个名为"hello"的模板。Spring Boot 会自动根据模板渲染出相应的HTML。

2. 直接返回字符串

@GetMapping("/response")
@ResponseBody
public String response() {
    return "Hello World!";
}

上面代码中,我们直接返回一个字符串"Hello World!",Spring Boot 会将其转化为HTTP Response输出到客户端。

3. 返回 JSON 数据

@GetMapping("/json")
@ResponseBody
public Map<String, Object> json() {
    Map<String, Object> map = new HashMap<>();
    map.put("name", "John");
    map.put("age", 30);
    map.put("gender", "Male");
    return map;
}

上面代码中,我们返回一个Map类型的JSON数据,其中包含三个属性:name、age 和 gender。

4. 返回 HTTP 状态码

@GetMapping("/status")
public ResponseEntity<String> status() {
    return new ResponseEntity<>("Hello World!", HttpStatus.OK);
}

上面代码中,我们返回一个HTTP OK状态并携带"Hello World!"的字符串。

2. Spring Boot 2.x 与 JSP

a. JSP 简介

JSP(Java Server Pages)是一种在HTML(或XML)文档中嵌入Java代码的技术。它是Servlet API之上的一种封装,可用于开发动态Web页面。
JSP 允许您在 HTML 页面中嵌入 Java 代码,这样您就能够在页面显示动态内容。

b. Spring Boot 2.x使用JSP

首先在工程的pom.xml里添加对jsp 支持及Tomcat Embed Jasper 的依赖:

<dependency>
    <groupId>org.apache.tomcat.embedgroupId>
    <artifactId>tomcat-embed-jasperartifactId>
    <scope>providedscope>
dependency>

<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>jstlartifactId>
dependency>

在application.properties里添加以下配置:

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

创建 JSP 文件(/src/main/webapp/WEB-INF/jsp/hello.jsp):


<html>
<head>
    <meta charset="UTF-8">
    <title>Hello JSPtitle>
head>
<body>
    <h1>Hello, <%= request.getAttribute("name") %>!h1>
body>
html>

添加Controller代码:

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("name", "John");
        return "hello";
    }

}

访问 http://localhost:8080/hello 就可以了。

3. Spring Boot 2.x 静态资源处理

a. 静态资源访问

Spring Boot 2.x默认会在如下路径中查找静态资源:

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/

例如,你可以在src/main/resources/static/目录下创建一个名为logo.png的图片文件,并通过URL http://localhost:8080/logo.png访问它。

六、Spring Boot 2.x 高级特性

1. Spring Boot 2.x Actuator 扩展

a. actuator 的作用

Actuator 用于监控和管理 Spring Boot 应用程序,它提供了很多用于检查应用程序运行状况的功能,包括应用程序健康状况、指标收集和暴露、日志配置等功能。

b. actuator 的使用方法

  1. 在pom.xml中引入 actuator的依赖:

    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>
    
  2. 在application.properties文件中开启或关闭 Actuator 功能:

    management.endpoint.health.show-details=always
    

    以上示例表示开启健康状况检查功能,并显示详细信息。

  3. 访问以下 URL 查看 Actuator 的功能列表:

    http://localhost:8080/actuator
    

2. Spring Boot 2.x 多环境配置

a. 执行环境分类

Spring Boot 环境定义有以下 4 种:

  • development
  • testing
  • staging
  • production

b. 配置文件的优先级

Spring Boot 支持多个 profile 的配置文件,文件名必须以 application-{profile}.properties 命名,其中 profile 可以是上述环境分类之一。

当存在多个 profile 时,配置文件的优先级由高到低如下:

  1. application-{profile}.yml
  2. application-{profile}.properties
  3. application.yml
  4. application.properties

3. Spring Boot 2.x 集成 Quartz

a. Quartz 的简介

Quartz 是一个功能强大的作业调度框架,可用于创建简单或复杂的定时任务,支持集群和分布式部署。

b. Spring Boot 2.x 集成 Quartz

  1. 在pom.xml中引入 quartz 和 quartz-jobs 的依赖:

    <dependency>
       <groupId>org.quartz-schedulergroupId>
       <artifactId>quartzartifactId>
       <version>2.3.1version>
    dependency>
    <dependency>
       <groupId>org.quartz-schedulergroupId>
       <artifactId>quartz-jobsartifactId>
       <version>2.3.1version>
    dependency>
    
  2. 在application.properties文件中配置 Quartz:

    # Quartz 配置
    spring.quartz.job-store-type=jdbc
    spring.quartz.jdbc.initialize-schema=always
    spring.quartz.properties.org.quartz.threadPool.threadCount=10
    
  3. 创建 Job 类:

    @Component
    public class MyJob implements Job {
    
       @Override
       public void execute(JobExecutionContext context) throws JobExecutionException {
          // 需要执行的任务逻辑
       }
       
    }
    
  4. 创建 JobDetail 和 Trigger,并将它们注册到 Scheduler 中:

    @Configuration
    public class QuartzConfig {
    
       @Autowired
       private MyJob myJob;
    
       @Bean
       public JobDetail jobDetail() {
          return JobBuilder.newJob(myJob.getClass())
             .withIdentity("myJob")
             .storeDurably()
             .build();
       }
    
       @Bean
       public Trigger trigger(JobDetail job) {
          return TriggerBuilder.newTrigger()
             .forJob(job)
             .withIdentity("myJobTrigger")
             .withSchedule(CronScheduleBuilder.cronSchedule("0 0 12 * * ?"))
             .build();
       }
    
       @Bean
       public Scheduler scheduler(Trigger trigger, JobDetail job, DataSource dataSource) throws SchedulerException {
          SchedulerFactory schedulerFactory = new StdSchedulerFactory();
          Scheduler scheduler = schedulerFactory.getScheduler();
          scheduler.setDataSource(dataSource);
          scheduler.scheduleJob(job, trigger);
          return scheduler;
       }
       
    }
    

你可能感兴趣的:(Java实践,java,架构,数据结构,分布式,spring,boot)