SpringBoot如何封装自己的SDK_Java

1. 前言

在使用maven构建项目时，会在pom.xml文件中引入各种各样的依赖，那么我们如何将自己常用的一些工具类库进行封装成starter或者sdk供其他项目使用呢，本博客就会带着大家一步一步创建自定义的sdk依赖。

2.项目准备

我们可以在原有项目上进行修改或者重新创建对应的项目。

2.1 创建项目（封装redis为例）

此处使用idea内置spring initializr初始化工具快速创建项目：

填写项目配置：

点击下一步

设置springboot版本以及依赖

此处一定要勾选（spring configuration processor依赖），这样当我们使用依赖后，可在application.yml中看到提示

点击create创建项目即可！

2.1.1删除maven的build插件

<?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 https://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>3.5.3</version>
		<relativepath/> <!-- lookup parent from repository -->
	</parent>
	<groupid>com.common.redis.sdk</groupid>
	<artifactid>common-redis-sdk</artifactid>
	<version>0.0.1</version>
	<name>common-redis-sdk</name>
	<description>common-redis-sdk</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerconnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter</artifactid>
		</dependency>
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-configuration-processor</artifactid>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupid>org.projectlombok</groupid>
			<artifactid>lombok</artifactid>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter-test</artifactid>
			<scope>test</scope>
		</dependency>
		<!-- springboot boot redis -->
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter-data-redis</artifactid>
			<version> 3.5.3</version>
		</dependency>
		<!-- alibaba fastjson -->
		<dependency>
			<groupid>com.alibaba.fastjson2</groupid>
			<artifactid>fastjson2</artifactid>
			<version> 2.0.53</version>
		</dependency>
	</dependencies>
</project>

2.1.2删除启动类

由于这不是一个web项目，因此我们需要将启动类给删除

2.1.3 编写配置类

package com.common.redis.sdk.configure;
import org.springframework.boot.autoconfigure.autoconfigurebefore;
import org.springframework.boot.autoconfigure.data.redis.redisautoconfiguration;
import org.springframework.cache.annotation.cachingconfigurersupport;
import org.springframework.cache.annotation.enablecaching;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.stringredisserializer;
/**
 * redis配置
 */
@configuration
@enablecaching
@autoconfigurebefore(redisautoconfiguration.class)
@suppresswarnings("deprecation")
public class redisconfig extends cachingconfigurersupport {
    @bean
    @suppresswarnings(value = {"unchecked", "rawtypes"})
    public redistemplate<object, object> redistemplate(redisconnectionfactory connectionfactory) {
        redistemplate<object, object> template = new redistemplate<>();
        template.setconnectionfactory(connectionfactory);
        fastjson2jsonredisserializer serializer = new fastjson2jsonredisserializer(object.class);
        // 使用stringredisserializer来序列化和反序列化redis的key值
        template.setkeyserializer(new stringredisserializer());
        template.setvalueserializer(serializer);
        // hash的key也采用stringredisserializer的序列化方式
        template.sethashkeyserializer(new stringredisserializer());
        template.sethashvalueserializer(serializer);
        template.afterpropertiesset();
        return template;
    }
}

2.1.3 编写工具类

package com.common.redis.sdk.service;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.boundsetoperations;
import org.springframework.data.redis.core.hashoperations;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.core.valueoperations;
import org.springframework.stereotype.component;
import java.util.*;
import java.util.concurrent.timeunit;
/**
 * spring redis 工具类
 *
 **/
@suppresswarnings(value = {"unchecked", "rawtypes"})
@component
public class redisservice {
    @autowired
    public redistemplate redistemplate;
    /**
     * 缓存基本的对象，integer、string、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <t> void setcacheobject(final string key, final t value) {
        redistemplate.opsforvalue().set(key, value);
    }
    /**
     * 缓存基本的对象，integer、string、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeunit 时间颗粒度
     */
    public <t> void setcacheobject(final string key, final t value, final long timeout, final timeunit timeunit) {
        redistemplate.opsforvalue().set(key, value, timeout, timeunit);
    }
    /**
     * 设置有效时间
     *
     * @param key     redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final string key, final long timeout) {
        return expire(key, timeout, timeunit.seconds);
    }
    /**
     * 设置有效时间
     *
     * @param key     redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final string key, final long timeout, final timeunit unit) {
        return redistemplate.expire(key, timeout, unit);
    }
    /**
     * 获取有效时间
     *
     * @param key redis键
     * @return 有效时间
     */
    public long getexpire(final string key) {
        return redistemplate.getexpire(key);
    }
    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean haskey(string key) {
        return redistemplate.haskey(key);
    }
    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <t> t getcacheobject(final string key) {
        valueoperations<string, t> operation = redistemplate.opsforvalue();
        return operation.get(key);
    }
    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteobject(final string key) {
        return redistemplate.delete(key);
    }
    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteobject(final collection collection) {
        return redistemplate.delete(collection) > 0;
    }
    /**
     * 缓存list数据
     *
     * @param key      缓存的键值
     * @param datalist 待缓存的list数据
     * @return 缓存的对象
     */
    public <t> long setcachelist(final string key, final list<t> datalist) {
        long count = redistemplate.opsforlist().rightpushall(key, datalist);
        return count == null ? 0 : count;
    }
    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <t> list<t> getcachelist(final string key) {
        return redistemplate.opsforlist().range(key, 0, -1);
    }
    /**
     * 缓存set
     *
     * @param key     缓存键值
     * @param dataset 缓存的数据
     * @return 缓存数据的对象
     */
    public <t> boundsetoperations<string, t> setcacheset(final string key, final set<t> dataset) {
        boundsetoperations<string, t> setoperation = redistemplate.boundsetops(key);
        iterator<t> it = dataset.iterator();
        while (it.hasnext()) {
            setoperation.add(it.next());
        }
        return setoperation;
    }
    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <t> set<t> getcacheset(final string key) {
        return redistemplate.opsforset().members(key);
    }
    /**
     * 缓存map
     *
     * @param key
     * @param datamap
     */
    public <t> void setcachemap(final string key, final map<string, t> datamap) {
        if (datamap != null) {
            redistemplate.opsforhash().putall(key, datamap);
        }
    }
    /**
     * 获得缓存的map
     *
     * @param key
     * @return
     */
    public <t> map<string, t> getcachemap(final string key) {
        return redistemplate.opsforhash().entries(key);
    }
    /**
     * 往hash中存入数据
     *
     * @param key   redis键
     * @param hkey  hash键
     * @param value 值
     */
    public <t> void setcachemapvalue(final string key, final string hkey, final t value) {
        redistemplate.opsforhash().put(key, hkey, value);
    }
    /**
     * 获取hash中的数据
     *
     * @param key  redis键
     * @param hkey hash键
     * @return hash中的对象
     */
    public <t> t getcachemapvalue(final string key, final string hkey) {
        hashoperations<string, string, t> opsforhash = redistemplate.opsforhash();
        return opsforhash.get(key, hkey);
    }
    /**
     * 获取多个hash中的数据
     *
     * @param key   redis键
     * @param hkeys hash键集合
     * @return hash对象集合
     */
    public <t> list<t> getmulticachemapvalue(final string key, final collection<object> hkeys) {
        return redistemplate.opsforhash().multiget(key, hkeys);
    }
    /**
     * 删除hash中的某条数据
     *
     * @param key  redis键
     * @param hkey hash键
     * @return 是否成功
     */
    public boolean deletecachemapvalue(final string key, final string hkey) {
        return redistemplate.opsforhash().delete(key, hkey) > 0;
    }
    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public collection<string> keys(final string pattern) {
        return redistemplate.keys(pattern);
    }
}

2.1.4 自动配置机制文件配置

在 resources目录下创建meta-inf/spring两级子目录
然后在spring目录下创建文件名为org.springframework.boot.autoconfigure.autoconfiguration.imports的文件，如果配置无误应该在idea中会有识别提示：

org.springframework.boot.autoconfigure.autoconfiguration.imports
是 spring boot 的一种自动配置机制，它允许你在 spring boot 的自动配置类中通过 @import 注解动态地导入其他类。这种机制通常用于为 spring boot 应用程序自动装配额外的配置或依赖。

在org.springframework.boot.autoconfigure.autoconfiguration.imports文件中配置项目配置类的路径

com.common.redis.sdk.configure.redisconfig
com.common.redis.sdk.service.redisservice

2.1.5 使用maven构建成jar包

2.2 原有项目改造（参考自建项目）

2.2.1 删除maven的build插件

2.2.2 删除启动类

2.2.3 自动配置机制文件配置

2.2.4 使用maven构建jar包

在项目中使用

将本地jar打进maven仓库中

注释：

-dfile=jar文件所在路径

-dgroupid=包名

-dartifactid=项目名

-dversion=版本号

-dpackaging=jar

mvn install:install-file -dfile=f:\twj\code\code\common-redis-sdk\target\common-redis-sdk-0.0.1.jar -dgroupid=com.common.redis.sdk -dartifactid=common-redis-sdk -dversion=0.0.1 -dpackaging=jar

导入依赖

        <dependency>
             <groupid>com.common.redis.sdk</groupid>
            <artifactid>common-redis-sdk</artifactid>
            <version>0.0.1</version>
        </dependency>

配置类中变量配置

在引入jar包的项目的配置文件中进行参数配置

假设我们的配置类如下：

@configuration
@configurationproperties("sicheng.database")
@data
@componentscan
public class  sqlsessionconfig{
    private string username;
    private string password;
    private string driver;
    private string url;
    @bean
    public sqlsessionfactory getsqlsessionfactory() {
        return new sqlsessionfactory(username,password,driver,url);
    }
}

我们在项目的application.yml文件中就需要进行如下配置

sicheng:
  database:
    driver: com.mysql.cj.jdbc.driver
    url: jdbc:mysql://localhost:3306/sicheng
    username: root
    password: 123456

在项目中使用common-redis-sdk

在项目application.yml文件中填写redis链接信息

spring:
  data:
    redis:
      host: localhost
      port: 13337
      password: password
      database: 10
      timeout: 6000
      lettuce:
        pool:
          max-active: 10 # 连接池最大连接数（使用负值表示没有限制）,如果赋值为-1，则表示不限制；如果pool已经分配了maxactive个jedis实例，则此时pool的状态为exhausted(耗尽)
          max-idle: 8   # 连接池中的最大空闲连接 ，默认值也是8
          max-wait: 100 # # 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出jedisconnectionexception  
          min-idle: 2    # 连接池中的最小空闲连接 ，默认值也是0
        shutdown-timeout: 100ms

在具体类中进行使用

到此这篇关于springboot封装自己的sdk的文章就介绍到这了,更多相关springboot封装sdk内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

SpringBoot如何封装自己的SDK

2025年07月15日 • Java •我要评论