Spring Boot微服务实战入门教程

2024/10/30 6:03:11

本文主要是介绍Spring Boot微服务实战入门教程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

概述

本文将详细介绍如何使用Spring Boot构建微服务架构，从Spring Boot框架的介绍到微服务的实际应用，涵盖服务注册与发现、负载均衡、数据库连接等多个方面，帮助读者全面掌握Spring Boot微服务实战。

引入Spring Boot微服务

微服务的基本概念

微服务架构是一种将应用程序拆分为多个小型服务的方式，每个服务运行在自己的进程中，并专注于一个特定的业务功能。每个服务通常负责提供一个小范围的功能，并通过HTTP或消息传递等方式与其它服务进行通信。相比传统的单体应用，微服务架构为开发、测试、部署、扩展和维护带来了显著的优势，但也带来了服务间的通信、服务发现、分布式配置、负载均衡和容错等新的挑战。

微服务架构的核心原则包括：

服务独立性：每个微服务管理自己的数据存储，并且可以使用不同的编程语言和技术栈。
服务自治：每个服务都有独立的生命周期，可以独立部署和扩展。
松耦合：服务之间通过定义好的API进行通信，保持松耦合关系。
弹性部署：支持灵活的部署策略，能够根据业务需求快速部署新版本或滚动更新。
容错与自我修复：采用容错机制和自我修复策略来提高系统的可用性。

Spring Boot框架简介

Spring Boot 是由Spring团队提供的一个框架，旨在简化Spring应用的初始搭建及开发过程。通过约定优于配置的策略来减少代码量，同时提供了大量的自动配置功能，使得开发者可以专注于业务逻辑的实现而无需过多关注底层配置。

特点

自动化配置：Spring Boot通过约定优于配置的方式，自动配置了许多常见的场景，例如数据库连接、视图解析器、静态资源映射等。
依赖管理：通过引入父工程与BOM（Bill of Materials）文件，Spring Boot能够自动管理项目的依赖，避免了版本冲突。
嵌入式容器：支持内嵌Tomcat、Jetty和Undertow等应用服务器，简化了部署过程。
健康监控：提供了多种监控和健康检查工具，便于开发和运维人员监控应用状况。
命令行接口：允许通过命令行执行应用的打包、运行、测试等操作。
集成测试：提供了集成测试支持，便于开发人员编写自动化测试。

Spring Boot与微服务的关系

Spring Boot 是实现微服务架构的理想选择，它不仅提供了丰富的自动配置功能，还集成了许多其他微服务相关的功能，如服务发现、负载均衡、服务网关等。Spring Boot 与 Spring Cloud 框架结合使用时，能够轻松地构建出具备高可用性、可扩展性的微服务应用。

关系概述

服务化：Spring Boot 可以轻松地将一个大应用拆分为多个小型服务，每个服务专注于单一职责。
配置简化：Spring Boot 的自动化配置特性减少了每个微服务的配置工作量。
依赖管理：Spring Boot 简化了依赖管理，使得开发者可以专注于业务逻辑的实现。
服务治理：通过Spring Cloud，可以实现服务的注册与发现、负载均衡、断路器等功能。
监控与日志：Spring Boot 提供了丰富的监控和日志功能，便于运维人员实时了解应用的状态。
部署与扩展：Spring Boot 支持多种部署方式，包括单体应用和微服务，灵活应对不同的部署场景。

创建第一个Spring Boot微服务应用

环境搭建

前提条件

在开始之前，请确保安装了以下工具：

JDK：Java开发工具包，建议使用JDK 1.8及以上版本。
IDE：集成开发环境，如IntelliJ IDEA 或 Eclipse。
Maven 或 Gradle：构建工具，用于项目依赖管理。
Git：版本控制系统，用于代码版本管理。
Docker（可选）：容器化工具，用于服务部署。

示例环境配置

安装Java：

sudo apt update
sudo apt install openjdk-11-jdk

安装Maven：
```
sudo apt-get install maven
```
安装Docker（可选）：
```
sudo apt-get install docker.io
```

示例代码

确认环境搭建成功后，可以通过以下命令检查环境是否正确安装：

java -version
mvn -version
docker --version

使用Spring Initializr创建项目

创建Spring Boot项目

首先，打开浏览器访问Spring Initializr（https://start.spring.io/），点击“Generate”按钮来创建一个新的Spring Boot项目。

选择 Project：选择Maven Project。
选择 Language：Java。
选择 Spring Boot：选择相应的版本，建议选择最新稳定版本。
选择 Packaging：选择jar（如果需要部署为war包，可以选择war）。
选择 Java Version：选择1.8+版本。
选择 Dependencies：选择Web、Actuator等依赖。

点击“Generate”按钮，下载生成的压缩包。

解压下载的文件：
```
unzip <下载的项目名>.zip
```
导入项目：
将解压后的文件夹导入到IDE中，例如在IntelliJ IDEA中，选择File -> Open，然后选择解压后的项目文件夹。

示例代码

如果手动创建项目，可以参考以下步骤：

创建一个Maven项目结构：

my-first-service/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myfirstservice/
│   │   │               └── MyFirstServiceApplication.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── myfirstservice/
│                       └── MyFirstServiceApplicationTests.java
└── pom.xml

编辑pom.xml文件：

<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>
   <groupId>com.example</groupId>
   <artifactId>myfirstservice</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.1</version>
       <relativePath/> <!-- lookup parent from repository -->
   </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-actuator</artifactId>
       </dependency>
   </dependencies>
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
</project>

编写启动类：

package com.example.myfirstservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyFirstServiceApplication {
   public static void main(String[] args) {
       SpringApplication.run(MyFirstServiceApplication.class, args);
   }
}

编写简单的RESTful服务

RESTful服务的概念

RESTful服务是一种基于HTTP协议的Web服务风格，它将服务的交互方式简化为HTTP的CRUD操作。RESTful服务定义了资源的URL路径、HTTP方法（GET、POST、PUT、DELETE等）以及数据的格式。

创建RESTful服务

下面将创建一个简单的RESTful服务，提供一个/greetings的GET接口，返回一个欢迎消息。

创建控制器：
在com.example.myfirstservice包下创建一个名为GreetingController的类，该类将处理HTTP请求。

package com.example.myfirstservice;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

   @GetMapping("/greetings")
   public String hello() {
       return "Hello from Spring Boot!";
   }
}

测试服务：
在IDE中运行MyFirstServiceApplication类，启动Spring Boot应用。然后打开浏览器，访问http://localhost:8080/greetings，你应该能看到返回的消息“Hello from Spring Boot!”。

示例代码

以下是完整的控制器类代码：

package com.example.myfirstservice;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {
    @GetMapping("/greetings")
    public String hello() {
        return "Hello from Spring Boot!";
    }
}

微服务的常用依赖管理

使用Maven或Gradle管理依赖

Maven与Gradle简介

Maven：一个项目管理和构建工具，基于项目对象模型（POM），设计用于简化项目构建过程。
Gradle：一个基于Groovy语言的开源项目自动化构建工具，能够简化构建、测试和部署应用程序的过程。

Mvn与Gradle的区别

特性	Maven	Gradle
构建脚本	XML格式的POM文件	Groovy或Kotlin脚本，更灵活
性能	较慢，尤其是处理大型项目	更快，得益于其缓存机制
生态系统	比较成熟，有广泛的插件支持	生态系统仍在发展，但也有许多可用插件
学习曲线	较陡峭，需要理解POM文件的结构和依赖管理	语法更简单，但需要学习Groovy或Kotlin
可定制性	较低，因为XML配置的灵活性较低	高，Groovy和Kotlin允许更复杂的自定义构建逻辑
社区与支持	非常活跃，有庞大的用户基础，支持广泛	社区和文档仍在发展中，但支持也很好

如何在Spring Boot中使用Maven和Gradle

Maven使用示例

<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>
    <groupId>com.example</groupId>
    <artifactId>myfirstservice</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</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-actuator</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </build>
</project>

Gradle使用示例

plugins {
    id 'org.springframework.boot' version '2.7.1'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

配置文件详解

application.properties

application.properties 文件用于定义Spring Boot的各种属性，如数据库连接、日志级别、应用端口等。

# Server properties
server.port=8080
spring.application.name=my-first-service

# Application properties
logging.level.root=INFO

application.yml

application.yml 文件是另一种配置文件格式，它使用YAML语法，通常被认为更简洁和易读。

server:
  port: 8080
spring:
  application:
   name: my-first-service
logging:
  level:
   root: INFO

示例代码

以下是一个application.properties文件的示例：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

环境变量覆盖

配置文件中的属性值也可以通过环境变量来覆盖。例如，可以在application.properties中定义端口号，然后通过环境变量SERVER_PORT来覆盖它。

server.port=${SERVER_PORT:8080}

在命令行中使用SERVER_PORT环境变量：

export SERVER_PORT=8081

服务注册与发现

使用Spring Cloud Eureka实现服务注册与发现

服务注册与发现的原理

服务注册与发现是微服务架构中的重要组成部分，通过服务注册，服务实例可以向注册中心注册自己的位置信息；通过服务发现，其他服务可以通过服务注册中心查询服务实例的位置信息，并建立连接。

Eureka注册中心

Eureka是Netflix开源的一个基于REST的服务注册与发现框架，主要应用于构建微服务架构中的服务注册与发现机制。Eureka支持服务器端与客户端分离的设计，Eureka Server作为服务注册中心，用于存储服务实例的信息；Eureka Client则负责将服务实例注册到Eureka Server，并通过心跳机制维护服务实例的可用性。

部署Eureka Server

创建新的Spring Boot项目：使用Spring Initializr创建一个新的Spring Boot项目，添加spring-boot-starter-actuator、spring-cloud-starter-netflix-eureka-server依赖。

配置application.yml文件：

server:
 port: 8761
eureka:
 instance:
   hostname: localhost
 client:
   register-with-eureka: false
   fetch-registry: false
   service-url:
     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

编写启动类：

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
   public static void main(String[] args) {
       SpringApplication.run(EurekaServerApplication.class, args);
   }
}

启动服务：
运行EurekaServerApplication启动类，访问http://localhost:8761，可以看到Eureka Server的管理控制台。

Eureka Client注册服务实例

创建新的Spring Boot项目：使用Spring Initializr创建一个新的Spring Boot项目，添加spring-boot-starter-actuator、spring-cloud-starter-netflix-eureka-client依赖。

配置application.yml文件：

server:
 port: 8081
spring:
 application:
   name: my-first-service
 cloud:
   eureka:
     instance:
       hostname: localhost
     client:
       service-url:
         defaultZone: http://localhost:8761/eureka/

编写启动类：

package com.example.myfirstservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class MyFirstServiceApplication {
   public static void main(String[] args) {
       SpringApplication.run(MyFirstServiceApplication.class, args);
   }
}

启动服务：
运行MyFirstServiceApplication启动类，访问Eureka Server的管理控制台，可以看到my-first-service服务实例已经成功注册。

客户端与服务端的交互

服务注册后，服务端（Eureka Server）会维护服务实例的状态，客户端（Eureka Client）通过服务注册中心获取服务实例的位置信息，进行服务调用。Eureka Client会定期向Eureka Server发送心跳，以保持服务实例的可用性。

Eureka Client具有以下功能：

注册服务实例：向Eureka Server发送服务实例的注册请求。
心跳机制：通过定期发送心跳来维护服务实例的状态。
服务发现：通过Eureka Server获取其他服务实例的注册信息，并建立连接。
服务下线：当服务实例停止运行时，Eureka Client会发送下线请求，Eureka Server会删除服务实例的注册信息。

示例代码

以下是完整的Eureka Client的application.yml配置文件：

server:
  port: 8081
spring:
  application:
   name: my-first-service
cloud:
  eureka:
    instance:
      hostname: localhost
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka/

服务治理与负载均衡

使用Spring Cloud LoadBalancer实现负载均衡

负载均衡的基本概念

负载均衡是一种将请求分发到多个服务实例中的技术，通过负载均衡技术可以有效地提高系统的吞吐量、减少延迟、提高系统的可用性和可靠性。

Spring Cloud LoadBalancer的原理

Spring Cloud LoadBalancer 是一个用于实现客户端负载均衡的组件，它允许在客户端直接进行负载均衡而无需通过中间的负载均衡器。Spring Cloud LoadBalancer 与服务发现组件（如Eureka）配合使用，可以根据预先定义的策略（如轮询、随机、最少连接等）自动将请求分发到不同的服务实例上。

配置LoadBalancer

添加依赖：
在Spring Boot项目的pom.xml或build.gradle文件中添加spring-cloud-starter-loadbalancer依赖。

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

implementation 'org.springframework.cloud:spring-cloud-starter-loadbalancer'

配置负载均衡策略：
可以在application.yml或application.properties中设置负载均衡策略，例如使用轮询策略。

spring:
 cloud:
   loadbalancer:
     discovery:
       enabled: true
       client:
         load-balancer:
           rule: round-robin

使用@LoadBalanced注解：
在需要使用负载均衡服务的客户端上，使用@LoadBalanced注解创建RestTemplate或WebClient实例。

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {
   @Bean
   @LoadBalanced
   public RestTemplate restTemplate() {
       return new RestTemplate();
   }
}

示例代码

下面是一个完整的示例，演示如何在服务中使用负载均衡：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class LoadBalancerController {

    @Autowired
    private LoadBalancerClient lbClient;
    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/loadbalance")
    public String loadBalance() {
        // 使用负载均衡客户端获取服务实例
        ServiceInstance serviceInstance = lbClient.choose("my-first-service");
        String serviceUrl = serviceInstance.getUri().toString();
        // 使用RestTemplate发起请求
        return restTemplate.getForObject(serviceUrl + "/greetings", String.class);
    }
}

实战：服务降级与熔断

服务降级与熔断是微服务架构中的重要概念，它们可以提高系统的容错能力，避免在某个服务出现故障时影响整个系统。

服务降级

服务降级是指在服务出现异常时，主动断开服务调用，返回一个预定义的结果，避免异常链路影响整个系统。

熔断机制

熔断机制是一种容错机制，它在微服务之间添加一层保护，当服务调用失败率达到预设条件时，直接返回错误信息，停止调用服务，避免雪崩效应。

实现服务降级与熔断

添加依赖：
在Spring Boot项目的pom.xml或build.gradle文件中添加spring-cloud-starter-resilience4j依赖。

<dependency>
   <groupId>io.github.resilience4j</groupId>
   <artifactId>spring-cloud-starter-resilience4j</artifactId>
</dependency>

implementation 'io.github.resilience4j:spring-cloud-starter-resilience4j'

配置熔断器：
在application.yml中配置熔断器规则。

spring:
 cloud:
   resilience4j:
     circuitbreaker:
       instances:
         my-first-service:
           fallbackProvider: true
           failureRateThreshold: 50
           slidingWindowSize: 10
           minimumNumberOfCalls: 5
           permittedNumberOfCallsInHalfOpenState: 2
           waitDurationInHalfOpenState: 10000

使用@CircuitBreaker注解：
在需要进行熔断操作的方法上使用@CircuitBreaker注解。

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class CircuitBreakerController {

   @Autowired
   private RestTemplate restTemplate;

   @GetMapping("/circuitbreaker")
   @CircuitBreaker(name = "my-first-service", fallbackMethod = "fallback")
   public String circuitBreaker() {
       // 调用远程服务
       return restTemplate.getForObject("http://my-first-service/greetings", String.class);
   }

   // 服务降级方法
   public String fallback() {
       return "Service is down, please try again later.";
   }
}

示例代码

以下是完整的CircuitBreakerController类：

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class CircuitBreakerController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/circuitbreaker")
    @CircuitBreaker(name = "my-first-service", fallbackMethod = "fallback")
    public String circuitBreaker() {
        // 调用远程服务
        return restTemplate.getForObject("http://my-first-service/greetings", String.class);
    }

    // 服务降级方法
    public String fallback() {
        return "Service is down, please try again later.";
    }
}

微服务的持久化存储

使用Spring Data JPA连接数据库

Spring Data JPA简介

Spring Data JPA 是Spring Data项目的一部分，它提供了一套用于操作JPA的工具，包括数据访问对象（DAO）的创建、查询的执行以及数据的持久化等功能。Spring Data JPA 消除了大量样板代码，使得开发人员可以更专注于业务逻辑的实现。

配置JPA

添加依赖：
在Spring Boot项目的pom.xml或build.gradle文件中添加spring-boot-starter-data-jpa依赖。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

数据库连接配置：
在application.yml或application.properties文件中配置数据库连接信息。

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/mydb
   username: root
   password: root
   driver-class-name: com.mysql.cj.jdbc.Driver
 jpa:
   hibernate:
     ddl-auto: update
   show-sql: true
   properties:
     hibernate:
       dialect: org.hibernate.dialect.MySQL5InnoDBDialect

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

编写实体类：
创建一个简单的实体类，例如User类。

package com.example.myfirstservice.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

编写Repository接口：
创建一个继承自JpaRepository接口的Repository接口，用于定义对User实体的操作方法。

package com.example.myfirstservice.repository;

import com.example.myfirstservice.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {}

编写Service类：
创建一个Service类，用于调用Repository接口的方法。

package com.example.myfirstservice.service;

import com.example.myfirstservice.model.User;
import com.example.myfirstservice.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
   @Autowired
   private UserRepository userRepository;

   public User getUserById(Long id) {
       return userRepository.findById(id).orElse(null);
   }
}

编写Controller类：
创建一个Controller类，用于提供RESTful API。

package com.example.myfirstservice.controller;

import com.example.myfirstservice.model.User;
import com.example.myfirstservice.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

   @Autowired
   private UserService userService;

   @GetMapping("/users/{id}")
   public User getUserById(@PathVariable Long id) {
       return userService.getUserById(id);
   }
}

示例代码

下面是完整的User实体类代码：

package com.example.myfirstservice.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

数据库连接配置与事务管理

数据库连接配置

数据库连接配置通常在application.yml或application.properties文件中完成。例如：

spring:
  datasource:
   url: jdbc:mysql://localhost:3306/mydb
   username: root
   password: root
   driver-class-name: com.mysql.cj.jdbc.Driver
 jpa:
   hibernate:
      ddl-auto: update
   show-sql: true
   properties:
      hibernate:
         dialect: org.hibernate.dialect.MySQL5InnoDBDialect

事务管理

Spring Data JPA 默认使用Spring的事务管理机制。通常，事务管理配置在application.yml或application.properties文件中，例如：

spring:
  jpa:
   properties:
      hibernate:
         default_batch_fetch_size: 10
         default_entity_graph_fetch_depth: 1
         default_batch_size: 10
         show_sql: true
         format_sql: true
         dialect: org.hibernate.dialect.MySQL5InnoDBDialect

Spring支持多种事务管理策略，如@Transactional注解，通常用于标记需要事务控制的方法：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public User addUser(User user) {
        return userRepository.save(user);
    }
}

示例代码

下面是一个简单的事务管理示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public User addUser(User user) {
        return userRepository.save(user);
    }
}

以上是使用Spring Data JPA连接数据库的基本步骤，通过具体的示例代码，可以更好地理解和应用这些概念。

这篇关于Spring Boot微服务实战入门教程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Spring Boot微服务实战入门教程

特点

关系概述

前提条件

示例环境配置

示例代码

创建Spring Boot项目

示例代码

RESTful服务的概念

创建RESTful服务

示例代码

Maven与Gradle简介

Mvn与Gradle的区别

如何在Spring Boot中使用Maven和Gradle

Maven使用示例

Gradle使用示例

配置文件详解

application.properties

application.yml

示例代码

环境变量覆盖

服务注册与发现的原理

Eureka注册中心

部署Eureka Server

Eureka Client注册服务实例

客户端与服务端的交互

示例代码

负载均衡的基本概念

Spring Cloud LoadBalancer的原理

配置LoadBalancer

示例代码

实战：服务降级与熔断

服务降级

熔断机制

实现服务降级与熔断

示例代码

Spring Data JPA简介

配置JPA

示例代码

数据库连接配置与事务管理

数据库连接配置

事务管理

示例代码

相关编程文章