【Spring-boot】自己开发一个SpringBoot的starter--＞实战

一、前言

上一篇文章我们已经研究了spring boot starter 的工作原理（传送门），现在我们来亲手开发一个自己的连接redis的spring boot starter吧。

1.1 环境信息

依赖	版本
springboot	2.4.10
redis	windows单机版

1.2 源码地址

传送门

二、starter开发

2.1 代码开发

2.1.1 首先创建一个最简单的maven项目

spring官方提供的starter命名一般都是spring-boot-starter-xxx，官方建议我们开发时命名格式为xxx-spring-boot-starter。因此，我们新建的项目名称按照官方的建议命名为my-redis-spring-boot-starter。


项目结构

2.1.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.lh</groupId>
    <artifactId>my-redis-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.3.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.4.2</version>
        </dependency>

        <!-- 引入redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.0.RELEASE</version>
        </dependency>
    </dependencies>
</project>

2.1.3 配置类

package com.lh.config;
import org.springframework.beans.factory.annotation.Autowired;
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;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author: liuhang
 * @createDate: 2021/8/26 10:58
 * @version: 1.0
 * @description: 只有当Jedis 存在的时候 才执行，就是说一定要引入了Jedis的依赖才会执行这个配置
 */
@Configuration
@ConditionalOnClass(Jedis.class)
@EnableConfigurationProperties(RedisProperties.class)//引入属性类
public class RedisAutoConfiguration {

    @Autowired
    private RedisProperties redisProperties;

    /**
     * 当这个bean不存在的时候才执行，防止重复加载bean
     */
    @Bean
    @ConditionalOnMissingBean
    public JedisPoolConfig poolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle());
        jedisPoolConfig.setMaxTotal(redisProperties.getMaxActive());
        jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWait());
        jedisPoolConfig.setTestOnBorrow(redisProperties.isTestOnBorrow());
        return jedisPoolConfig;
    }

    @Bean
    @ConditionalOnMissingBean
    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(redisProperties.getHost());
        jedisConnectionFactory.setPort(redisProperties.getPort());
        jedisConnectionFactory.setDatabase(redisProperties.getDbIndex());
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
        return jedisConnectionFactory;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }
}

2.1.4 参数配置类

package com.lh.config;

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

/**
 * @author: liuhang
 * @createDate: 2021/8/26 11:01
 * @version: 1.0
 * @description:
 */
@ConfigurationProperties("my.redis")
public class RedisProperties {
    /**
     * ip
     */
    private String host;
    /**
     * 端口
     */
    private Integer port;
    /**
     * 密码
     */
    private String password;
    /**
     * 库索引
     */
    private int dbIndex;
    /**
     * 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
     */
    private int maxIdle;
    /**
     * 可用连接实例的最大数目
     */
    private int maxActive;
    /**
     * 等待可用连接的最大时间
     */
    private int maxWait;
    /**
     * 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
     */
    private boolean testOnBorrow;

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getDbIndex() {
        return dbIndex;
    }

    public void setDbIndex(int dbIndex) {
        this.dbIndex = dbIndex;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle) {
        this.maxIdle = maxIdle;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }
}

2.1.5 创建spring.factories

在resources目录下创建一个META-INF文件夹，并创建一个spring.factories文件，指定配置类的权限定名（com.lh.config.RedisAutoConfiguration）。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.lh.config.RedisAutoConfiguration

2.2 打包

打开右侧的maven对话框，分别执行clean-》install 打包。

在项目的target目录先就是我们打好的jar包。

打开本地maven仓库地址，可以发现已经安装到本地maven仓库了。

三、测试

接下来我们创建一个sprin boot项目测试下吧。

3.1 在新创建的项目中引入自定义starter的依赖

		<dependency>
            <groupId>com.lh</groupId>
            <artifactId>my-redis-spring-boot-starter</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

3.2 测试的controller

package com.lh.my.springboot.starter.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redis")
public class RedisController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("/set")
    public String set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
        return "OK";
    }

    @GetMapping("/get")
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

3.3 application.properties配置

server.port=8080
my.redis.host=localhost
my.redis.port=6379
my.redis.password=
my.redis.dbIndex=0
my.redis.maxIdle=200
my.redis.maxActive=1024
my.redis.maxWait=10000
my.redis.testOnBorrow=true

3.4 测试保存

3.5 测试查询

打开redis可是化工具，查看