RedisTemplate的配置和讲解以及和StringRedisTemplate的区别

2023-11-30 07:12
文章标签 配置 讲解 区别 redistemplate stringredistemplate

本文主要是介绍RedisTemplate的配置和讲解以及和StringRedisTemplate的区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

本文主要讲redisTempalte的几种常用的序列化方式

  • string，我们大部分情况下都希望存入redis的数据可读性强一些，并且value也不总是一个规则的类型，所以这里也是不用json序列化的原因，可以更自由方便，下边提供配置方法 
    package sca.pro.core.redis.configuration;import cn.hutool.core.convert.Convert;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;import java.time.Duration;@Configuration
@EnableCaching
public class RedisTemplateConfig {@Value("${spring.redis.database}")private int database;@Value("${spring.redis.host}")private String host;@Value("${spring.redis.password}")private String password;@Value("${spring.redis.port}")private String port;@Value("${spring.redis.timeout}")private String timeout;@Value("${spring.redis.lettuce.pool.max-idle}")private String maxIdle;@Value("${spring.redis.lettuce.pool.min-idle}")private String minIdle;@Value("${spring.redis.lettuce.pool.max-active}")private String maxActive;@Value("${spring.redis.lettuce.pool.max-wait}")private String maxWait;@Beanpublic LettuceConnectionFactory lettuceConnectionFactory() {GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();genericObjectPoolConfig.setMaxIdle(Convert.toInt(maxIdle));genericObjectPoolConfig.setMinIdle(Convert.toInt(minIdle));genericObjectPoolConfig.setMaxTotal(Convert.toInt(maxActive));genericObjectPoolConfig.setMaxWaitMillis(Convert.toLong(maxWait));genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(100);RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();redisStandaloneConfiguration.setDatabase(database);redisStandaloneConfiguration.setHostName(host);redisStandaloneConfiguration.setPort(Convert.toInt(port));redisStandaloneConfiguration.setPassword(RedisPassword.of(password));LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(Convert.toLong(timeout))).poolConfig(genericObjectPoolConfig).build();LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);return factory;}@Beanpublic RedisTemplate<String, String> redisTemplate(LettuceConnectionFactory factory) {// 配置redisTemplateRedisTemplate<String, String> redisTemplate = new RedisTemplate<>();redisTemplate.setConnectionFactory(factory);redisTemplate.setKeySerializer(new StringRedisSerializer());//key序列化redisTemplate.setValueSerializer(new StringRedisSerializer());//value序列化//设置hash的key的序列化方式redisTemplate.setHashKeySerializer(new StringRedisSerializer());//设置hash的value的序列化方式redisTemplate.setHashValueSerializer(new StringRedisSerializer());redisTemplate.afterPropertiesSet();//使上面参数生效return redisTemplate;}
}

其实如果key和value都是string，那就等效于我们直接引入StringRedisTemplate 

  • 如果使用字节数组的形式序列化，redistemplate默认使用的jdk的序列化方式，但是jdk的序列化后的字节数组不仅重，而且序列化和反序列化我们用的是protobuf，如下

   pom

<!-- 工具库 -->
<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>18.0</version>
</dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency><!-- 序列化 -->
<dependency><groupId>com.dyuproject.protostuff</groupId><artifactId>protostuff-core</artifactId><version>1.1.3</version>
</dependency>
<dependency><groupId>com.dyuproject.protostuff</groupId><artifactId>protostuff-runtime</artifactId><version>1.1.3</version>
</dependency>

2.自己编写序列化工具

@Slf4j
public class ProtoStuffUtil {/*** 序列化对象** @param obj* @return*/public static <T> byte[] serialize(T obj) {if (obj == null) {log.error("Failed to serializer, obj is null");throw new RuntimeException("Failed to serializer");}@SuppressWarnings("unchecked") Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(obj.getClass());LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);byte[] protoStuff;try {protoStuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);} catch (Exception e) {log.error("Failed to serializer, obj:{}", obj, e);throw new RuntimeException("Failed to serializer");} finally {buffer.clear();}return protoStuff;}/*** 反序列化对象** @param paramArrayOfByte* @param targetClass* @return*/public static <T> T deserialize(byte[] paramArrayOfByte, Class<T> targetClass) {if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {log.error("Failed to deserialize, byte is empty");throw new RuntimeException("Failed to deserialize");}T instance;try {instance = targetClass.newInstance();} catch (InstantiationException | IllegalAccessException e) {log.error("Failed to deserialize", e);throw new RuntimeException("Failed to deserialize");}Schema<T> schema = RuntimeSchema.getSchema(targetClass);ProtostuffIOUtil.mergeFrom(paramArrayOfByte, instance, schema);return instance;}/*** 序列化列表** @param objList* @return*/public static <T> byte[] serializeList(List<T> objList) {if (objList == null || objList.isEmpty()) {log.error("Failed to serializer, objList is empty");throw new RuntimeException("Failed to serializer");}@SuppressWarnings("unchecked") Schema<T> schema =(Schema<T>) RuntimeSchema.getSchema(objList.get(0).getClass());LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);byte[] protoStuff;ByteArrayOutputStream bos = null;try {bos = new ByteArrayOutputStream();ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer);protoStuff = bos.toByteArray();} catch (Exception e) {log.error("Failed to serializer, obj list:{}", objList, e);throw new RuntimeException("Failed to serializer");} finally {buffer.clear();try {if (bos != null) {bos.close();}} catch (IOException e) {e.printStackTrace();}}return protoStuff;}/*** 反序列化列表** @param paramArrayOfByte* @param targetClass* @return*/public static <T> List<T> deserializeList(byte[] paramArrayOfByte, Class<T> targetClass) {if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {log.error("Failed to deserialize, byte is empty");throw new RuntimeException("Failed to deserialize");}Schema<T> schema = RuntimeSchema.getSchema(targetClass);List<T> result;try {result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(paramArrayOfByte), schema);} catch (IOException e) {log.error("Failed to deserialize", e);throw new RuntimeException("Failed to deserialize");}return result;}}

3.RedisTemplate的工具类方法

@Component
public class RedisClient {private final RedisTemplate<String, String> redisTemplate;@Autowiredpublic RedisClient(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;}/*** get cache** @param field* @param targetClass* @param <T>* @return*/public <T> T get(final String field, Class<T> targetClass) {byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(field.getBytes()));if (result == null) {return null;}return ProtoStuffUtil.deserialize(result, targetClass);}/*** put cache** @param field* @param obj* @param <T>* @return*/public <T> void set(String field, T obj) {final byte[] value = ProtoStuffUtil.serialize(obj);redisTemplate.execute((RedisCallback<Void>) connection -> {connection.set(field.getBytes(), value);return null;});}/*** put cache with expire time** @param field* @param obj* @param expireTime 单位: s* @param <T>*/public <T> void setWithExpire(String field, T obj, final long expireTime) {final byte[] value = ProtoStuffUtil.serialize(obj);redisTemplate.execute((RedisCallback<Void>) connection -> {connection.setEx(field.getBytes(), expireTime, value);return null;});}/*** get list cache** @param field* @param targetClass* @param <T>* @return*/public <T> List<T> getList(final String field, Class<T> targetClass) {byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(field.getBytes()));if (result == null) {return null;}return ProtoStuffUtil.deserializeList(result, targetClass);}/*** put list cache** @param field* @param objList* @param <T>* @return*/public <T> void setList(String field, List<T> objList) {final byte[] value = ProtoStuffUtil.serializeList(objList);redisTemplate.execute((RedisCallback<Void>) connection -> {connection.set(field.getBytes(), value);return null;});}/*** put list cache with expire time** @param field* @param objList* @param expireTime* @param <T>* @return*/public <T> void setListWithExpire(String field, List<T> objList, final long expireTime) {final byte[] value = ProtoStuffUtil.serializeList(objList);redisTemplate.execute((RedisCallback<Void>) connection -> {connection.setEx(field.getBytes(), expireTime, value);return null;});}/*** get h cache** @param key* @param field* @param targetClass* @param <T>* @return*/public <T> T hGet(final String key, final String field, Class<T> targetClass) {byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.hGet(key.getBytes(), field.getBytes()));if (result == null) {return null;}return ProtoStuffUtil.deserialize(result, targetClass);}/*** put hash cache** @param key* @param field* @param obj* @param <T>* @return*/public <T> boolean hSet(String key, String field, T obj) {final byte[] value = ProtoStuffUtil.serialize(obj);return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hSet(key.getBytes(), field.getBytes(), value));}/*** put hash cache** @param key* @param field* @param obj* @param <T>*/public <T> void hSetWithExpire(String key, String field, T obj, long expireTime) {final byte[] value = ProtoStuffUtil.serialize(obj);redisTemplate.execute((RedisCallback<Void>) connection -> {connection.hSet(key.getBytes(), field.getBytes(), value);connection.expire(key.getBytes(), expireTime);return null;});}/*** get list cache** @param key* @param field* @param targetClass* @param <T>* @return*/public <T> List<T> hGetList(final String key, final String field, Class<T> targetClass) {byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.hGet(key.getBytes(), field.getBytes()));if (result == null) {return null;}return ProtoStuffUtil.deserializeList(result, targetClass);}/*** put list cache** @param key* @param field* @param objList* @param <T>* @return*/public <T> boolean hSetList(String key, String field, List<T> objList) {final byte[] value = ProtoStuffUtil.serializeList(objList);return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hSet(key.getBytes(), field.getBytes(), value));}/*** get cache by keys** @param key* @param fields* @param targetClass* @param <T>* @return*/public <T> Map<String, T> hMGet(String key, Collection<String> fields, Class<T> targetClass) {List<byte[]> byteFields = fields.stream().map(String::getBytes).collect(Collectors.toList());byte[][] queryFields = new byte[byteFields.size()][];byteFields.toArray(queryFields);List<byte[]> cache = redisTemplate.execute((RedisCallback<List<byte[]>>) connection -> connection.hMGet(key.getBytes(), queryFields));Map<String, T> results = new HashMap<>(16);Iterator<String> it = fields.iterator();int index = 0;while (it.hasNext()) {String k = it.next();if (cache.get(index) == null) {index++;continue;}results.put(k, ProtoStuffUtil.deserialize(cache.get(index), targetClass));index++;}return results;}/*** set cache by keys** @param field* @param values* @param <T>*/public <T> void hMSet(String field, Map<String, T> values) {Map<byte[], byte[]> byteValues = new HashMap<>(16);for (Map.Entry<String, T> value : values.entrySet()) {byteValues.put(value.getKey().getBytes(), ProtoStuffUtil.serialize(value.getValue()));}redisTemplate.execute((RedisCallback<Void>) connection -> {connection.hMSet(field.getBytes(), byteValues);return null;});}/*** get caches in hash** @param key* @param targetClass* @param <T>* @return*/public <T> Map<String, T> hGetAll(String key, Class<T> targetClass) {Map<byte[], byte[]> records = redisTemplate.execute((RedisCallback<Map<byte[], byte[]>>) connection -> connection.hGetAll(key.getBytes()));Map<String, T> ret = new HashMap<>(16);for (Map.Entry<byte[], byte[]> record : records.entrySet()) {T obj = ProtoStuffUtil.deserialize(record.getValue(), targetClass);ret.put(new String(record.getKey()), obj);}return ret;}/*** list index** @param key* @param index* @param targetClass* @param <T>* @return*/public <T> T lIndex(String key, int index, Class<T> targetClass) {byte[] value =redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.lIndex(key.getBytes(), index));return ProtoStuffUtil.deserialize(value, targetClass);}/*** list range** @param key* @param start* @param end* @param targetClass* @param <T>* @return*/public <T> List<T> lRange(String key, int start, int end, Class<T> targetClass) {List<byte[]> value = redisTemplate.execute((RedisCallback<List<byte[]>>) connection -> connection.lRange(key.getBytes(), start, end));return value.stream().map(record -> ProtoStuffUtil.deserialize(record, targetClass)).collect(Collectors.toList());}/*** list left push** @param key* @param obj* @param <T>*/public <T> void lPush(String key, T obj) {final byte[] value = ProtoStuffUtil.serialize(obj);redisTemplate.execute((RedisCallback<Long>) connection -> connection.lPush(key.getBytes(), value));}/*** list left push** @param key* @param objList* @param <T>*/public <T> void lPush(String key, List<T> objList) {List<byte[]> byteFields = objList.stream().map(ProtoStuffUtil::serialize).collect(Collectors.toList());byte[][] values = new byte[byteFields.size()][];redisTemplate.execute((RedisCallback<Long>) connection -> connection.lPush(key.getBytes(), values));}/*** 精确删除key** @param key*/public void deleteCache(String key) {redisTemplate.delete(key);}/*** 排行榜的存入** @param redisKey* @param immutablePair*/public void zAdd(String redisKey, ImmutablePair<String, BigDecimal> immutablePair) {final byte[] key = redisKey.getBytes();final byte[] value = immutablePair.getLeft().getBytes();redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.zAdd(key, immutablePair.getRight().doubleValue(), value));}/*** 获取排行榜低->高排序** @param redisKey 要进行排序的类别* @param start* @param end* @return*/public List<ImmutablePair<String, BigDecimal>> zRangeWithScores(String redisKey, int start, int end) {Set<RedisZSetCommands.Tuple> items = redisTemplate.execute((RedisCallback<Set<RedisZSetCommands.Tuple>>) connection -> connection.zRangeWithScores(redisKey.getBytes(), start, end));return items.stream().map(record -> ImmutablePair.of(new String(record.getValue()), BigDecimal.valueOf(record.getScore()))).collect(Collectors.toList());}/*** 获取排行榜高->低排序** @param redisKey 要进行排序的类别* @param start* @param end* @return*/public List<ImmutablePair<String, BigDecimal>> zRevRangeWithScores(String redisKey, int start, int end) {Set<RedisZSetCommands.Tuple> items = redisTemplate.execute((RedisCallback<Set<RedisZSetCommands.Tuple>>) connection -> connection.zRevRangeWithScores(redisKey.getBytes(), start, end));return items.stream().map(record -> ImmutablePair.of(new String(record.getValue()), BigDecimal.valueOf(record.getScore()))).collect(Collectors.toList());}
}
  • 最推荐的一种序列化方式GenericJackson2JsonRedisSerializer，org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer 使用Jackson 实现JSON的序列化方式，Generic单词翻译过来表示：通用的意思，可以看出，是支持所有类。
@Bean@ConditionalOnMissingBean(name = "redisTemplate")public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(factory);//String的序列化方式StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();// 使用GenericJackson2JsonRedisSerializer 替换默认序列化(默认采用的是JDK序列化)GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();//key序列化方式采用String类型template.setKeySerializer(stringRedisSerializer);//value序列化方式采用jackson类型template.setValueSerializer(genericJackson2JsonRedisSerializer);//hash的key序列化方式也是采用String类型template.setHashKeySerializer(stringRedisSerializer);//hash的value也是采用jackson类型template.setHashValueSerializer(genericJackson2JsonRedisSerializer);template.afterPropertiesSet();return template;}}

运行下边的测试类测试GenericJackson2JsonRedisSerializer，发现不管是字符串还是对象还是数组都很通用

@Test
void redisTemplateSerializeTest() {String redisTemplateStringKey = "redisTemplateStringKey";String redisTemplateUserObjectKey = "redisTemplateUserObjectKey";String redisTemplateUserArrayObjectKey = "redisTemplateUserArrayObjectKey";String redisTemplateJSONObjectKey = "redisTemplateJSONObjectKey";String redisTemplateJSONArrayKey = "redisTemplateJSONArrayKey";//序列化String类型和反序列化String类型redisTemplate.opsForValue().set(redisTemplateStringKey, "austin");String austin = (String) redisTemplate.opsForValue().get(redisTemplateStringKey);System.out.println("stringGet: " + austin);//序列化Object对象类型和反序列化Object对象类型 (User对象)User user = new User("123", "austin", 25);redisTemplate.opsForValue().set(redisTemplateUserObjectKey, user);User userGet = (User) redisTemplate.opsForValue().get(redisTemplateUserObjectKey);System.out.println("userGet: " + userGet);//序列化Object对象数组类型和反序列化Object对象数组类型 (User[]对象数组)User user1 = new User("1", "austin1", 25);User user2 = new User("2", "austin2", 25);User[] userArray = new User[]{user1, user2};redisTemplate.opsForValue().set(redisTemplateUserArrayObjectKey, userArray);User[] userArrayGet = (User[]) redisTemplate.opsForValue().get(redisTemplateUserArrayObjectKey);System.out.println("userArrayGet: " + userArrayGet);//序列化JSONObject对象类型和反序列化JSONObject对象类型JSONObject jsonObject = new JSONObject();jsonObject.put("id", "123");jsonObject.put("name", "austin");jsonObject.put("age", 25);redisTemplate.opsForValue().set(redisTemplateJSONObjectKey, jsonObject);JSONObject jsonObjectGet = (JSONObject) redisTemplate.opsForValue().get(redisTemplateJSONObjectKey);System.out.println("jsonObjectGet: " + jsonObjectGet);//序列化JSONArray对象类型和反序列化JSONArray对象类型JSONArray jsonArray = new JSONArray();JSONObject jsonObject1 = new JSONObject();jsonObject1.put("id", "1");jsonObject1.put("name", "austin1");jsonObject1.put("age", 25);JSONObject jsonObject2 = new JSONObject();jsonObject2.put("id", "1");jsonObject2.put("name", "austin2");jsonObject2.put("age", 25);jsonArray.add(jsonObject1);jsonArray.add(jsonObject2);redisTemplate.opsForValue().set(redisTemplateJSONArrayKey, jsonArray);JSONArray jsonArrayGet = (JSONArray) redisTemplate.opsForValue().get(redisTemplateJSONArrayKey);System.out.println("jsonArrayGet: " + jsonArrayGet);
}

key- value ：

字符串类型
Key: redisTemplateStringKey
Value: "austin"


对象类型
Key: redisTemplateUserObjectKey
Value:
{
    "@class": "com.example.jedisserializefrombytestojson.User",
    "id": "123",
    "name": "austin",
    "age": 25
}
 
对象数组类型
Key: redisTemplateUserArrayObjectKey
Value: 
[
    "[Lcom.example.jedisserializefrombytestojson.User;",
    [
        {
            "@class": "com.example.jedisserializefrombytestojson.User",
            "id": "1",
            "name": "austin1",
            "age": 25
        },
        {
            "@class": "com.example.jedisserializefrombytestojson.User",
            "id": "2",
            "name": "austin2",
            "age": 25
        }
    ]
]
 

JSONObject类型
Key: redisTemplateJSONObjectKey
Value:
{
    "@class": "com.alibaba.fastjson.JSONObject",
    "name": "austin",
    "id": "123",
    "age": 25
}


JSONArray类型
Key: redisTemplateJSONArrayKey
Value: 
[
    "com.alibaba.fastjson.JSONArray",
    [
        {
            "@class": "com.alibaba.fastjson.JSONObject",
            "name": "austin1",
            "id": "1",
            "age": 25
        },
        {
            "@class": "com.alibaba.fastjson.JSONObject",
            "name": "austin2",
            "id": "1",
            "age": 25
        }
    ]
]

这篇关于RedisTemplate的配置和讲解以及和StringRedisTemplate的区别的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/436104。

相关文章

最新版IDEA配置 Tomcat的详细过程

最新版IDEA配置 Tomcat的详细过程

《最新版IDEA配置Tomcat的详细过程》本文介绍如何在IDEA中配置Tomcat服务器,并创建Web项目,首先检查Tomcat是否安装完成,然后在IDEA中创建Web项目并添加Web结构,接着,... 目录配置tomcat第一步，先给项目添加Web结构查看端口号配置tomcat    先检查自己的to
阅读更多...
结构体和联合体的区别及说明

结构体和联合体的区别及说明

《结构体和联合体的区别及说明》文章主要介绍了C语言中的结构体和联合体,结构体是一种自定义的复合数据类型,可以包含多个成员,每个成员可以是不同的数据类型,联合体是一种特殊的数据结构,可以在内存中共享同一... 目录结构体和联合体的区别1. 结构体(Struct)2. 联合体(Union)3. 联合体与结构体的
阅读更多...
Servlet中配置和使用过滤器的步骤记录

Servlet中配置和使用过滤器的步骤记录

《Servlet中配置和使用过滤器的步骤记录》：本文主要介绍在Servlet中配置和使用过滤器的方法,包括创建过滤器类、配置过滤器以及在Web应用中使用过滤器等步骤,文中通过代码介绍的非常详细,需... 目录创建过滤器类配置过滤器使用过滤器总结在Servlet中配置和使用过滤器主要包括创建过滤器类、配置过滤
阅读更多...
什么是 Ubuntu LTS？Ubuntu LTS和普通版本区别对比

什么是 Ubuntu LTS？Ubuntu LTS和普通版本区别对比

《什么是UbuntuLTS？UbuntuLTS和普通版本区别对比》UbuntuLTS是Ubuntu操作系统的一个特殊版本，旨在提供更长时间的支持和稳定性，与常规的Ubuntu版本相比，LTS版... 如果你正打算安装 Ubuntu 系统，可能会被「LTS 版本」和「普通版本」给搞得一头雾水吧？尤其是对于刚入
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
在Spring中配置Quartz的三种方式

在Spring中配置Quartz的三种方式

《在Spring中配置Quartz的三种方式》SpringQuartz是一个任务调度框架,它允许我们定期执行特定的任务,在Spring中,我们可以通过多种方式来配置Quartz,包括使用​​@Sche... 目录介绍使用 ​​@Scheduled​​ 注解XML 配置Java 配置1. 创建Quartz配置
阅读更多...
python中json.dumps和json.dump区别

python中json.dumps和json.dump区别

《python中json.dumps和json.dump区别》json.dumps将Python对象序列化为JSON字符串,json.dump直接将Python对象序列化写入文件,本文就来介绍一下两个... 目录1、json.dumps和json.dump的区别2、使用 json.dumps() 然后写入文
阅读更多...
Kibana的安装和配置全过程

Kibana的安装和配置全过程

《Kibana的安装和配置全过程》Kibana是一个开源的数据分析和可视化平台,它与Elasticsearch紧密集成,提供了一个直观的Web界面,使您可以快速地搜索、分析和可视化数据,在本文中,我们... 目录Kibana的安装和配置1.安装Java运行环境2.下载Kibana3.解压缩Kibana4.配
阅读更多...
tomcat在nginx中的配置方式

tomcat在nginx中的配置方式

《tomcat在nginx中的配置方式》文章介绍了如何在Linux系统上安装和配置Tomcat,并通过Nginx进行代理,首先,下载并解压Tomcat压缩包,然后启动Tomcat并查看日志,接着,配置... 目录一、下载安装tomcat二、启动tomcat三、配置nginx总结提示：文章写完后，目录可以自动
阅读更多...
Zookeeper安装和配置说明

Zookeeper安装和配置说明

一、Zookeeper的搭建方式 Zookeeper安装方式有三种，单机模式和集群模式以及伪集群模式。 ■ 单机模式：Zookeeper只运行在一台服务器上，适合测试环境； ■ 伪集群模式：就是在一台物理机上运行多个Zookeeper 实例； ■ 集群模式：Zookeeper运行于一个集群上，适合生产环境，这个计算机集群被称为一个“集合体”（ensemble） Zookeeper通过复制来实现
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2