SpringBoot_RestTemplate的使用

Springboot 开发之 RestTemplate 简介 可以通过设置ClientHttpRequestFactory来自定义RestTemplate的配置,如使用HttpComponentsClientHttpRequestFactory(基于Apache HttpClient)或OkHttp3ClientHttpRequestFactory(基于OkHttp)等。可以配置连接池、超时时间、请求和响应的编解码等。 阅读详情

SpringBoot_RestTemplate的使用

spring框架提供的RestTemplate类可用于在应用中调用rest服务,它简化了与http服务的通信方式,统一了RESTful的标准,封装了http链接, 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient,RestTemplate是一种更优雅的调用RESTful服务的方式。

RestTemplate默认依赖JDK提供http连接的能力(HttpURLConnection),如果有需要的话也可以通过setRequestFactory方法替换为例如 Apache HttpComponents、Netty或OkHttp等其它HTTP library。

本篇介绍如何使用RestTemplate,以及在SpringBoot里面的配置和注入。

实现逻辑

RestTemplate包含以下几个部分:

  • HttpMessageConverter 对象转换器
  • ClientHttpRequestFactory 默认是JDK的HttpURLConnection
  • ResponseErrorHandler 异常处理
  • ClientHttpRequestInterceptor 请求拦截器

img

直接进行简单的使用

/**
 * @author CodeWYX
 * @date 2022/1/21 15:36
 */
public class RestTemplateTest {
    public static void main(String[] args) {
        RestTemplate restT = new RestTemplate();
        //通过Jackson JSON processing library直接将返回值绑定到对象
        List<User> user = restT.getForObject("http://localhost:8088/user", List.class);
        System.out.println(Arrays.asList(user));
    }
}

发送Get请求

01.getForObject 不带参

private void getForObject(){
    RestTemplate restT = new RestTemplate();
    //通过Jackson JSON processing library直接将返回值绑定到对象
    List<User> user = restT.getForObject(url, List.class);
    System.out.println(Arrays.asList(user));
}

02.getForObject 带参

private void getForObject(){
    RestTemplate restT = new RestTemplate();
    //通过Jackson JSON processing library直接将返回值绑定到对象
    User user = restT.getForObject(url+"/{id}", User.class,7);
    System.out.println(Arrays.asList(user));
}

03.getForEntity 不带参

private void getForEntity(){
    RestTemplate restT = new RestTemplate();
    //通过Jackson JSON processing library直接将返回值绑定到对象
    ResponseEntity<List> forEntity = restT.getForEntity(url, List.class);
    HttpStatus code = forEntity.getStatusCode();
    HttpHeaders headers = forEntity.getHeaders();
    List<User> body = forEntity.getBody();
    System.out.println("code"+code);
    System.out.println("headers"+headers);
    System.out.println("body"+Arrays.asList(body));
}

04.getForEntity 带参

private void getForEntity1(){
    RestTemplate restT = new RestTemplate();
    //通过Jackson JSON processing library直接将返回值绑定到对象
    ResponseEntity<User> forEntity = restT.getForEntity(url+"/{id}", User.class,7);
    HttpStatus code = forEntity.getStatusCode();
    HttpHeaders headers = forEntity.getHeaders();
    User body = forEntity.getBody();
    System.out.println("code"+code);
    System.out.println("headers"+headers);
    System.out.println("body"+Arrays.asList(body));
}

发送Post请求

01.postForObject

private void postForObject(){
    RestTemplate restT = new RestTemplate();
    User user = new User();
    user.setName("hello");
    user.setPassword("word");
    User i = restT.postForObject(url, user, User.class);
    System.out.println(i);
}

02.postForEntity

private void postForEntity(){
    RestTemplate restT = new RestTemplate();
    User user = new User();
    user.setName("hello1");
    user.setPassword("word2");
    ResponseEntity<User> i = restT.postForEntity(url, user, User.class);
    User body = i.getBody();
    System.out.println(i);
    System.out.println(body);
}

使用exchange()请求

private String postUser() {
    RestTemplate restT = new RestTemplate();
    String url = this.url;
    //设置Http的Header
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
    //设置访问参数
    HashMap<String, Object> params = new HashMap<>();
    params.put("name", "aaaa");
    params.put("password", "cascascasggreg");
    //设置访问的Entity
    HttpEntity entity = new HttpEntity<>(params, headers);
    ResponseEntity<String> result = null;
    try {
        //发起一个POST请求
        result = restT.exchange(url, HttpMethod.POST, entity, String.class);
        String body = result.getBody();
        System.out.println(body);
    } catch (Exception e) {
        System.out.println("失败: " + e.getMessage());
    }
    return null;
}

设置请求头

// 1-Content-Type
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .contentType(MediaType.APPLICATION_JSON)
        .body(user);

// 2-Accept
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .accept(MediaType.APPLICATION_JSON)
        .body(user);

// 3-Other
RequestEntity<User> requestEntity = RequestEntity
        .post(new URI(uri))
        .header("Authorization", "Basic " + base64Credentials)
        .body(user);

配置类

创建HttpClientConfig类,设置连接池大小、超时时间、重试机制等。配置如下:

/**
 * @author CodeWYX
 * @date 2022/1/21 17:27
 */
@Configuration
@EnableScheduling
public class HttpClientConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientConfig.class);

    @Resource
    private HttpClientProperties p;

    @Bean
    public PoolingHttpClientConnectionManager poolingConnectionManager() {
        SSLContextBuilder builder = new SSLContextBuilder();
        try {
            builder.loadTrustMaterial(null, new TrustStrategy() {
                @Override
                public boolean isTrusted(X509Certificate[] arg0, String arg1) {
                    return true;
                }
            });
        } catch (NoSuchAlgorithmException | KeyStoreException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }

        SSLConnectionSocketFactory sslsf = null;
        try {
            sslsf = new SSLConnectionSocketFactory(builder.build());
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }

        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
                .<ConnectionSocketFactory>create()
                .register("https", sslsf)
                .register("http", new PlainConnectionSocketFactory())
                .build();

        PoolingHttpClientConnectionManager poolingConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        poolingConnectionManager.setMaxTotal(p.getMaxTotalConnections());  //最大连接数
        poolingConnectionManager.setDefaultMaxPerRoute(p.getDefaultMaxPerRoute());  //同路由并发数
        return poolingConnectionManager;
    }

    @Bean
    public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
        return new ConnectionKeepAliveStrategy() {
            @Override
            public long getKeepAliveDuration(HttpResponse response, HttpContext httpContext) {
                HeaderElementIterator it = new BasicHeaderElementIterator
                        (response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while (it.hasNext()) {
                    HeaderElement he = it.nextElement();
                    String param = he.getName();
                    String value = he.getValue();
                    if (value != null && param.equalsIgnoreCase("timeout")) {
                        return Long.parseLong(value) * 1000;
                    }
                }
                return p.getDefaultKeepAliveTimeMillis();
            }
        };
    }

    @Bean
    public CloseableHttpClient httpClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(p.getRequestTimeout())
                .setConnectTimeout(p.getConnectTimeout())
                .setSocketTimeout(p.getSocketTimeout()).build();

        return HttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(poolingConnectionManager())
                .setKeepAliveStrategy(connectionKeepAliveStrategy())
                .setRetryHandler(new DefaultHttpRequestRetryHandler(3, true))  // 重试次数
                .build();
    }

    @Bean
    public Runnable idleConnectionMonitor(final PoolingHttpClientConnectionManager connectionManager) {
        return new Runnable() {
            @Override
            @Scheduled(fixedDelay = 10000)
            public void run() {
                try {
                    if (connectionManager != null) {
                        LOGGER.trace("run IdleConnectionMonitor - Closing expired and idle connections...");
                        connectionManager.closeExpiredConnections();
                        connectionManager.closeIdleConnections(p.getCloseIdleConnectionWaitTimeSecs(), TimeUnit.SECONDS);
                    } else {
                        LOGGER.trace("run IdleConnectionMonitor - Http Client Connection manager is not initialised");
                    }
                } catch (Exception e) {
                    LOGGER.error("run IdleConnectionMonitor - Exception occurred. msg={}, e={}", e.getMessage(), e);
                }
            }
        };
    }

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("poolScheduler");
        scheduler.setPoolSize(50);
        return scheduler;
    }
}

然后再配置RestTemplateConfig类,使用之前配置好的CloseableHttpClient类注入,同时配置一些默认的消息转换器:

/**
 * RestTemplate客户端连接池配置
 * @author CodeWYX
 * @date 2022/1/21 17:39
 */
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class RestTemplateConfig {

    @Resource
    private CloseableHttpClient httpClient;

    @Bean
    public RestTemplate restTemplate(MappingJackson2HttpMessageConverter jackson2HttpMessageConverter) {
        RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());

        List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("utf-8"));
        messageConverters.add(stringHttpMessageConverter);
        messageConverters.add(jackson2HttpMessageConverter);
        restTemplate.setMessageConverters(messageConverters);

        return restTemplate;
    }

    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        HttpComponentsClientHttpRequestFactory rf = new HttpComponentsClientHttpRequestFactory();
        rf.setHttpClient(httpClient);
        return rf;
    }

}

创建HttpClientProperties类

/**
 * @author CodeWYX
 * @date 2022/1/21 17:27
 */
@Component
@ConfigurationProperties(prefix = "httpclient")
public class HttpClientProperties {
    /**
     * 建立连接的超时时间
     */
    private int connectTimeout = 20000;
    /**
     * 连接不够用的等待时间
     */
    private int requestTimeout = 20000;
    /**
     * 每次请求等待返回的超时时间
     */
    private int socketTimeout = 30000;
    /**
     * 每个主机最大连接数
     */
    private int defaultMaxPerRoute = 100;
    /**
     * 最大连接数
     */
    private int maxTotalConnections = 300;
    /**
     * 默认连接保持活跃的时间
     */
    private int defaultKeepAliveTimeMillis = 20000;
    /**
     * 空闲连接生的存时间
     */
    private int closeIdleConnectionWaitTimeSecs = 30;

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public int getRequestTimeout() {
        return requestTimeout;
    }

    public void setRequestTimeout(int requestTimeout) {
        this.requestTimeout = requestTimeout;
    }

    public int getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public int getDefaultMaxPerRoute() {
        return defaultMaxPerRoute;
    }

    public void setDefaultMaxPerRoute(int defaultMaxPerRoute) {
        this.defaultMaxPerRoute = defaultMaxPerRoute;
    }

    public int getMaxTotalConnections() {
        return maxTotalConnections;
    }

    public void setMaxTotalConnections(int maxTotalConnections) {
        this.maxTotalConnections = maxTotalConnections;
    }

    public int getDefaultKeepAliveTimeMillis() {
        return defaultKeepAliveTimeMillis;
    }

    public void setDefaultKeepAliveTimeMillis(int defaultKeepAliveTimeMillis) {
        this.defaultKeepAliveTimeMillis = defaultKeepAliveTimeMillis;
    }

    public int getCloseIdleConnectionWaitTimeSecs() {
        return closeIdleConnectionWaitTimeSecs;
    }

    public void setCloseIdleConnectionWaitTimeSecs(int closeIdleConnectionWaitTimeSecs) {
        this.closeIdleConnectionWaitTimeSecs = closeIdleConnectionWaitTimeSecs;
    }
}

注意,如果没有apache的HttpClient类,需要在pom文件中添加:

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

发送文件

MultiValueMap<String, Object> multiPartBody = new LinkedMultiValueMap<>();
multiPartBody.add("file", new ClassPathResource("/tmp/user.txt"));
RequestEntity<MultiValueMap<String, Object>> requestEntity = RequestEntity
        .post(uri)
        .contentType(MediaType.MULTIPART_FORM_DATA)
        .body(multiPartBody);

下载文件

// 小文件
RequestEntity requestEntity = RequestEntity.get(uri).build();
ResponseEntity<byte[]> responseEntity = restTemplate.exchange(requestEntity, byte[].class);
byte[] downloadContent = responseEntity.getBody();
  
// 大文件  
ResponseExtractor<ResponseEntity<File>> responseExtractor = new ResponseExtractor<ResponseEntity<File>>() {
    @Override
    public ResponseEntity<File> extractData(ClientHttpResponse response) throws IOException {
        File rcvFile = File.createTempFile("rcvFile", "zip");
        FileCopyUtils.copy(response.getBody(), new FileOutputStream(rcvFile));
        return ResponseEntity.status(response.getStatusCode()).headers(response.getHeaders()).body(rcvFile);
    }
};
File getFile = this.restTemplate.execute(targetUri, HttpMethod.GET, null, responseExtractor);

Service注入

@Service
public class DeviceService {
    private static final Logger logger = LoggerFactory.getLogger(DeviceService.class);

    @Resource
    private RestTemplate restTemplate;
}

实际使用例子

// 开始推送消息
logger.info("解绑成功后推送消息给对应的POS机");
LoginParam loginParam = new LoginParam();
loginParam.setUsername(managerInfo.getUsername());
loginParam.setPassword(managerInfo.getPassword());
HttpBaseResponse r = restTemplate.postForObject(
        p.getPosapiUrlPrefix() + "/notifyLogin", loginParam, HttpBaseResponse.class);
if (r.isSuccess()) {
    logger.info("推送消息登录认证成功");
    String token = (String) r.getData();
    UnbindParam unbindParam = new UnbindParam();
    unbindParam.setImei(pos.getImei());
    unbindParam.setLocation(location);
    // 设置HTTP Header信息
    URI uri;
    try {
        uri = new URI(p.getPosapiUrlPrefix() + "/notify/unbind");
    } catch (URISyntaxException e) {
        logger.error("URI构建失败", e);
        return 1;
    }
    RequestEntity<UnbindParam> requestEntity = RequestEntity
            .post(uri)
            .contentType(MediaType.APPLICATION_JSON)
            .accept(MediaType.APPLICATION_JSON)
            .header("Authorization", token)
            .body(unbindParam);
    ResponseEntity<HttpBaseResponse> responseEntity = restTemplate.exchange(requestEntity, HttpBaseResponse.class);
    HttpBaseResponse r2 = responseEntity.getBody();
    if (r2.isSuccess()) {
        logger.info("推送消息解绑网点成功");
    } else {
        logger.error("推送消息解绑网点失败,errmsg = " + r2.getMsg());
    }
} else {
    logger.error("推送消息登录认证失败");
}

创建一个请求的工具类

/**
 * @author CodeWYX
 * @date 2022/1/21 17:27
 */
@Component
public class HttpUtil {

    private static Logger logger = LoggerFactory.getLogger(HttpUtil.class);

    @Resource
    private RestTemplate restTemplate;

    private static HttpUtil httpUtil;

    @PostConstruct
    public void init(){
        httpUtil = this;
        httpUtil.restTemplate = this.restTemplate;
    }

    public static <T> String httpRequest(String url, HttpMethod method, HttpEntity<T> entity){
        try {
            ResponseEntity<String> result = httpUtil.restTemplate.exchange(url, method, entity, String.class);
            return result.getBody();
        } catch (Exception e) {
            logger.error("请求失败: " + e.getMessage());
        }
        return null;
    }

}
Springboot之restTemplate配置及使用 Springboot之restTemplate配置及使用 在springboot项目中,可以直接注入RestTemplate使用,也可进行简单配置 基础配置 @Configuration public class RestTemplateConfig { @Bean public RestTemplate restTemplate(ClientHttpRequestFactory factory) { return new RestTemplate(factory); 阅读详情

相关推荐

SpringBoot使用RestTemplate实现发送HTTP请求

RestTemplate 是 Spring 框架提供的一个用于访问 RESTful 服务的客户端工具,它简化了与 RESTful 服务的交互,并提供了一系列方便的方法来发送 HTTP 请求、处理响应以及处理错误。RestTemplate 提供了一组简单易用的方法,使得发送HTTP请求变得非常简单和直观。RestTemplate 可以自动将请求和响应的 JSON/XML 数据转换为 Java 对象,简化了数据的处理过程。

pan_junbiao的博客 1954

RestTemplate使用详解

一、什么是RestTemplate RestTemplate 是从 Spring3.0 开始支持的一个 HTTP 请求工具,它提供了常见的REST请求方案的模版,例如 GET 请求、POST 请求、PUT 请求、DELETE 请求以及一些通用的请求执行方法 exchange 以及 execute。RestTemplate 继承自 InterceptingHttpAccessor 并且实现了 RestOperations 接口,其中 RestOperations 接口定义了基本的 RESTf...

玲珑骰子安红豆,入骨相思知不知 6万+

SpringBoot整合RestTemplate用法讲解(完整详细)

本篇主要介绍了RestTemplate中的GET,POST,PUT,DELETE、文件上传和文件下载6大常用的功能,每一个方法和每一行代码都进行了详细的讲解,代码都是亲自测试过的,整篇博客写完以后自己也是受益匪浅,于是在这做个技术分享!

黄团团的个人博客 5001

Spring之RestTemplate详解

文章目录1 RestTemplate1.1 引言1.2 环境配置1.2.1 非Spring环境下使用RestTemplate1.2.2 Spring 环境下使用 RestTemplate1.3 API 实践1.3.1 GET请求1.3.1.1 不带参请求1.3.1.2 带参的get请求(使用占位符号传参)1.3.1.3 带参的get请求(restful风格)1.3.1.4 getForEntity使用示例1.3.2 POST请求1.3.2.1 模拟表单请求1.3.2.2 模拟表单请求(传递对象)1.3.2.

上善若泪 3万+

SpringBoot2.x系列教程(六十七)Spring Boot注入RestTemplate及源码解析

引入SpringBoot本来就支持REST服务,因此在SpringBoot项目之间经常需要通过REST的形式来相互调用。本文以具体的实例带大家了解一下SpringBoot中怎么使用RestTemplate进行接口调用。同时,会讲解部分相关源码。 RestTemplate的实例化 RestTemplate实例通常需要自己进行定制,SpringBoot相关的自动配置bean。但是,SpringBoot提供了自动配置的RestTemplateBuilder,可以用它来创建RestTemplate实例。 那么,Sp

程序新视界 1831

华南理工大学电子与信息学院23年预推免复试面试经验贴

华南理工大学电子与信息学院23年预推免复试面试经验贴

Scut_Ty的博客 3300

RestTemplate详解

现如今的 IT 项目,由服务端向外发起网络请求的场景,基本上处处可见!传统情况下,在服务端代码里访问 http 服务时,一般会使用 JDK 的 HttpURLConnection 或者 Apache 的 HttpClient,不过这种方法使用起来太过繁琐,而且 api 使用起来非常的复杂,还得操心资源回收。以下载文件为例,通过 Apache 的 HttpClient方式进行下载文件,会很复杂其实Spring已经为我们提供了一种简单便捷的模板类来进行操作,它就是RestTemplate。

qq_62377885的博客 1万+

WorkBuddy结合DeepSeek与Skill:文献检索自动化与Token成本控制实战

Agent工具与大模型API的结合正重塑知识工作者的日常流程。在实际工程中,调用大模型处理批量任务常面临Token消耗过快、成本不可控的痛点,而国产大模型DeepSeek以极低的API定价和兼容OpenAI接口的特性,为规模化文本处理提供了“Token自由”的可能。同时,可复用的Skill机制能够将特定领域的工作流固化为标准化步骤,让Agent自动执行检索式生成、文献筛选与摘要归纳等复杂操作。本文从这一技术背景出发,以科研文献检索为应用场景,演示如何利用WorkBuddy、DeepSeek API与自建文献

weixin_29061509的博客 511

SpringBoot RestTemplate详解

RestTemplate是Spring提供的进行远程调用客户端RestTemplate提供了很多远程调用的方法,能够大大提高客户端的编写效率。调用RestTemplate的默认构造函数,RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式ClientHttpRequestFactory接口主要提供了三种实现方式。

白羊座的橙子 1万+

数据科学常见模型总结(二)-倾向性得分匹配模型

PSM的核心思想是从未受干预的用户群体中,找到和干预对象一模一样的用户,这样就可以把因果效应归因到干预上。

wudelong0112的专栏 4900

MTK平台TP驱动设备树与GPIO配置实战解析

本文详细解析了MTK平台TP驱动开发中的设备树与GPIO配置实战。通过DCT工具配置GPIO引脚,结合设备树节点定义触摸参数,并分享驱动移植、编译调试技巧及常见问题解决方案,帮助开发者快速掌握MTK触摸驱动开发核心。

ice55的博客 236

SpringBoot之RestTemplate

现如今的 IT 项目,由服务端向外发起网络请求的场景,基本上处处可见!传统情况下,在服务端代码里访问 http 服务时,我们一般会使用JDK的或者Apache的HttpClient,不过这种方法使用起来太过繁琐,而且 api 使用起来非常的复杂,还得操心资源回收。以下载文件为例,通过Apache的HttpClient方式进行下载文件,下面这个是我之前封装的代码逻辑,看看有多复杂!其实Spring已经为我们提供了一种简单便捷的模板类来进行操作,它就是。是一个执行HTTP。

八戒的博客 4673

Git GUI学习教程

学习宗旨:快速应用,不易忘记 很遗憾,申请Git的专栏未审批,那我就不再写专栏了,把最近的学习心得写一下,我也是在学习中进行,有任何问题直接留言,回复交流,我还采用思路+实践模式快速过。 目录 1、Git是什么 2、远程仓库 1)GitHub: 2)Gitee(码云): 3、安装Git(Windows) 1)下载 ...

Alexantao 的专栏 7255

Springboot 使用RestTemplate

最近项目中springboot使用了RestTemplate,在此了解和学习了一下,有问题请指正 1、先学习最简单的使用 创建RestTemplate public static RestTemplate restTemplate() { SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory(); requestFactory.setConnectTime.

醇醛酸酯 的博客 3万+

使用PostgreSQL构建高可用数据库集群

在现代企业级应用中,数据库的高可用性已成为业务连续性的核心要求。PostgreSQL作为一款功能强大的开源关系型数据库,其高可用架构的设计直接影响着系统的稳定性和可靠性。

九天的专栏 1261

零基础学GPU KMD--8. 内存管理:GPU 显存与系统内存的协同​8.1 显存分配策略:GEM / TTM 原理

支持 VRAM、GTT(Graphics Translation Table)、SYSTEM 内存的动态迁移与缓存管理。:若缓冲区在 SYSTEM,TTM 分配 GTT 条目并建立页表映射,使 GPU 可直接访问。:系统内存中预留给 GPU 直接访问的区域,通过 GPU 的 MMU 做地址翻译。你需要我继续展开这一部分吗?​ 为复杂离散 GPU 设计,应对大容量 VRAM、多内存域、显存迁移等问题。:重量级、功能全,适合大容量、多内存域的离散 GPU,强调显存迁移与统一管理。

amy_mhd的博客 188

重学SpringBoot3-RestTemplate配置与使用详解

RestTemplate 是 Spring 框架提供的一个用于发送 HTTP 请求的同步客户端工具类。在 SpringBoot 3.x 版本中,我们依然可以使用 RestTemplate 来进行 REST API 的调用。本文将详细介绍如何在 SpringBoot 3 项目中配置和使用 RestTemplate。

CoderJia的学习之路 7781

(一)深入理解Bluez协议栈之蓝牙Mesh的支持(1/5)

BlueZ是Linux官方蓝牙协议栈。它是一个基于GNU General Public License (GPL)发布的开源项目,从Linux 2.4.6开始便成为Linux 内核的一部分。如果你是linux平台开发蓝牙的的工程师,肯定会接触过Bluez协议栈,hciconfig,hciattach,hciconfig等工具都是很好用的工具。

3325

SpringBoot-RestTemplate

SpringBoot-RestTemplate 需要的Maven RestTemplate是spring的一个rest客户端,在spring-web这个包下,spring boot的依赖如下: <!-- web服务--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spr

weixin_45203607的博客 3651

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

SpringBoot RestTemplate

是 Spring Framework 原生封装的同步阻塞式 HTTP 请求客户端,专门用于 Java 程序内部发起 HTTP/HTTPS 请求,实现跨服务、跨系统、第三方接口调用。就是 Java 代码里的“浏览器”,可以让后端代码主动发送 GET、POST、PUT、DELETE 请求,访问别的接口、获取数据、提交数据。SpringBoot2.x / 3.x 中,自动内置该功能,无需额外导入依赖,直接配置即可使用。Spring 官方目前将其标记为维护模式。

只要肯攀登,终有登顶时 266

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

springboot restTemplate配置

spring template配置示例 @Bean public RestTemplate restTemplate() { SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory(); requestFactory.setConnect...

asd804171023的博客 3121

SpringBoot 2.X 整合 RestTemplate 与使用教程

首先导入springboot 的 web 包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> ...

李虹柏的博客 3万+
上一篇: SpringBoot_MyBatis/MyBatis入门+整合Druid基础
下一篇: FISCO BCOS AND Ubuntu 系列 01-平台搭建
CodeWYX
博客等级 码龄5年 350粉丝 14原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeWYX

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值