标签 spring 下的文章

2024-09-03

Spring Data JPA 和 MyBatisPlus 都是Java持久层框架，但它们有不同的设计和特点。

Spring Data JPA:

使用JPA标准操作数据库，适合已经熟悉JPA或者JDBC的开发者。
自动生成SQL，开发者只需要关注业务逻辑，提升开发效率。
提供了丰富的查询语言支持，如JPQL和原生SQL。
与Spring框架紧密集成，方便进行依赖注入等操作。

MyBatisPlus:

基于MyBatis，提供了更多的CRUD操作方法，以及动态SQL的功能。
开发者需要手写SQL语句，但可以自定义通用的CRUD操作，减少代码量。
提供了强大的插件机制，可以自定义扩展，满足复杂的业务需求。

选择哪个取决于具体的项目需求：

如果需要更高的灵活性和自定义能力，可以选择MyBatisPlus。
如果需要更好的抽象和更少的代码编写，可以选择Spring Data JPA。

以下是两者的简单对比：




// Spring Data JPA 示例
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByUsername(String username);
}
 
// MyBatisPlus 示例
@Mapper
public interface UserMapper extends BaseMapper<User> {
    List<User> selectListByUsername(@Param("username") String username);
}

在上述代码中，Spring Data JPA 通过方法名约定来自动生成查询，而 MyBatisPlus 需要手写SQL。在实际使用时，开发者可以根据自己的需求和喜好来选择。

【SpringCloud——Seata分布式事务管理框架】

2024-09-03

Seata 是一种开源的分布式事务解决方案，它提供了高性能和简单易用的分布式事务服务。

以下是一个使用 Seata 进行分布式事务管理的简单示例：

首先，你需要添加 Seata 的依赖到你的项目中。如果你使用 Maven，可以在你的 pom.xml 文件中添加：




<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>你的Seata版本</version>
</dependency>

配置 Seata，在 application.yml 或 application.properties 文件中添加 Seata 服务器的配置：




spring:
  cloud:
    alibaba:
      seata:
        tx-service-group: my_tx_group
        service:
          grouplist:
            default: localhost:8091

在你的业务代码中，使用 @GlobalTransactional 注解标记你的方法，以启用 Seata 的分布式事务管理：




import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class BusinessService {
 
    @Autowired
    private StorageService storageService;
 
    @Autowired
    private OrderService orderService;
 
    @GlobalTransactional
    public void placeOrder(String userId, String commodityCode, int orderCount) {
        storageService.deduct(commodityCode, orderCount);
        orderService.create(userId, commodityCode, orderCount);
    }
}

在上述代码中，placeOrder 方法包含了两个操作：一个是扣减库存，另一个是创建订单。这两个操作会在同一个分布式事务中执行，要么全部成功，要么全部失败。

以上只是一个简单的示例，实际使用时你需要根据你的业务需求和架构进行相应的调整。

SpringBoot-配置加载顺序

2024-09-03

Spring Boot 配置加载顺序通常遵循以下优先级规则：

命令行参数。
来自 SPRING_APPLICATION_JSON 环境变量的内联JSON配置。
当前目录下的 application.properties 或 application.yml 文件。
外部配置文件，如 application.properties 或 application.yml 放在配置目录下。
在 SPRING_CONFIG_LOCATION 环境变量中指定的外部配置文件。
入口点的 spring.config.location 参数。
应用程序的 resource 目录中的 application.properties 或 application.yml 文件。
应用程序的 resource 目录中的 application.properties 或 application.yml 文件。
@PropertySource 注解指定的配置。
默认属性。

这个加载过程是由SpringApplication类中的prepareEnvironment方法来控制的，它会按照上述顺序依次加载配置。

如果要改变默认的配置加载顺序，可以通过编程方式来指定配置文件的位置，例如：




@SpringBootApplication
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MySpringBootApplication.class);
        app.setAdditionalProfiles("dev");
        app.run(args);
    }
}

在这个例子中，我们通过 setAdditionalProfiles 方法添加了一个额外的配置文件后缀名为 dev，Spring Boot 会尝试加载带有 application-dev.properties 或 application-dev.yml 的配置文件。

另外，你可以通过设置 spring.config.location 或 spring.config.import 属性来改变配置文件的默认位置。例如，在命令行中启动应用程序时使用：




java -jar myproject.jar --spring.config.location=file:/path/to/config/

这将会让Spring Boot应用程序加载指定路径下的配置文件。

注意，在实际开发中，通常推荐使用 Spring Boot 提供的默认配置加载顺序，这样可以保持配置的灵活性和可维护性。如果需要覆盖或添加特定的配置，可以在 application.properties 或 application.yml 文件中进行，或者在不同的配置文件中进行分模块管理。

2024-09-03

Spring Boot 配置文件主要有 application.yml 和 application-dev.yml。

application.yml 是主配置文件，通常包含共享环境（如数据库连接信息、服务器配置等）的配置。

application-dev.yml 是一个 profile 配置文件，用于开发环境的配置。当设置了 Spring Boot 的 spring.profiles.active 属性为 dev 时，application-dev.yml 中的配置会覆盖 application.yml 中相同的属性。

以下是两个配置文件的简单示例：

application.yml 示例：




server:
  port: 8080
 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: dbuser
    password: dbpass
    driver-class-name: com.mysql.jdbc.Driver

application-dev.yml 示例：




server:
  port: 8081
 
spring:
  profiles: dev
  datasource:
    url: jdbc:mysql://localhost:3306/mydb_dev
    username: dbuser_dev
    password: dbpass_dev
    driver-class-name: com.mysql.jdbc.Driver

在这个例子中，如果你启动应用程序时设置了 spring.profiles.active=dev，那么应用程序将会使用 application-dev.yml 中定义的端口号 8081 和数据库连接信息。这样做可以让开发环境和生产环境有不同的配置，便于开发和调试。

Spring boot2.7整合jetcache 远程redis缓存方案

2024-09-03

在Spring Boot 2.7中整合jetcache进行远程Redis缓存的方案，你可以参考以下步骤和示例代码：

添加依赖到你的pom.xml：




<dependencies>
    <!-- jetcache -->
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-starter-redis</artifactId>
        <version>0.11.0</version>
    </dependency>
    <!-- redis client -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.7.0</version>
    </dependency>
</dependencies>

配置application.yml文件：




jetcache:
  default:
    type: redis
    host: 你的Redis服务器地址
    port: 6379
    password: 你的Redis密码
    valueDecoder: java.lang.String
    keyEncoder: java.lang.String
    valueEncoder: java.lang.String
    poolConfig:
      maxTotal: 100
      maxIdle: 10
      minIdle: 1

创建一个配置类，使用@Bean定义Cache实例：




import com.alicp.jetcache.Cache;
import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.CreateCache;
import com.alicp.jetcache.anno.config.SpringConfigProvider;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.redis.RedisCacheBuilder;
import com.alicp.jetcache.support.FastjsonKeyConvertor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class CacheConfig {
 
    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }
 
    @Bean
    public Cache defaultCache() {
        return new RedisCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .buildCache();
    }
}

使用jetcache进行缓存操作：




import com.alicp.jetcache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class CacheService {
 
    @Autowired
    private Cache<String, String> cache;
 
    public void put(String key, String value) {
        cache.put(key, value);
    }
 
    public String get(String key) {
        return cache.get(key);
    }
}

确保你的Redis服务器已经启动并可以正常连接，以上代码提供了一个基本的示例，展示了如何在Spring Boot 2.7项目中整合jetcache来使用远程Redis缓存。

2024-09-03

在JDK 11中，引入了一个新的API来创建虚拟线程，这是一个轻量级的线程，可以用于I/O密集型的任务，以减少上下文切换的开销。




import java.lang.invoke.MethodHandles;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.VirtualThread;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        ThreadFactory factory = VirtualThread.factory();
        VirtualThread virtualThread = factory.newThread(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
 
        virtualThread.start();
    }
}

在JDK 17中，对虚拟线程进行了进一步的改进，包括对java.util.concurrent.Executors.newVirtualThreadFactory()的支持，以及对VirtualThread的改进，例如提供了更多的控制选项，如最大虚拟线程数等。




import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        Executor virtualThreadExecutor = Executors.newVirtualThreadFactory();
 
        virtualThreadExecutor.execute(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
    }
}

JDK 21中，虚拟线程的功能进一步加强，包括对虚拟线程池的支持，以及对其他并发工具的改进。




import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
 
public class VirtualThreadExample {
    public static void main(String[] args) {
        ExecutorService virtualThreadExecutor = Executors.newVirtualThreadExecutor();
 
        virtualThreadExecutor.submit(() -> {
            System.out.println("Virtual thread is running.");
            // 执行异步I/O操作
        });
 
        // 关闭虚拟线程池
        virtualThreadExecutor.shutdown();
    }
}

Spring Boot 3 的新特性取决于你所使用的JDK版本。如果你使用JDK 17或更高版本，可以开始利用JDK 17的新特性，如文件加密存储、ZGC的改进等。如果你使用JDK 21或更高版本，可以利用JDK 21引入的模式匹配等新特性。

2024-09-03

为了解决Spring Boot内嵌Tomcat时的异常信息显示问题，可以通过以下步骤来去掉版本号和异常信息：

自定义错误页面：在src/main/resources/templates目录下创建一个名为error.html的错误页面，用以展示友好的错误信息。
配置application.properties或application.yml文件：




# 关闭版本号显示
server.servlet.version-servlet-provider=false
# 关闭堆栈跟踪信息
server.servlet.stacktrace-servlet-provider=false

或者在application.yml中配置：




server:
  servlet:
    version-servlet-provider: false
    stacktrace-servlet-provider: false

确保你有一个错误控制器或者一个全局异常处理器来捕获异常并返回自定义的错误页面。

下面是一个简单的自定义错误页面error.html的例子：




<!DOCTYPE html>
<html>
<head>
    <title>Error Page</title>
</head>
<body>
    <h1>An error occurred!</h1>
    <p>Please try again later.</p>
</body>
</html>

确保你的Spring Boot应用程序已经配置了Thymeleaf或其他模板引擎，以便正确地渲染这个错误页面。如果你使用的是不同的模板引擎，请相应地调整上述代码。

【Protobuf】Springboot集成protobuf

2024-09-03

在Spring Boot中集成Protocol Buffers (protobuf)，你需要做以下几步：

添加依赖：确保你的pom.xml中包含了protobuf和Spring Boot的相关依赖。




<dependencies>
    <!-- Protobuf Dependency -->
    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>YOUR_PROTOBUF_VERSION</version>
    </dependency>
 
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
 
    <!-- Other dependencies ... -->
</dependencies>

编写.proto文件：定义你的消息和服务。




syntax = "proto3";
 
package com.example.service;
 
// 定义消息
message MyMessage {
    string message = 1;
}
 
// 定义服务
service MyService {
    rpc SendMessage(MyMessage) returns (MyMessage);
}

生成Java代码：使用protobuf编译器生成Java代码。




protoc --java_out=./src/main/java -I./src/main/proto ./src/main/proto/*.proto

创建配置类：配置protobuf的JSON格式支持。




@Configuration
public class ProtobufConfiguration {
 
    @Bean
    public ProtobufHttpMessageConverter protobufHttpMessageConverter() {
        return new ProtobufHttpMessageConverter();
    }
}

使用消息和服务：在你的Spring Boot应用中使用生成的protobuf类。




@RestController
public class MyController {
 
    @PostMapping("/message")
    public MyMessage sendMessage(@RequestBody MyMessage request) {
        // 处理请求
        return MyMessage.newBuilder().setMessage("Received: " + request.getMessage()).build();
    }
}

确保你的.proto文件放置在项目的合适位置，并在运行protoc命令时指定正确的输入和输出路径。这样，你就可以在Spring Boot应用中使用protobuf进行消息的序列化和反序列化了。

Spring Boot应用监控实战

2024-09-03




import org.springframework.boot.SpringApplication;
import org.springframework.boot.actuate.autoconfigure.metrics.export.InfluxDbMetricsExportAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication(exclude = InfluxDbMetricsExportAutoConfiguration.class)
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

这段代码展示了如何在Spring Boot应用中禁用InfluxDB的自动配置。通过使用@SpringBootApplication注解并通过exclude属性排除掉InfluxDbMetricsExportAutoConfiguration类，我们可以禁用Spring Boot Actuator的InfluxDB指标导出功能。这是一个常见的需求，尤其是在不需要将监控数据发送到InfluxDB时。

【Spring Cloud 1】分布式架构入门，看完跪了

2024-09-03

在Spring Cloud中，服务间的通信通常通过HTTP RESTful API进行。以下是一个简单的例子，展示了如何使用Spring Cloud Feign客户端来调用远程服务。

首先，在Spring Cloud项目中引入Spring Cloud Feign依赖。




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

创建一个Feign客户端接口。




import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@FeignClient(name = "remote-service", url = "http://localhost:8080")
public interface RemoteServiceClient {
    @GetMapping("/greeting")
    String greeting(@RequestParam(value = "name", defaultValue = "World") String name);
}

在Spring Boot应用的主类或配置类上添加@EnableFeignClients注解。




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
 
@SpringBootApplication
@EnableFeignClients
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在服务的任何需要的地方注入并使用Feign客户端。




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class GreetingController {
 
    @Autowired
    private RemoteServiceClient remoteServiceClient;
 
    @GetMapping("/greeting")
    public String greeting() {
        return remoteServiceClient.greeting();
    }
}

在这个例子中，我们创建了一个名为RemoteServiceClient的Feign客户端接口，用于调用位于http://localhost:8080的远程服务的/greeting端点。在应用的主类上启用Feign客户端，然后在控制器中注入并使用该客户端来进行远程调用。这样，你就可以在Spring Cloud应用中轻松地调用和集成远程服务了。