玩转springboot2.x 之自定义HttpClient start依赖

版权声明：本文为博主原创文章，转载请表明出处。如果您觉得文章还行就点个赞，同时也可以关注一下我哈。 https://blog.csdn.net/ljk126wy/article/details/87906351

专题系列分类：玩转SpringBoot2.x系列教程

SpringBoot starter起步依赖介绍

SpringBoot 核心功能就是 start依赖，他默认提供了 spring-boot-starter-web spring-boot-starter-logging spring-boot-starter-aop 等自带的starter起步依赖。这个起步依赖依靠自动配置功能来实现的。他的原理就是将一些Bean进行自动配置 不需要我们去人工的干预，最后配置的Bean注入到Spring的容器中。

自定义SpringBoot starter依赖

我们通过创建一个 HttpClient 起步依赖项目来介绍如何创建自定义起步依赖。

创建 starter 依赖项目

创建maven项目 引入 spring-boot-autoconfigure 依赖 并引入httpclient的依赖 具体配置如下：

<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>cn.lijunkui</groupId>
  <artifactId>spring-boot-start-httpclient</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.6</version>
		</dependency>
		 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>
  </dependencies>
</project>

首先创建我们HttpClient 配置信息的配置类 HttpClientProperties
@ConfigurationProperties: 属性配置注解，我们可以在springboot 配置文件中通过注解配置的前缀 + 属性名称 配置值 springboot 会自动将其注入到配置类中。

HttpClientProperties .java相当于是读取到的application.properties中的配置注入到HttpClient 中，或者说是当没有配置的话，就注入默认配置。
HttpClientProperties 类具体内容如下：

package cn.lijunkui.autoconfig;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix="spring.httpclient")
public class HttpClientProperties {
	private Integer connectTimeout = 1000;//创建连接的最长时间
	private Integer socketTimeout = 10000;//数据传输的最长时间
	private String agent = "agent";
	private Integer maxPerRoute = 10;//设置每个路由的并发数
	private Integer maxTotal = 50;//最大连接数 
	public Integer getConnectTimeout() {
		return connectTimeout;
	}
	public void setConnectTimeout(Integer connectTimeout) {
		this.connectTimeout = connectTimeout;
	}
	public Integer getSocketTimeout() {
		return socketTimeout;
	}
	public void setSocketTimeout(Integer socketTimeout) {
		this.socketTimeout = socketTimeout;
	}
	public String getAgent() {
		return agent;
	}
	public void setAgent(String agent) {
		this.agent = agent;
	}
	public Integer getMaxPerRoute() {
		return maxPerRoute;
	}
	public void setMaxPerRoute(Integer maxPerRoute) {
		this.maxPerRoute = maxPerRoute;
	}
	public Integer getMaxTotal() {
		return maxTotal;
	}
	public void setMaxTotal(Integer maxTotal) {
		this.maxTotal = maxTotal;
	}
}

创建HttpClient 自动配置类 HttpClientAutoConfiguration ，在创建我们的配置类前我们先介绍一下我们在配置类中使用的注解：

@Configuration ：声明该类是Spring的配置类 一般和@Bean 结合使用
@Bean: 声明在方法上用于将实例对象注入Spring上下文中。
@EnableConfigurationProperties：会将会HttpClientProperties 作为一个Bean引入HttpClientAutoConfiguration 中。
@ConditionalOnMissingBean：该注解表示，如果存在它修饰的类的bean，则不需要再创建这个bean；可以给该注解传入参数例如@ConditionOnMissingBean(name = “example”)，这个表示如果name为“example”的bean存在，这该注解修饰的代码块不执行。
@ConditionalOnClass：该注解的参数对应的类必须存在，否则不解析该注解修饰的配置类；
具体内容如下：

package cn.lijunkui.autoconfig;

import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.NoConnectionReuseStrategy;
import org.apache.http.impl.client.HttpClientBuilder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass({HttpClient.class})
@EnableConfigurationProperties(HttpClientProperties.class)
public class HttpClientAutoConfiguration {
	private  HttpClientProperties httpClientProperties;
	
	public HttpClientAutoConfiguration(HttpClientProperties httpClientProperties) {
		this.httpClientProperties = httpClientProperties;
	}
	@Bean
	@ConditionalOnMissingBean(HttpClient.class)
	public HttpClient httpClient() {
		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(httpClientProperties.getConnectTimeout())
				.setSocketTimeout(httpClientProperties.getSocketTimeout()).build();
		
		HttpClient httpClient = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig)
				.setUserAgent(httpClientProperties.getAgent()).setMaxConnPerRoute(httpClientProperties.getMaxPerRoute())
				.setConnectionReuseStrategy(new NoConnectionReuseStrategy()).build();
		return httpClient;
	}
}

在resource 目录下 创建META-INF 文件夹并在该文件夹下创建名称为 spring.factories
文件 内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.lijunkui.autoconfig.HttpClientAutoConfiguration

到此代码内容编写完毕，使用maven的install安装到本地仓库后，在创建好springboot之后，添加上依赖，就可以很方便的使用了。

创建SpringBoot 项目 测试自定义依赖

关于创建sprignBoot 项目请参考 玩转springboot2.x 快速搭建之STS篇 这里就不再过多的进行阐述。
第一不引入我们自定义的start依赖，具体配置如下：

扫描二维码关注公众号，回复： 5670639 查看本文章

<?xml version="1.0" encoding="UTF-8"?>
<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>springbootlearn</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springbootlearn</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

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

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			  <groupId>cn.lijunkui</groupId>
			  <artifactId>spring-boot-start-httpclient</artifactId>
			  <version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

编写我们的测试类 具体代码如下：

package com.example.demo;

import java.io.IOException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootlearnApplicationTests {
	
	Logger log = LoggerFactory.getLogger(SpringbootlearnApplicationTests.class);
	@Autowired
	private HttpClient httpClient;
	@Test
	public void contextLoads() throws ClientProtocolException, IOException {
		HttpEntity httpEntity = httpClient.execute(new HttpGet("http://www.baidu.com")).getEntity();
		HttpGet httpGet = new HttpGet("https://www.baidu.com");
		HttpResponse httpResponse = null;
		try {
			//执行请求访问
			httpResponse = httpClient.execute(httpGet);
			//获取返回HTTP状态码
			int satausCode = httpResponse.getStatusLine().getStatusCode();
			if(satausCode == 200 ){
				String content = EntityUtils.toString(httpResponse.getEntity(),"UTF-8");
				log.info("百度首页页面："+content);
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

参考文献：http://www.cnblogs.com/yixianyixian/p/7346894.html
https://www.cnblogs.com/wangxinblog/p/7818700.html