年轻人的第一个自定义Springboot starter

最新推荐文章于 2023-10-29 12:58:43 发布

钱多多_qdd

最新推荐文章于 2023-10-29 12:58:43 发布

阅读量188

点赞数

分类专栏：文一西路的日子文章标签： spring boot

本文链接：https://blog.csdn.net/moneywenxue/article/details/114242363

版权

文一西路的日子专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、码前必备知识

1.1、SpringBoot starter机制

SpringBoot中的starter是一种非常重要的机制，能够抛弃以前繁杂的配置，将其统一集成进starter，应用者只需要在maven中引入starter依赖，SpringBoot就能自动扫描到要加载的信息并启动相应的默认配置。starter让我们摆脱了各种依赖库的处理，需要配置各种信息的困扰。SpringBoot会自动通过classpath路径下的类发现需要的Bean，并注册进IOC容器。SpringBoot提供了针对日常企业应用研发各种场景的spring-boot-starter依赖模块。所有这些依赖模块都遵循着约定成俗的默认配置，并允许我们调整这些配置，即遵循“约定大于配置”的理念。

1.2、为什么要自定义starter

在我们的日常开发工作中，经常会有一些独立于业务之外的配置模块，我们经常将其放到一个特定的包下，然后如果另一个工程需要复用这块功能的时候，需要将代码硬拷贝到另一个工程，重新集成一遍，麻烦至极。如果我们将这些可独立于业务代码之外的功配置模块封装成一个个starter，复用的时候只需要将其在pom中引用依赖即可，SpringBoot为我们完成自动装配，简直不要太爽。

1.3、自定义starter的案例

以下案例由笔者工作中遇到的部分场景

　　▲ 动态数据源。

　　▲ 登录模块。

　　▲ 基于AOP技术实现日志切面。

　　。。。。。。

1.4、自定义starter的命名规则

SpringBoot提供的starter以spring-boot-starter-xxx的方式命名的。官方建议自定义的starter使用xxx-spring-boot-starter命名规则。以区分SpringBoot生态提供的starter。

1.5、代码地址

https://gitee.com/qianwx/web-starter.git

二、starter的实现方法

2.1 新建一个工程

命名项目web-starter；

总项目结构及文件：

2.2 pom依赖

<?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>

    <groupId>com.qian</groupId>
    <artifactId>web-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.3.0.RELEASE</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.12</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--非必需,该依赖作用是在使用IDEA编写配置文件有代码提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>r</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.3.0.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

    </dependencies>
</project>

2.3 定义一个实体类映射配置信息

@ConfigurationProperties(prefix = "demo") 它可以把相同前缀的配置信息通过配置项名称映射成实体类，比如我们这里指定 prefix = "demo" 这样，我们就能将以demo为前缀的配置项拿到了。
ps：其实这个注解很强大，它不但能映射成String或基本类型的变量。还可以映射为List，Map等数据结构。

@ConfigurationProperties(
		prefix = "spring.http.pool"
)
public class HttpClientProperties {
	private int maxTotal = 100;
	private int defaultMaxPerRoute = 20;
	private int connectTimeout = 3000;
	private int connectionRequestTimeout = 200;
	private int socketTimeout = 2000;
	private int validateAfterInactivity;
	private Long keepAliveTime = 20L;

	public HttpClientProperties() {
	}
	public int getMaxTotal() {
		return this.maxTotal;
	}
	public void setMaxTotal(int maxTotal) {
		this.maxTotal = maxTotal;
	}
	public int getDefaultMaxPerRoute() {
		return this.defaultMaxPerRoute;
	}
	public void setDefaultMaxPerRoute(int defaultMaxPerRoute) {
		this.defaultMaxPerRoute = defaultMaxPerRoute;
	}
	public int getConnectTimeout() {
		return this.connectTimeout;
	}
	public void setConnectTimeout(int connectTimeout) {
		this.connectTimeout = connectTimeout;
	}

	public int getConnectionRequestTimeout() {
		return this.connectionRequestTimeout;
	}
	public void setConnectionRequestTimeout(int connectionRequestTimeout) {
		this.connectionRequestTimeout = connectionRequestTimeout;
	}
	public int getSocketTimeout() {
		return this.socketTimeout;
	}
	public void setSocketTimeout(int socketTimeout) {
		this.socketTimeout = socketTimeout;
	}
	public int getValidateAfterInactivity() {
		return this.validateAfterInactivity;
	}
	public void setValidateAfterInactivity(int validateAfterInactivity) {
		this.validateAfterInactivity = validateAfterInactivity;
	}
	public Map<String, Integer> getKeepAliveTargetHost() {
		return null;
	}
	public Long getKeepAliveTime() {
		return this.keepAliveTime;
	}
	public void setKeepAliveTime(Long keepAliveTime) {
		this.keepAliveTime = keepAliveTime;
	}
}

2.4 定义一个配置类

这里，我们将DemoService类定义为一个Bean，交给Ioc容器。

▲ @Configuration 注解就不多说了。
▲ @EnableConfigurationProperties 注解。该注解是用来开启对3步骤中 @ConfigurationProperties 注解配置Bean的支持。也就是@EnableConfigurationProperties注解告诉Spring Boot 能支持@ConfigurationProperties。

当然了，也可以在 @ConfigurationProperties 注解的类上添加 @Configuration 或者 @Component 注解

▲ @ConditionalOnProperty 注解控制 @Configuration 是否生效。简单来说也就是我们可以通过在yml配置文件中控制 @Configuration 注解的配置类是否生效。

@Slf4j
@Configuration
@EnableConfigurationProperties({HttpClientProperties.class})
public class RestTemplateAutoConfiguration {
	@Autowired
	private HttpClientProperties httpClientProperties;

	public RestTemplateAutoConfiguration() {
	}

	@Bean
	public RestTemplate restTemplate() {
		RestTemplate template = new RestTemplate(this.httpRequestFactory());
		template.getInterceptors().add(new LoggingReqRespInterceptor());
		return template;
	}

	@Bean
	public ClientHttpRequestFactory httpRequestFactory() {
		return new HttpComponentsClientHttpRequestFactory(this.httpClient());
	}

	@Bean
	public HttpClient httpClient() {
		Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", SSLConnectionSocketFactory.getSocketFactory()).build();
		PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
		connectionManager.setMaxTotal(this.httpClientProperties.getMaxTotal());
		connectionManager.setDefaultMaxPerRoute(this.httpClientProperties.getDefaultMaxPerRoute());
		connectionManager.setValidateAfterInactivity(this.httpClientProperties.getValidateAfterInactivity());
		RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(this.httpClientProperties.getSocketTimeout()).setConnectTimeout(this.httpClientProperties.getConnectTimeout()).setConnectionRequestTimeout(this.httpClientProperties.getConnectionRequestTimeout()).build();
		HttpClientBuilder clientBuilder = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).setConnectionManager(connectionManager);

		try {
			SSLContext sslContext = (new SSLContextBuilder()).loadTrustMaterial((KeyStore)null, new TrustStrategy() {
				@Override
				public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
					return true;
				}
			}).build();
			SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new String[]{"TLSv1"}, (String[])null, NoopHostnameVerifier.INSTANCE);
			clientBuilder.setConnectionManager(connectionManager).setSSLSocketFactory(csf);
			clientBuilder.setKeepAliveStrategy(this.connectionKeepAliveStrategy2());
		} catch (KeyStoreException | KeyManagementException | NoSuchAlgorithmException var7) {
			log.error("SSL context configuring failed, HTTPS cannot be used in RestTemplate.", var7);
		}

		return clientBuilder.build();
	}

	/**
	 * 金投的方法，e.getKey()出现报错
	 * @return
	 */
	/*public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
		return (response, context) -> {
			BasicHeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator("Keep-Alive"));

			while(true) {
				String param;
				String value;
				do {
					do {
						if (!it.hasNext()) {
							HttpHost target = (HttpHost)context.getAttribute(HttpClientContext.HTTP_TARGET_HOST);
							Optional<Map.Entry<String, Integer>> any = ((Map)Optional.ofNullable(this.httpClientProperties.getKeepAliveTargetHost()).orElseGet(HashMap::new)).entrySet().stream().filter((e) -> {
								return ((String)e.getKey()).equalsIgnoreCase(target.getHostName());
							}).findAny();
							return (Long)any.map((en) -> {
								return (long)(Integer)en.getValue() * 1000L;
							}).orElse(this.httpClientProperties.getKeepAliveTime() * 1000L);
						}

						HeaderElement he = it.nextElement();
						log.info("HeaderElement:{}", JSON.toJSONString(he));
						param = he.getName();
						value = he.getValue();
					} while(value == null);
				} while(!"timeout".equalsIgnoreCase(param));

				try {
					return Long.parseLong(value) * 1000L;
				} catch (NumberFormatException var8) {
					log.error("Error occurs while parsing timeout settings of keep-alived connection.", var8);
				}
			}
		};
	}*/

	public ConnectionKeepAliveStrategy connectionKeepAliveStrategy2(){
		return (response, context) -> {
			// Honor 'keep-alive' header
			HeaderElementIterator it = new BasicHeaderElementIterator(
					response.headerIterator(HTTP.CONN_KEEP_ALIVE));
			while (it.hasNext()) {
				HeaderElement he = it.nextElement();
				log.info("HeaderElement:{}", JSON.toJSONString(he));
				String param = he.getName();
				String value = he.getValue();
				if (value != null && "timeout".equalsIgnoreCase(param)) {
					try {
						return Long.parseLong(value) * 1000;
					} catch(NumberFormatException ignore) {
						log.error("解析长连接过期时间异常",ignore);
					}
				}
			}
			HttpHost target = (HttpHost) context.getAttribute(
					HttpClientContext.HTTP_TARGET_HOST);
			//如果请求目标地址,单独配置了长连接保持时间,使用该配置
			Optional<Map.Entry<String, Integer>> any = Optional.ofNullable(httpClientProperties.getKeepAliveTargetHost()).orElseGet(HashMap::new)
					.entrySet().stream().filter(
							e -> e.getKey().equalsIgnoreCase(target.getHostName())).findAny();
			//否则使用默认长连接保持时间
			return any.map(en -> en.getValue() * 1000L).orElse(httpClientProperties.getKeepAliveTime() * 1000L);
		};
	}
	public static void main(String[] args) {
		System.out.println("###");
	}
}

2.5 spring.factories

如图，新建META-INF文件夹，然后创建spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.qian.starter.web.RestTemplateAutoConfiguration

2.6 测试

1.在另一个项目中引入web-starter：

2.写一个测试类，注入restTemlate

3.运行testRest()，查看是否用了我们restTemplate

如上图，证明restTemplate确实是我们web-starter里的实例，并且也执行了拦截器。

三、starter的基础——SPI

https://www.cnblogs.com/warrior4236/p/13280755.html

钱多多_qdd

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
年轻人的第一个自定义Springboot starter

一、码前必备知识1.1、SpringBoot starter机制SpringBoot中的starter是一种非常重要的机制，能够抛弃以前繁杂的配置，将其统一集成进starter，应用者只需要在maven中引入starter依赖，SpringBoot就能自动扫描到要加载的信息并启动相应的默认配置。starter让我们摆脱了各种依赖库的处理，需要配置各种信息的困扰。SpringBoot会自动通过classpath路径下的类发现需要的Bean，并注册进IOC容器。SpringBoot提供了针对日常企业应用
复制链接

扫一扫

专栏目录