微服务之远程调用

常见的远程调用方式

RPC:Remote Produce Call远程过程调用,类似的还有 。自定义数据格式,基于原生TCP通信,速度快,效率高。早期的webservice,现在热门的dubbo (12不再维护、17年维护权交给apache),都是RPC的典型代表

Http:http其实是一种网络传输协议,基于TCP,规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用Http协议,也可以用来进行远程服务调用。缺点是消息封装臃肿,优势是对服务的提供和调用方没有任何技术限定,自由灵活,更符合微服务理念。现在热门的Rest风格,就可以通过http协议来实现。

跨域调用

跨域特指前端页面调用后端api,即前端页面在一个服务器,后端api在另外一个服务器,是浏览器安全保护行为,与后端没有关系。一般在前后端分离的项目中要解决跨域问题。解决跨域一般有以下几种方式:

(1)ajax+jsonp

(2)proxytable

(3)@CrossOrigin

(4)nginx代理

(5)response.setHeader(“Access-Control-Allow-Origin”, “*”);

远程调用

远程调用技术特指后端不同服务器之间的调用,例如在A服务的api中调用B服务的api。以下的技术都可以完成A服务调用B服务:

(1)dubbo+zookeeper

(2)springcloud中的eureka+feign

(3)httpclient/okhttp3

(4)spring中的RestTemplate

(5)webservice

1、HttpClient

1) HttpClient介绍

HttpClient是一个基于Java的HTTP客户端库,主要用于提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包。以下是关于HttpClient的详细介绍:

1.项目背景:
        - HttpClient是Apache Jakarta Common下的子项目。
        - 它支持HTTP协议最新的版本和建议。
2.主要功能:
        - 发送HTTP请求:HttpClient可以发送GET、POST、PUT、DELETE、HEAD等HTTP请求。
        - 支持HTTPS:HttpClient可以与HTTPS协议一起使用,可以识别和验证服务器证书,并使用加密算法保护请求和响应的数据。
        - 连接管理:HttpClient可以管理多个连接,实现更高效的使用。
        - 请求和响应拦截器:支持添加请求和响应拦截器,可以对请求和响应进行自定义处理(如添加请求头、解析响应内容等)。
        - 连接和请求池:通过连接池和请求池来最大化利用连接和资源,实现更快速和更可靠的HTTP通信。
        - 自定义连接设置:支持自定义连接设置,如设置连接超时时间、请求超时时间、代理等。
        - 支持重定向:默认支持HTTP重定向,可以设置是否允许重定向以及最大重定向次数。
        - 支持认证:支持基本认证、摘要认证、NTLM认证等。
        - 支持缓存:可以使用本地缓存,减少对服务器的请求次数,提高性能。
3.使用场景:
        - 需要调用其他系统接口时,尤其是基于HTTP协议的接口,例如微信支付、查看地图、获取短信验证码、获取天气等。
4.核心API:
        - HttpClient:Http客户端对象,使用该类型对象可发起Http请求。
        - HttpClients:构建器,用于获得HttpClient对象。
        - CloseableHttpClient:具体实现类,实现了HttpClient接口。
        - HttpGet、HttpPost等:不同的HTTP请求方式对应的请求类型。

2)HttpClient使用

使用步骤(以GET请求为例):

    • 引入Maven坐标(依赖项)。
    • 创建HttpClient对象。
    • 创建HttpGet请求对象,并设置目标URL。
    • (可选)添加请求头。
    • 执行请求并获取响应。
    • 提取响应状态码和响应实体内容

引入依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

HttpClient工具类

package com.example.producer.utils;

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpClientUtil {

    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }
}

代码实现

//使用httpclient
@RequestMapping("/orderToMember1")
public String orderToMember1() {
    // 使用httpclient调用接口
    return "订单调用会员服务返回结果" + com.example.producer.utils.HttpClientUtil.doGet("http://127.0.0.1:8082/getMember", null);
}

2、RestTemplate

1)RestTemplate介绍

RestTemplate是Spring Framework提供的一个用于发送HTTP请求的客户端工具类。它简化了在Java应用程序中进行HTTP通信的过程,封装了底层的HTTP连接和请求/响应处理逻辑。

RestTemplate的主要特点和功能包括:

支持多种HTTP方法:RestTemplate支持常见的HTTP方法,如GET、POST、PUT、DELETE等,可以根据需要选择合适的方法来发送请求。

提供丰富的请求和响应处理方法:RestTemplate提供了多种方法来处理请求和响应,如添加请求头、设置请求参数、发送请求、获取响应等。开发者可以根据需要选择合适的方法来处理HTTP请求和响应。

支持请求和响应的序列化和反序列化:RestTemplate可以将请求和响应的数据进行序列化和反序列化,支持多种数据格式,如JSON、XML等。开发者可以根据需要选择合适的序列化和反序列化方式。

支持错误处理和异常处理:RestTemplate可以处理HTTP请求过程中的错误和异常,如连接超时、请求失败等。开发者可以根据需要进行错误处理和异常处理。

可扩展性和定制化:RestTemplate提供了一些扩展点和配置选项,可以进行定制化配置。开发者可以根据需要进行扩展和定制,以满足特定的业务需求。

常用方法:

2)RestTemplate使用

声明restTemplateBean方式一

@Bean
public RestTemplate getRestTemplate(){
    return new RestTemplate();
}

声明restTemplateBean方式二

@Bean
public RestTemplate getRestTemplate(RestTemplateBuilder builder){
    return builder.build();
}

远程调用实现

    @Autowired
    private RestTemplate restTemplate;

   
    @RequestMapping("/getId")
    public String consumerRest(){
        String url = "http://localhost:8082/getMember";
        String consumer = restTemplate.getForObject(url,String.class);
        return "restTemplate consumer如下=http://localhost:8082/getMember" + consumer;
    }

3、WebClient

1)WebClient介绍

WebClient是一个用于执行HTTP请求的客户端,具有多种实现和用途。以下是关于WebClient的详细解释:
1.定义与原理:
        - WebClient是一种非阻塞、响应式客户端,主要用于执行HTTP请求。它可以在处理高并发HTTP请求时,以少量的线程数提供快速响应。
        - 与传统的RestTemplate相比,WebClient是异步执行的,不会阻塞代码,直到HTTP请求返回响应。这使得WebClient在处理大量并发请求时更加高效。
        - WebClient支持同步、异步和流式场景,提供了RestTemplate的替代方案。
2.功能特点:
        - 非阻塞I/O:WebClient使用非阻塞I/O模型,使得在等待HTTP响应时不会阻塞线程。
        - 反应流背压:WebClient支持反应流背压,这是一种控制数据流速的机制,可以防止数据生产者过快地发送数据,导致数据消费者处理不过来。
        - 高并发性:由于WebClient的非阻塞特性,它在硬件资源较少的情况下也能支持高并发请求。
        - 函数式风格与流畅API:WebClient提供了函数式编程风格和流畅的API,使得代码更加简洁和易于阅读。
        - 支持多种场景:WebClient不仅支持传统的HTTP请求,还支持流式传输、WebSocket等场景。

2)WebClient使用

添加webflux依赖

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

编写配置类


import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
 
 
@Component
public class WebClientConfig {
 
    @Bean
    @LoadBalanced
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

编写测试类

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
 
import javax.annotation.Resource;
 
 
@RestController
@RequestMapping("/client")
public class TestClientController {
 
    @Resource
    private WebClient.Builder webClientBuilder;
 
    @GetMapping("/echo/{str}")
    public Mono<String> echo(@PathVariable("str") String str) {
        return webClientBuilder.build()     // 创建WebClient实例
                .get()                      // 请求方式
                .uri("http://service-provider/echo/{1}", str) // 请求url
                .retrieve()                 // 获取响应结果
                .bodyToMono(String.class);  // 将结果转换为指定类型
    }
 
}

3)API详解

请求方式

响应类型

4、OpenFeign

1)OpenFeign介绍

OpenFeign是一个声明式的Web服务客户端,它是Spring Cloud中的一个组件,用于简化和优化微服务架构中的服务间调用。OpenFeign基于Netflix的Feign库进行了扩展和增强。

OpenFeign的主要特点和功能包括:

声明式的API定义:通过使用注解,开发者可以定义和描述服务间的API接口,包括请求方法、路径、参数、请求头等信息。这样可以使得服务间的调用代码更加简洁和易于维护。

自动化的服务发现和负载均衡:OpenFeign集成了服务注册中心,可以自动发现和调用其他微服务。它还支持负载均衡,可以根据配置的负载均衡策略选择合适的服务实例进行调用。

内置的请求和响应拦截器:OpenFeign提供了一些内置的拦截器,可以在请求和响应的不同阶段进行拦截和处理。开发者可以自定义拦截器来实现日志记录、错误处理等功能。

支持多种编码器和解码器:OpenFeign支持多种编码器和解码器,可以处理不同的数据格式,如JSON、XML等。开发者可以根据需要选择合适的编码器和解码器。

整合了Hystrix和Ribbon:OpenFeign与Hystrix和Ribbon等其他Spring Cloud组件集成,可以实现服务的容错和熔断机制,提高系统的可靠性和稳定性。

总之,OpenFeign简化了微服务架构中的服务间调用,提供了一种简洁、声明式的方式来定义和调用服务API。它与Spring Cloud的其他组件集成良好,是构建和管理微服务架构的重要工具之一。

2)OpenFeign使用

① 添加 OpenFeign依赖

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

② 创建Feign客户端接口

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "producer")   //标记的接口用于定义远程服务的调用
public interface RemoteClient {

    @GetMapping("/getMember")
    String helloNacos();
}

③ 使用Feign客户端

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
@EnableFeignClients
@EnableDiscoveryClient
public class NacosFeignApplication {

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

    @Autowired
    private RemoteClient remoteClient;

    @GetMapping("/feign")
    public String test() {
        return remoteClient.helloNacos();
    }
}

④ 注册配置及controller

spring:
  application:
    name: producer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
server:
  port: 8083

=========================================================================
@RestController
@Slf4j
public class ProducerController {
    @Value("${server.port}")
    private String port;

    @RequestMapping("/getMember")
    public String getMember() {
        return "The port of producer is "+port;
    }
}

5、Feign

1)Feign介绍

1.定义:
        - Feign是一个声明式的Web服务客户端,它使得编写Web服务客户端变得更加容易。
        - Feign的设计目标是让Web服务调用变得更加简单,无论是在本地还是在远程。
2.特点:
        - 声明式API定义:通过简单的注解,开发者可以定义需要调用的远程服务的API接口。
        - 集成了负载均衡:Feign默认集成了Ribbon负载均衡器,使得服务调用更加健壮和可靠。
        - 自动化的服务发现:Feign通过服务名自动进行服务发现,无需手动指定远程服务的IP地址和端口。
3.与其他技术的关系:
        - Feign在RestTemplate和Ribbon的基础上进一步封装,使用RestTemplate实现HTTP调用,使用Ribbon实现负载均衡

2)Feign调用步骤

程序启动时,扫描所有的@FeignClient注解

当接口方法被调用时,通过JDK代理来生成RequestTemplate模板

根据RequestTemplate模板生成Http请求的Request对象

Request对象交给Client去处理,其中Client的网络请求框架可以是HttpURLConnection、HttpClient、OKHttp

最后client封装成LoadBaLanceClient,结合ribbon负载均衡地发起调用

6、比较

1)HttpClient、RestTemplate、WebClient的比较

        ①HttpClient

    • 来源:HttpClient是Apache基金会下的一个项目,提供了丰富的HTTP客户端功能。
    • 功能:
      • 支持HTTP/1.1和HTTP/2协议。
      • 提供了连接池管理,用于复用HTTP连接,提高性能。
      • 支持异步和同步请求。
      • 提供了详细的请求和响应控制,如自定义请求头、响应拦截等。
    • 使用方式:通常直接通过HttpClient的API来发起请求,需要编写较多的代码来处理请求和响应。
    • 性能:由于支持连接池和HTTP/2的多路复用,HttpClient在处理大量并发请求时具有优秀的性能表现。

        ②RestTemplate

    • 来源:RestTemplate是Spring框架提供的一个HTTP客户端工具,用于简化与RESTful服务的交互。
    • 功能:
      • 提供了统一的模板方法来发送HTTP请求,如GET、POST、PUT、DELETE等。
      • 支持URI模板,方便构建动态URL。
      • 可以通过实现ClientHttpRequestFactory来定制底层HTTP请求的实现,如使用Apache HttpClient、OkHttp等。
      • 提供了消息转换器,用于将请求和响应体转换为Java对象。
    • 使用方式:RestTemplate的使用较为简单,通常只需要注入一个RestTemplate实例,然后调用其方法发送请求即可。
    • 性能:RestTemplate的性能取决于底层HTTP请求的实现。默认情况下,它使用Java标准库的HttpURLConnection,性能一般。但可以通过配置使用更高效的HTTP客户端库来提升性能。

        ③WebClient

    • 来源:WebClient是Spring WebFlux的一部分,用于构建非阻塞的、响应式的Web客户端。
    • 功能:
      • 基于Reactor响应式编程模型,支持非阻塞的HTTP请求。
      • 提供了丰富的操作符来组合和转换请求和响应流。
      • 支持WebSocket和服务器发送的事件(SSE)。
      • 与Spring WebFlux的其他组件(如Router、Filters等)无缝集成。
    • 使用方式:WebClient的使用方式与传统的HTTP客户端有所不同,它基于响应式编程模型,通过链式调用的方式来构建请求和处理响应。
    • 性能:WebClient在处理大量并发请求时具有优秀的性能表现,因为它基于非阻塞的IO模型,能够充分利用系统资源。同时,它也支持HTTP/2协议,具有更高效的多路复用能力。

总结:

  • HttpClient是一个功能强大的HTTP客户端库,提供了丰富的功能和详细的控制选项。它适用于需要高度定制和灵活性的场景。
  • RestTemplate是Spring框架提供的一个HTTP客户端工具,简化了与RESTful服务的交互。它适用于大多数Web应用程序的场景。
  • WebClient是Spring WebFlux的一部分,基于响应式编程模型构建非阻塞的Web客户端。它适用于需要处理大量并发请求和高效利用系统资源的场景。

2)Feign和OpenFeign的比较

1. 定义与背景

  • Feign:Feign是Netflix开发的一个声明式HTTP客户端,它使得编写Web服务客户端变得更加容易。Feign通过注解和动态代理简化了HTTP API的调用。
  • OpenFeign:OpenFeign是Feign的一个开源实现,并且完全兼容Feign的API。OpenFeign提供了更多的功能和扩展性,是Spring Cloud生态系统中用于服务间通信的重要组件。

2. 核心特性

  • Feign:
    • 支持多种HTTP请求类型,包括GET、POST、PUT、DELETE等。
    • 支持多种数据格式,如JSON、XML、文本等。
    • 支持负载均衡和故障转移。
  • OpenFeign:
    • 除了Feign的所有特性外,OpenFeign还支持以下功能:
      • 更多的注解支持,包括@FeignClient、@RequestMapping、@GetMapping、@PostMapping等。
      • 更多的配置选项,如超时、重试、熔断器等。
      • 更多的扩展,如日志记录、监控、安全等。

3. 实现方式

  • Feign:使用Java动态代理来创建HTTP客户端,根据注解自动生成HTTP请求。
  • OpenFeign:使用Java SPI(Service Provider Interface)来创建HTTP客户端,允许用户自定义HTTP客户端的实现。

4. 适用场景

  • Feign:适用于需要简单、强大的声明式HTTP请求库的场景。
  • OpenFeign:适用于需要更强大、更灵活的声明式HTTP请求库的场景,需要自定义HTTP客户端、使用更多注解、配置更多选项或扩展更多功能。

5. 集成与扩展

  • Feign:虽然功能强大,但扩展性相对有限。
  • OpenFeign:作为Spring Cloud的一部分,与Spring Cloud的其他组件(如Eureka、Ribbon等)集成得更好,并且提供了丰富的扩展机制。

6. 性能优化

  • Feign:性能优化主要依赖于底层HTTP客户端的选择和配置。
  • OpenFeign:除了底层HTTP客户端的选择和配置外,OpenFeign还提供了更多的配置选项和扩展机制来优化性能,如连接池、超时设置等。

总结:

Feign是Spring Cloud组件中的一个轻量级RESTful的HTTP服务客户端,Feign内置了Ribbon,用来做客户端负载均衡,去调用服务注册中心的服务。Feign的使用方式是:使用Feign的注解定义接口,调用这个接口,就可以调用服务注册中心的服务

OpenFeign是Spring Cloud在Feign的基础上支持了SpringMVC的注解,如@RequesMapping等等。OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口,并通过动态代理的方式产生实现类,实现类中做负载均衡并调用其他服务。

7、常用注解

① @EnableFeignClients

  • 作用:启用Feign客户端。Feign是一个声明式的Web Service客户端,它使得编写Web Service客户端变得更加容易。使用Feign,你可以创建一个接口并注解它,Feign将为你生成实现,负责HTTP请求的发送和接收。
  • 使用场景:在Spring Boot应用的主类上添加此注解,以启用Feign客户端的功能。

② @EnableDiscoveryClient

  • 作用:启用服务发现功能。在微服务架构中,服务发现是一个重要的组件,它允许服务在运行时动态地查找其他服务的位置。
  • 使用场景:通常在Spring Boot应用的主类上添加此注解,如果你正在使用Eureka、Consul、Zookeeper等作为服务发现组件。

③ @FeignClient

  • 作用:定义Feign客户端。通过此注解,你可以指定一个服务ID(通常在服务注册中心中注册的服务名),Feign将为你创建一个客户端,用于与该服务进行通信。
  • 使用场景:在接口上添加此注解,定义Feign客户端。
  • 示例:
@FeignClient(name = "my-service")  
public interface MyServiceClient {  
    // 定义方法,用于调用远程服务的API  
}

④ @RefreshScope

  • 作用:使一个Bean具有动态刷新的能力。当外部配置源(如Spring Cloud Config Server)发生变化时,带有此注解的Bean将被重新创建,从而应用新的配置。
  • 使用场景:当你想要让Bean能够动态地感知并应用配置变化时,可以使用此注解。例如,当配置中心的数据库连接信息发生变化时,带有此注解的数据库连接池Bean将被重新创建,从而使用新的数据库连接信息。或者,直接在Feign客户端接口上使用此注解,以便在配置中心的配置变化时,Feign客户端能够使用新的配置(如新的服务地址)。

相关推荐

  1. 异构服务远程调用如何打jar包

    2024-06-10 10:02:05       32 阅读

最近更新

  1. linux在文件夹中查找文件内容

    2024-06-10 10:02:05       0 阅读
  2. 自动化喷涂生产线控制方法概述

    2024-06-10 10:02:05       0 阅读
  3. Leetcode.2709 最大公约数遍历

    2024-06-10 10:02:05       0 阅读
  4. 常用的设计模式

    2024-06-10 10:02:05       0 阅读
  5. 服务器添加TLS域名证书核子之PKCS编解码

    2024-06-10 10:02:05       0 阅读
  6. WDF驱动开发-I/O请求的处理(四)

    2024-06-10 10:02:05       0 阅读
  7. Flask-RQ

    2024-06-10 10:02:05       0 阅读

热门阅读

  1. 2024前端面试准备4-Vue相关

    2024-06-10 10:02:05       4 阅读
  2. #10 解决Stable Diffusion常见问题和错误

    2024-06-10 10:02:05       5 阅读
  3. 006 CentOS 7.9 elasticsearch7.10.0安装及配置

    2024-06-10 10:02:05       8 阅读
  4. 1341. 电影评分

    2024-06-10 10:02:05       5 阅读
  5. 如何学好量子计算机技术的两种思路

    2024-06-10 10:02:05       5 阅读