lpz/intelligent-application-orchestration-service
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request '修改代码及服务发布的逻辑代码（无redis）' (#11) from xiaohucoding into main

Browse Source 
Reviewed-on: #11
This commit is contained in:
lpz
2025-05-22 16:09:16 +08:00
parent 19e6032ba7 f235f2d111
commit 56bfdad0c0
20 changed files with 567 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
doc/DesignDocument/模型服务表--hky.md Normal file
View File

@ -0,0 +1,16 @@
# 数据库设计文档
## 服务发布
### 服务发布
#### 1.服务发布表（service_publish）
| 序号 | 数据表名 | 中文名称 |
| ---- | -------- | ------------------ |
| 1 | id | 发布表id(发布记录唯一标识) |
| 2 | model_id | 模型id |
| 3 | api_url | api路径 |
| 4 | create_time | 发布请求创建时间 |
####

47
doc/WorkReport/2025-05-hky.md
View File

@ -40,13 +40,54 @@
## 2025年5月19日
### ✅ 今日完成
完成了服务发布的表设计
模型发布的数据库设计
### 🚧 进行中
缓存设计
模型发布的逻辑开发
### ⚠️ 问题/障碍
暂无
### 📅 明日计划
完成缓存设计，以及实体类设计
完成模型发布的逻辑开发
## 2025年5月20日
### ✅ 今日完成
服务发布逻辑开发（无GPU版）
### 🚧 进行中
redis设计
### ⚠️ 问题/障碍
暂无
### 📅 明日计划
完成redis设计，做完服务发布的逻辑开发
## 2025年5月21日
### ✅ 今日完成
redis的服务器配置
### 🚧 进行中
开发服务发布的redis内容
### ⚠️ 问题/障碍
如何把model_version表中的配置中相关GPU资源的内容提取出来。
### 📅 明日计划
完成服务发布的开发
## 2025年5月22日
### ✅ 今日完成
服务发布，拦截器部分功能
### 🚧 进行中
拦截器等待队列算法
### ⚠️ 问题/障碍
不知道怎么优先分配等待队列中任务
### 📅 明日计划
完成拦截器功能

10
pom.xml
View File

@ -1,11 +1,11 @@
<?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">
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.4.5</version>
<version>3.2.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.bipt</groupId>
@ -27,7 +27,7 @@
<url/>
</scm>
<properties>
<java.version>24</java.version>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
@ -39,6 +39,10 @@
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>

26
src/main/java/com/bipt/intelligentapplicationorchestrationservice/config/RedisConfiguration.java Normal file
View File

@ -0,0 +1,26 @@
package com.bipt.intelligentapplicationorchestrationservice.config;
import lombok.extern.slf4j.Slf4j;
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;
@Configuration
@Slf4j
public class RedisConfiguration {
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
log.info("开始创建redis模板对象...");
RedisTemplate redisTemplate = new RedisTemplate();
//设置redis的连接工厂对象
redisTemplate.setConnectionFactory(redisConnectionFactory);
//设置redis key的序列化器
redisTemplate.setKeySerializer(new StringRedisSerializer());
return redisTemplate;
}
}

2
src/main/java/com/bipt/intelligentapplicationorchestrationservice/constant/MessageConstant.java
View File

@ -2,5 +2,5 @@ package com.bipt.intelligentapplicationorchestrationservice.constant;
public class MessageConstant {
public static final String UNKNOWN_ERROR = "未知错误";
public static final String ALREADY_EXISTS = "数据集已存在";
public static final String ALREADY_EXISTS = "已存在";
}

13
src/main/java/com/bipt/intelligentapplicationorchestrationservice/constant/StatusConstant.java Normal file
View File

@ -0,0 +1,13 @@
package com.bipt.intelligentapplicationorchestrationservice.constant;
/**
* 状态常量，启用或者禁用
* @author hky
*/
public class StatusConstant {
//启用
public static final Integer ENABLE = 1;
//禁用
public static final Integer DISABLE = 0;
}

8
src/main/java/com/bipt/intelligentapplicationorchestrationservice/controller/DatasetController.java
View File

@ -2,12 +2,14 @@ package com.bipt.intelligentapplicationorchestrationservice.controller;
import com.bipt.intelligentapplicationorchestrationservice.pojo.*;
import com.bipt.intelligentapplicationorchestrationservice.service.DatasetService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Tag(name ="数据集相关接口")
@RestController
@RequestMapping("/dataset")
@Slf4j
@ -20,6 +22,7 @@ public class DatasetController {
* @param datasetDTO
* @return
*/
@Operation(summary ="新增数据集")
@PostMapping
public OptResult save(@RequestBody DatasetDTO datasetDTO) {
log.info("新增数据集:{}", datasetDTO);
@ -32,6 +35,7 @@ public class DatasetController {
* @param dataSetPageQueryDTO
* @return
*/
@Operation(summary ="分页查询")
@GetMapping("/page")
public OptResult<PageResult> page(DatasetPageQueryDTO dataSetPageQueryDTO) {
log.info("数据集分页查询:{}", dataSetPageQueryDTO);
@ -45,6 +49,7 @@ public class DatasetController {
* @param datasetDTO
* @return
*/
@Operation(summary ="修改数据集")
@PutMapping
public OptResult update(@RequestBody DatasetDTO datasetDTO){
log.info("修改数据集",datasetDTO);
@ -59,6 +64,7 @@ public class DatasetController {
* @param datasetIds 数据集ID列表
* @return 操作结果
*/
@Operation(summary ="删除数据集")
@DeleteMapping
public OptResult<String> deleteBatch(@RequestBody List<Long> datasetIds) {
log.info("批量删除数据集，ID列表：{}", datasetIds);

112
src/main/java/com/bipt/intelligentapplicationorchestrationservice/controller/publishController.java Normal file
View File

@ -0,0 +1,112 @@
package com.bipt.intelligentapplicationorchestrationservice.controller;
import com.bipt.intelligentapplicationorchestrationservice.config.RedisConfiguration;
import com.bipt.intelligentapplicationorchestrationservice.pojo.*;
import com.bipt.intelligentapplicationorchestrationservice.service.PublishService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@Tag(name ="服务发布相关接口")
@RestController
@RequestMapping("/publish")
@Slf4j
public class publishController {
@Autowired
private PublishService publishService;
@Autowired
private RedisTemplate redisTemplate;
/**
* 新增请求发布
* @param servicePublishDTO
* @return
*/
@PostMapping
@Operation(summary ="新增发布请求")
@Transactional
public OptResult<List<ServicePublishVO>> save(@RequestBody ServicePublishDTO servicePublishDTO) {
log.info("模型发布请求:{}", servicePublishDTO);
publishService.save(servicePublishDTO);
Long modelId = servicePublishDTO.getModelId();
String key = "Model_" + modelId;
//查询redis是否存在GPU相关资源数据
List<ServicePublishVO> list;
list = (List<ServicePublishVO>) redisTemplate.opsForValue().get(key);
//如果存在，直接返回，无须查询数据库
if (list != null) {
return OptResult.success(list);
}else {
list = new ArrayList<>();
}
String modelConfig = publishService.getByModelId(modelId);
if (modelConfig == null) {
log.error("模型配置为空，modelId={}", modelId);
}
String[] keyValuePairs = modelConfig.split("\\|");
String GPUMemorySize = null;
String GPUModel = null;
for (String pair : keyValuePairs) {
pair = pair.trim();
if (pair.startsWith("GPU")) {
GPUModel = pair.split(";", 2)[1];
} else if (pair.startsWith("Memory:")) {
GPUMemorySize = pair.split(":", 2)[1];
}
}
ServicePublishVO servicePublishVO = new ServicePublishVO();
servicePublishVO.setIp(servicePublishDTO.getIp());
servicePublishVO.setModelId(servicePublishDTO.getModelId());
servicePublishVO.setGPUMemorySize(GPUMemorySize);
servicePublishVO.setGPUModel(GPUModel);
//todo 调用模型部署，传递信息
servicePublishVO.setApiUrl(servicePublishDTO.getApiUrl());
list.add(servicePublishVO);
redisTemplate.opsForValue().set(key,list);
//一个ip上有多个机器
// 假设从 Redis 获取的列表元素是 MachineInfo 类型
String ip = servicePublishVO.getIp();
String key1 = ip;
List<MachineInfo> machineList = (List<MachineInfo>) redisTemplate.opsForValue().get(key1);
// 模型所需的 GPU 资源
String requiredGPUModel = servicePublishVO.getGPUModel();
Integer requiredGPUMemory = Integer.valueOf(servicePublishVO.getGPUMemorySize());
if (machineList != null) {
for (MachineInfo machine : machineList) {
// 获取机器的 GPU 资源
String machineGPUModel = machine.getGPUModel();
Integer machineGPUMemory = machine.getGPUMemorySize();
// 判断机器是否满足模型需求
if (requiredGPUModel.equals(machineGPUModel) &&
machineGPUMemory >= requiredGPUMemory) {
return OptResult.success(list);
}
}
String key3 = "wait_queue";
redisTemplate.opsForValue().set(key3,list);
//todo资源释放时候优先分配等待队列中任务
}
return OptResult.success(list);
}
}

35
src/main/java/com/bipt/intelligentapplicationorchestrationservice/enumeration/DatasetType.java Normal file
View File

@ -0,0 +1,35 @@
package com.bipt.intelligentapplicationorchestrationservice.enumeration;
import lombok.Getter;
/**
* @author hky
*/
@Getter
public enum DatasetType {
UPLOAD(0,"用户上传"),
FROM_DATABASE(1,"来源于数据库");
private final Integer code;
private final String description;
DatasetType(Integer code, String description) {
this.code = code;
this.description = description;
}
/**
* 根据状态码获取对应的枚举值
* @param code 状态码
* @return 对应的枚举值
*/
public static DatasetType fromCode(Integer code) {
for (DatasetType datasetType : DatasetType.values()) {
if (datasetType.getCode().equals(code)) {
return datasetType;
}
}
throw new IllegalArgumentException("无效的数据集状态码: " + code);
}
}

20
src/main/java/com/bipt/intelligentapplicationorchestrationservice/mapper/PublishMapper.java Normal file
View File

@ -0,0 +1,20 @@
package com.bipt.intelligentapplicationorchestrationservice.mapper;
import com.bipt.intelligentapplicationorchestrationservice.pojo.ModelVersion;
import com.bipt.intelligentapplicationorchestrationservice.pojo.ServicePublishDTO;
import com.bipt.intelligentapplicationorchestrationservice.pojo.ServicePublishVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
@Mapper
public interface PublishMapper {
void insert(ServicePublishDTO servicePublishDTO);
Long getByApiUrl(String apiUrl);
@Select("select model_config from model_version where model_id=#{modelId} and status = 1")
String getById(Long modelId);
}

39
src/main/java/com/bipt/intelligentapplicationorchestrationservice/pojo/MachineInfo.java Normal file
View File

@ -0,0 +1,39 @@
package com.bipt.intelligentapplicationorchestrationservice.pojo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
import java.util.Map;
/**
* 机器信息实体类
* @author hky
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MachineInfo implements Serializable {
private static final long serialVersionUID = 1L;
private String id; // 机器唯一标识
private String ip; // IP 地址
private String hostname; // 主机名
private Integer cpuCoreNum; // CPU 核心数
private Long memoryTotal; // 总内存 (MB)
private Long memoryUsed; // 已用内存 (MB)
private String GPUModel; // GPU 型号
private Integer GPUMemorySize; // GPU 显存大小 (GB)
private Integer GPUCount; // GPU 数量
private Integer status; // 机器状态 (0: 离线, 1: 在线, 2: 繁忙)
private String os; // 操作系统
private String region; // 所属区域
private String zone; // 可用区
private Date createTime; // 创建时间
private Date updateTime; // 更新时间
private Map<String, String> labels; // 自定义标签
}

23
src/main/java/com/bipt/intelligentapplicationorchestrationservice/pojo/ServicePublish.java Normal file
View File

@ -0,0 +1,23 @@
package com.bipt.intelligentapplicationorchestrationservice.pojo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author hky
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ServicePublish implements Serializable {
private Long modelId;
private String GPUModel;
private String ip;
private String GPUMemorySize;
}

23
src/main/java/com/bipt/intelligentapplicationorchestrationservice/pojo/ServicePublishDTO.java Normal file
View File

@ -0,0 +1,23 @@
package com.bipt.intelligentapplicationorchestrationservice.pojo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author hky
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ServicePublishDTO implements Serializable {
private Long id;
private Long modelId;
private String apiUrl;
private LocalDateTime createTime;
private String ip;
}

26
src/main/java/com/bipt/intelligentapplicationorchestrationservice/pojo/ServicePublishVO.java Normal file
View File

@ -0,0 +1,26 @@
package com.bipt.intelligentapplicationorchestrationservice.pojo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* @author hky
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ServicePublishVO implements Serializable {
private Long modelId;
private String GPUModel;
private String ip;
private String GPUMemorySize;
private String apiUrl;
}

56
src/main/java/com/bipt/intelligentapplicationorchestrationservice/service/Impl/DatasetServiceImpl.java
View File

@ -1,5 +1,7 @@
package com.bipt.intelligentapplicationorchestrationservice.service.Impl;
import com.bipt.intelligentapplicationorchestrationservice.constant.StatusConstant;
import com.bipt.intelligentapplicationorchestrationservice.enumeration.DatasetType;
import com.bipt.intelligentapplicationorchestrationservice.mapper.DatasetMapper;
import com.bipt.intelligentapplicationorchestrationservice.pojo.*;
import com.bipt.intelligentapplicationorchestrationservice.service.DatasetService;
@ -15,6 +17,8 @@ import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import static com.bipt.intelligentapplicationorchestrationservice.enumeration.DatasetType.FROM_DATABASE;
@Service
@Slf4j
public class DatasetServiceImpl implements DatasetService {
@ -29,20 +33,26 @@ public class DatasetServiceImpl implements DatasetService {
@Transactional
public void save(DatasetDTO datasetDTO) {
//判断数据集类型，如果是本地上传则保存，若用调用数据仓库进入下一步
if (datasetDTO.getDatasetType()==0){
//TODO 保存到分布式文件系统
// 获取数据集类型
DatasetType datasetType = DatasetType.fromCode(datasetDTO.getDatasetType());
// 根据类型处理数据
switch (datasetType) {
case UPLOAD:
//TODO 保存到分布式文件系统
break;
case FROM_DATABASE:
String args = datasetDTO.getArgs();
//TODO 根据筛选条件调用数据仓库中的数据
}else {
// Map<String,String> args = datasetDTO.getArgs();
String args = datasetDTO.getArgs();
int datasetType = datasetDTO.getDatasetType();
//TODO 根据筛选条件调用数据仓库中的数据
//TODO 调用数据仓库保存到分布式文件系统
//TODO 调用数据仓库保存到分布式文件系统
break;
default:
throw new IllegalArgumentException("不支持的数据集类型: " + datasetType);
}
DatasetEntity datasetEntity = new DatasetEntity();
BeanUtils.copyProperties(datasetDTO,datasetEntity);
datasetEntity.setDatasetStatus(1);
datasetEntity.setDatasetStatus(StatusConstant.ENABLE);
datasetEntity.setCreateTime(LocalDateTime.now());
datasetEntity.setUpdateTime(LocalDateTime.now());
datasetMapper.insert(datasetEntity);
@ -59,15 +69,18 @@ public class DatasetServiceImpl implements DatasetService {
public void update(DatasetDTO datasetDTO) {
/*DatasetEntity datasetEntity = new DatasetEntity();
BeanUtils.copyProperties(datasetDTO,datasetEntity);*/
if (datasetDTO.getDatasetType()==0){
//TODO 覆盖保存到分布式文件系统中
}else {
//TODO 覆盖数据文件
//TODO
DatasetType datasetType = DatasetType.fromCode(datasetDTO.getDatasetType());
// 根据类型处理数据
switch (datasetType) {
case UPLOAD:
//TODO 覆盖保存到分布式文件系统中
break;
case FROM_DATABASE:
//TODO 覆盖数据文件
break;
default:
throw new IllegalArgumentException("不支持的数据集类型: " + datasetType);
}
DatasetEntity datasetEntity = new DatasetEntity();
BeanUtils.copyProperties(datasetDTO,datasetEntity);
@ -94,14 +107,7 @@ public class DatasetServiceImpl implements DatasetService {
@Override
@Transactional
public void deleteBatch(List<Long> datasetIds) {
for (Long datasetId : datasetIds) {
DatasetEntity datasetEntity = datasetMapper.getById(datasetId);
if (datasetEntity == null) {
throw new IllegalArgumentException("数据集不存在，ID：" + datasetId);
}
}
//TODO 在分布式文件系统中删除
datasetMapper.deleteBatch(datasetIds);
}

46
src/main/java/com/bipt/intelligentapplicationorchestrationservice/service/Impl/PublishServiceImpl.java Normal file
View File

@ -0,0 +1,46 @@
package com.bipt.intelligentapplicationorchestrationservice.service.Impl;
import com.bipt.intelligentapplicationorchestrationservice.mapper.PublishMapper;
import com.bipt.intelligentapplicationorchestrationservice.pojo.ServicePublishDTO;
import com.bipt.intelligentapplicationorchestrationservice.service.PublishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* @author hky
*/
@Service
@Slf4j
public class PublishServiceImpl implements PublishService {
@Autowired
private PublishMapper publishMapper;
/**
* 新增服务请求
* @param servicePublishDTO
*/
@Override
@Transactional
public void save(ServicePublishDTO servicePublishDTO) {
String apiUrl = servicePublishDTO.getApiUrl();
Long id = publishMapper.getByApiUrl(apiUrl);
if (id != null){
throw new IllegalArgumentException("请求已存在: " + apiUrl);
}
publishMapper.insert(servicePublishDTO);
}
/**
* 根据id查找配置信息
* @param modelId
* @return
*/
@Override
public String getByModelId(Long modelId) {
return publishMapper.getById(modelId);
}
}

13
src/main/java/com/bipt/intelligentapplicationorchestrationservice/service/PublishService.java Normal file
View File

@ -0,0 +1,13 @@
package com.bipt.intelligentapplicationorchestrationservice.service;
import com.bipt.intelligentapplicationorchestrationservice.pojo.ServicePublishDTO;
public interface PublishService {
void save(ServicePublishDTO servicePublishDTO);
String getByModelId(Long modelId);
}

11
src/main/resources/application.properties
View File

@ -16,3 +16,14 @@ mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.bipt.intelligentapplicationorchestrationservice.pojo
# 开启驼峰命名转换
mybatis.configuration.map-underscore-to-camel-case=true
# Redis服务器地址
spring.data.redis.host=116.205.121.200
# Redis服务器端口
spring.data.redis.port=6379
# Redis密码（如果有）
spring.data.redis.password=Jbjhhzstsl97@
# Redis数据库索引（默认为0）
spring.data.redis.database = 0
# 连接超时时间（毫秒）
spring.data.redis.timeout = 3000

20
src/main/resources/mapper/PublishMapper.xml Normal file
View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bipt.intelligentapplicationorchestrationservice.mapper.PublishMapper">
<insert id="insert">
INSERT INTO service_publish
(id,model_id,api_url,create_time)
values (#{id}, #{modelId}, #{apiUrl}, #{createTime})
</insert>
<select id="getByApiUrl" resultType="java.lang.Long">
SELECT id FROM service_publish WHERE api_url = #{apiUrl};
</select>
<select id="getByModelId"
resultType="com.bipt.intelligentapplicationorchestrationservice.pojo.ServicePublishVO">
select
sp.api_url,
mv.*
from model_version mv join service_publish sp on mv.model_id = sp.model_id
</select>
</mapper>

53
src/test/java/com/bipt/intelligentapplicationorchestrationservice/RedisTest.java Normal file
View File

@ -0,0 +1,53 @@
package com.bipt.intelligentapplicationorchestrationservice;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@SpringBootTest
public class RedisTest {
@Autowired
private RedisTemplate redisTemplate;
@Test
public void testRedisTemplate(){
System.out.println(redisTemplate);
ValueOperations valueOperations = redisTemplate.opsForValue();
HashOperations hashOperations = redisTemplate.opsForHash();
ListOperations listOperations = redisTemplate.opsForList();
SetOperations setOperations = redisTemplate.opsForSet();
ZSetOperations zSetOperations = redisTemplate.opsForZSet();
}
@Test
public void testString(){
//set get setex setnx
redisTemplate.opsForValue().set("name","小明");
String city =(String) redisTemplate.opsForValue().get("name");
System.out.println(city);
redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);
redisTemplate.opsForValue().setIfAbsent("lock","1");
redisTemplate.opsForValue().setIfAbsent("lock","2");
}
@Test
public void testHash(){
// hset hget hdel hkeys hvals
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.put("100","name","tom");
hashOperations.put("100","age","20");
String name = (String) hashOperations.get("100", "name");
System.out.println(name);
Set keys = hashOperations.keys("100");
System.out.println(keys);
List values = hashOperations.values("100");
System.out.println(values);
hashOperations.delete("100","age");
}
}