标签微服务下的文章

2024-09-03

微服务架构是一种软件开发方法，它将应用程序构建为一组小型服务的集合，这些服务都能够独立地部署、更新和扩展。每个服务都只关注于完成一个特定的功能。

Spring Cloud是一个用于构建微服务系统的框架，它提供了一系列的工具，如服务发现、配置管理、负载均衡、断路器、智能路由等，来帮助开发者快速构建和部署微服务系统。

以下是使用Spring Cloud构建微服务的基本步骤：

定义服务接口：每个微服务提供一组定义良好的服务接口。
服务实现：开发微服务的具体实现。
服务注册与发现：使用Spring Cloud Netflix Eureka实现服务注册与发现。
客户端负载均衡：使用Spring Cloud Netflix Ribbon实现客户端负载均衡。
断路器：使用Spring Cloud Netflix Hystrix实现断路器模式，防止系统雪崩。
服务间调用：使用Spring Cloud Feign实现服务间调用。
配置管理：使用Spring Cloud Config服务器集中管理配置。
路由：使用Spring Cloud Zuul实现API网关和智能路由。

以下是一个简单的Spring Cloud微服务示例：




@SpringBootApplication
@EnableEurekaClient
public class MyServiceApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
 
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }
}
 
@RestController
public class MyController {
 
    @Autowired
    private RestTemplate restTemplate;
 
    @GetMapping("/call-other-service")
    public String callOtherService() {
        return restTemplate.getForObject("http://other-service/get-data", String.class);
    }
}

在这个例子中，我们创建了一个简单的微服务，它使用@EnableEurekaClient注解来注册自己到Eureka服务器，并且使用RestTemplate进行服务间调用。这只是构建微服务的一个基本示例，实际应用中还需要考虑更多的配置和安全性问题。

微服务入门（Nacos,Feign,网关Zuul）

2024-09-03

微服务是一种架构风格，它将单一应用程序拆分成一组小型服务，每个服务运行在自己的进程中，服务之间通过轻量级的通信机制互相协作。

Nacos是一个更易于构建云原生应用的动态服务发现、配置和服务管理平台。

Feign是一个声明式的Web服务客户端，它使得编写Web服务客户端变得更加简单。

Zuul是Netflix开源的API路由和服务网关，提供动态路由、监控、弹性负载均衡等功能。

以下是一个简单的示例，演示如何使用Nacos作为服务注册中心，Feign进行服务间调用，以及Zuul作为API网关。

引入相关依赖（Maven示例）：




<!-- Nacos客户端依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- Feign客户端依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- Zuul路由网关依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

配置application.properties或者application.yml文件：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos服务器地址
 
server:
  port: 8080
 
feign:
  hystrix:
    enabled: true # 开启Feign的熔断功能
 
zuul:
  routes:
    user-service: # 路由ID，可以自定义
      path: /user-service/** # 匹配路径
      serviceId: user-service # 对应的服务ID

启动类添加注解：




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

Feign客户端调用示例：




@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    UserDto getUserById(@PathVariable("id") Long id);
}
 
@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public UserDto getUserById(Long id) {
        return new UserDto("Error", "Error");
    }
}

启动Nacos服务，启动微服务，启动网关服务。

以上示例展示了如何将Nacos作为服务注册中心，Feign用于服务间的调用，以及Zuul作为API网关的简单使用。这些组件结合使用可以帮助开发者构建一个健壮的微服务架构。

【微服务~原始真解】Spring Cloud —— 配置绑定和配置属性校验

2024-09-03




package com.example.config;
 
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
 
import javax.validation.constraints.NotEmpty;
import java.util.List;
 
@Component
@ConfigurationProperties(prefix = "myservice")
@Validated
public class MyServiceProperties {
 
    @NotEmpty
    private List<String> endpoints;
 
    // 标准的getter和setter方法
    public List<String> getEndpoints() {
        return endpoints;
    }
 
    public void setEndpoints(List<String> endpoints) {
        this.endpoints = endpoints;
    }
}

这个代码示例展示了如何使用Spring Boot的@ConfigurationProperties注解来绑定配置文件中以myservice为前缀的属性。同时，使用了@Validated和@NotEmpty注解来确保endpoints属性不为空，如果属性为空或者未提供，将会抛出验证错误。这种方式可以确保配置文件中的关键属性是有效的，从而提高应用程序的健壮性。

2024-09-03

在Spring Boot 3.x中使用Knife4j，首先需要在项目的pom.xml中添加Knife4j的依赖。




<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>3.x的对应版本</version>
</dependency>

确保你使用的Knife4j版本与Spring Boot 3.x兼容。

接下来，在Spring Boot的配置文件application.yml或application.properties中添加Knife4j的相关配置。




# 设置Knife4j的基本路径，默认是actuator的路径
knife4j.basic.uiPath=/doc.html
# 设置Knife4j的接口文档的访问基础路径
knife4j.basic.enable=true

确保你的Spring Boot应用配置了Spring MVC或Spring WebFlux，因为Knife4j是基于Swagger的，需要这些组件来正确地启动和提供API文档。

对于Knife4j无法访问(404)的问题，可能的原因和解决方法如下：

路径问题：检查你的Knife4j配置路径是否正确，确保访问的路径与配置的路径一致。
Web服务器配置：如果你使用的是嵌入式服务器，如Spring Boot内置的Tomcat，通常不需要额外配置。但如果你使用的是外部服务器，如Nginx，确保Nginx的配置没有拦截掉对应的路径。
安全配置：如果你的应用启用了安全控制，确保Knife4j的路径没有被安全规则阻止访问。
版本兼容性：确保你使用的Knife4j版本与Spring Boot 3.x兼容。
重启应用：在修改配置后，重启Spring Boot应用，以确保新的配置生效。
清理缓存：清理浏览器缓存和服务器端的缓存，以确保访问的是最新的资源。

如果以上步骤都无法解决问题，可以查看应用的日志文件，寻找更具体的错误信息，或者在Stack Overflow等社区寻求帮助。

Spring Cloud微服务项目公共类抽取

2024-09-03

在Spring Cloud项目中抽取公共类，通常是为了代码复用和维护便捷。以下是一个简单的例子，展示如何抽取一个公共的实体类User。

创建一个新的Maven模块，比如叫common-module。
在这个模块中定义公共实体类，比如User。
打包这个模块为一个可被其他模块依赖的Jar包。
在其他的微服务模块中，通过Maven或Gradle添加对这个Jar包的依赖。

以下是一个简单的User类和pom.xml文件示例：

User.java:




package com.example.common.entity;
 
public class User {
    private Long id;
    private String name;
    private String email;
 
    // 省略getter和setter方法
}

pom.xml文件中添加打包方式和可能的依赖：




<project ...>
    <!-- ... 其他配置 ... -->
 
    <groupId>com.example</groupId>
    <artifactId>common-module</artifactId>
    <version>1.0.0</version>
 
    <packaging>jar</packaging>
 
    <!-- 依赖配置 -->
    <dependencies>
        <!-- 依赖其他库 -->
    </dependencies>
 
    <!-- ... 其他配置 ... -->
</project>

在其他微服务模块的pom.xml中添加对common-module的依赖：




<dependencies>
    <!-- 其他依赖 -->
 
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>common-module</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

这样，你就可以在多个微服务模块之间共享User类了。当需要更新User类或者其他公共类时，只需要在common-module中进行更改，并更新版本号，依赖它的微服务会自动获取这些更新。

2024-09-03

Spring Cloud Gateway 是一种网关服务，通常用于API路由、过滤和管理。SpringDoc 是一个Spring Boot应用程序，可以为Spring REST API生成Swagger UI文档。将Spring Cloud Gateway与SpringDoc集成可以提供一个集中的Swagger UI来查看所有微服务的API文档。

以下是一个简化的例子，展示如何将Spring Cloud Gateway与SpringDoc集成：

在Spring Cloud Gateway中添加依赖：




<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!-- SpringDoc -->
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-ui</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-webflux-core</artifactId>
    </dependency>
</dependencies>

配置Spring Cloud Gateway以转发请求到后端服务，并设置SpringDoc的路由：




@Configuration
public class GatewayConfig {
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("service1", r -> r.path("/service1/**")
                        .uri("http://service1:8081")
                        .id("service1_route")
                )
                .route("service2", r -> r.path("/service2/**")
                        .uri("http://service2:8082")
                        .id("service2_route")
                )
                // 添加SpringDoc的路由
                .route("swagger-ui", r -> r.path("/swagger-ui/**")
                        .filters(f -> f.stripPrefix(1))
                        .uri("http://springdoc:8083")
                        .id("swagger_ui_route")
                )
                .build();
    }
}

在微服务中添加SpringDoc依赖并配置SpringDoc：




<dependencies>
    <!-- SpringDoc -->
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-core</artifactId>
    </dependency>
</dependencies>




@Configuration
public class SpringDocConfig {
 
    @Bean
    public OpenAPI customOpenAPI(@Value("${springdoc.version}") String appVersion) {
        return new OpenAPI()
                .info(new Info().title("微服务API文档")
                        .version(appVersion)
                        .license(new License().name("Apache 2.0").url("http://springdoc.org")));
    }
}

确保每个微服务都有一个对应的SpringDoc实例，并且这些实例可以被Spring Cloud Gateway访问。

以上代码展示了如何通过Spring Cloud Gateway将对微服务的请求以及

Spring Cloud Gateway：打造可扩展的微服务网关

2024-09-03




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 示例：检查请求头中是否有特定的安全认证信息
        String authHeader = exchange.getRequest().getHeaders().getFirst("X-Auth-Header");
        if (authHeader == null || !authHeader.equals("expected-value")) {
            // 如果没有或不匹配，则返回401未授权状态码
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        // 如果检查通过，则继续执行后续的过滤器链
        return chain.filter(exchange);
    }
 
    @Override
    public int getOrder() {
        // 定义过滤器的执行顺序，数字越小，优先级越高
        return -1;
    }
}

这段代码定义了一个全局过滤器，用于检查请求头中的X-Auth-Header值是否符合预期。如果不符合，则返回401未授权的HTTP状态码。这是一个简单的权限控制示例，实际应用中可以根据需要进行更复杂的认证和授权逻辑的添加。

Spring Cloud微服务基础入门

2024-09-03

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性简化了分布式系统的开发，如服务发现、服务配置、负载均衡、断路器、智能路由、微代理、控制总线等。

以下是一个简单的Spring Cloud微服务示例，包括一个服务注册中心（Eureka Server）和一个服务提供者（Eureka Client）。

创建一个Spring Boot项目作为服务注册中心（Eureka Server）：




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

在application.properties中配置：




spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

创建另一个Spring Boot项目作为服务提供者（Eureka Client）：




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

在application.properties中配置：




spring.application.name=service
server.port=8762
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

在提供者中创建一个REST控制器：




@RestController
public class TestController {
    @GetMapping("/test")
    public String test() {
        return "Hello, Spring Cloud!";
    }
}

启动Eureka Server，然后启动ServiceApplication（Eureka Client）。打开浏览器访问http://localhost:8761/，你将看到Service服务已注册在Eureka Server上。使用任何HTTP客户端访问http://localhost:8762/test，你将得到返回的消息。

Spring Boot中的微服务通信方式

2024-09-03

Spring Boot支持多种微服务通信方式，以下是一些常见的方法：

使用Spring Web MVC创建RESTful API：
Spring Boot使得创建RESTful API变得简单，通过@RestController和@RequestMapping注解，可以轻松地构建出用于微服务间通信的API。




@RestController
@RequestMapping("/api/items")
public class ItemController {
    @GetMapping("/{id}")
    public ResponseEntity<Item> getItem(@PathVariable("id") Long id) {
        // 获取Item逻辑
    }
 
    @PostMapping
    public ResponseEntity<Item> createItem(@RequestBody Item item) {
        // 创建Item逻辑
    }
 
    // 其他CRUD操作
}

使用Spring Web Client进行服务间调用：
Spring Web Client提供了一种简单的方式来进行HTTP调用。




@Service
public class AnotherServiceClient {
    private final WebClient webClient;
 
    public AnotherServiceClient(WebClient.Builder builder) {
        this.webClient = builder.baseUrl("http://another-service-url/api/").build();
    }
 
    public Mono<String> getDataFromAnotherService(String dataId) {
        return webClient.get()
                .uri("/data/{dataId}", dataId)
                .retrieve()
                .bodyToMono(String.class);
    }
}

使用Spring Cloud Feign进行声明式REST调用：
Feign是一个声明式的Web服务客户端，它使得编写Web服务客户端变得更加简单。




@FeignClient(name = "another-service", url = "http://another-service-url")
public interface AnotherServiceFeignClient {
    @GetMapping("/api/data/{dataId}")
    String getData(@PathVariable("dataId") String dataId);
}

使用Spring Cloud Stream进行消息驱动的通信：
Spring Cloud Stream为实现消息驱动的微服务提供了抽象层。




@EnableBinding(Processor.class)
public class MessageService {
    @Autowired
    private MessageChannel output;
 
    public void sendMessage(String message) {
        this.output.send(MessageBuilder.withPayload(message).build());
    }
 
    @StreamListener(Processor.INPUT)
    public void receiveMessage(String payload) {
        // 处理接收到的消息逻辑
    }
}

以上是Spring Boot中实现微服务通信的一些常见方式，具体使用哪种方式取决于具体的应用场景和团队的技术偏好。

微服务 | Springboot整合GateWay+Nacos实现动态路由

2024-09-03

在Spring Boot中，你可以使用Spring Cloud Gateway结合Spring Cloud Alibaba Nacos实现动态路由。以下是一个简化的示例：

在pom.xml中添加依赖：




<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!-- Spring Cloud Alibaba Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- Spring Cloud Alibaba Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

配置application.yml：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos Server 地址
    gateway:
      discovery:
        locator:
          enabled: true # 开启基于服务发现的路由
      routes:
        - id: user-service
          # 使用服务发现路由，gateway会去nacos拉取服务列表，并动态更新路由
          uri: lb://user-service
          predicates:
            - Path=/user/**

启动类添加注解：




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

这样配置后，Spring Cloud Gateway会结合Nacos服务注册中心，动态地根据服务ID（如user-service）创建路由。当新的服务实例注册到Nacos时，Gateway会自动添加新的路由；当服务实例下线或删除时，Gateway会自动移除对应的路由。这样，你就可以通过Nacos管理你的服务路由，实现动态路由。