缓存整合优化 v0.01

(cherry picked from commit 29aa9a24aa6264f84f356157ec14e7c0f77a8ae1)

launch-admin/src/main/java/com/webflux/launchadmin/config/ReactiveRedisConfig.java

@@ -0,0 +1,101 @@
+package com.webflux.launchadmin.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.weblux.launchredis.test.DomainTest;
+import com.weblux.launchredis.test.TweetTest;
+import com.weblux.launchredis.test.User;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+
+/**
+ * 反应redis配置
+ */
+@Configuration
+@EnableCaching
+public class ReactiveRedisConfig {
+
+    @Bean
+    public RedisSerializationContext<String, Object> redisSerializationContext() {
+        RedisSerializationContext.RedisSerializationContextBuilder<String, Object> builder =
+                RedisSerializationContext.newSerializationContext();
+        Jackson2JsonRedisSerializer<Object> redisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
+        ObjectMapper om = new ObjectMapper();
+        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        redisSerializer.setObjectMapper(om);
+
+        builder.key(new StringRedisSerializer());
+        builder.value(redisSerializer);
+        builder.hashKey(new StringRedisSerializer());
+        builder.hashValue(redisSerializer);
+
+        return builder.build();
+    }
+
+    /**
+     * Configures a {@link ReactiveRedisTemplate} with {@link String} keys and a typed
+     * {@link Jackson2JsonRedisSerializer}.
+     */
+    @Bean
+    public ReactiveRedisTemplate<String, User> reactiveJsonUserRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<User>(User.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, User> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+    @Bean
+    public ReactiveRedisTemplate<String, DomainTest> reactiveJsonDomainTestRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<DomainTest>(DomainTest.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, DomainTest> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+
+    @Bean
+    public ReactiveRedisTemplate<String, TweetTest> reactiveJsonTweetTestRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<TweetTest>(TweetTest.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, TweetTest> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+
+    @Bean
+    public ReactiveRedisTemplate<String, Object> reactiveRedisTemplate(ReactiveRedisConnectionFactory factory) {
+        RedisSerializationContext<String, Object> serializationContext = RedisSerializationContext
+                .<String, Object>newSerializationContext(new StringRedisSerializer())
+                .hashKey(new StringRedisSerializer())
+                .hashValue(new Jackson2JsonRedisSerializer<>(Object.class))
+                .build();
+
+        return new ReactiveRedisTemplate<>(factory, serializationContext);
+    }
+
+
+}
+

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/BackgroupGroupController.java

@@ -0,0 +1,38 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.SourceMaterialInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.MaterialManagementInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Mono;
+
+/**
+ * 背景组设置
+ * @author lw12420
+ * @date 2024/08/01
+ */
+@RestController
+@RequestMapping("/in/background/")
+public class BackgroupGroupController {
+
+    @Resource
+    private MaterialManagementInterface sourceMaterialInterface;
+
+
+    /**
+     * 列表查询
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link BackgroupImage}>>>
+     */
+    @GetMapping("list")
+    public Mono<RStatus<Paged<BackgroupImageRes>>> pageBackgroup(Integer page, Integer size){
+       return  sourceMaterialInterface.pageBackgroup(page,size);
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/BackgroupGroup/BackgroupImageReq.java

@@ -0,0 +1,22 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+import org.springframework.data.annotation.Id;
+
+import java.time.ZonedDateTime;
+@Data
+public class BackgroupImageReq {
+    private   Long id;
+    private String name;
+    private  String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private  ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime deletedAt;
+    private Integer groupType;
+    private String groupTypeName;
+    private Integer groupTypeId;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/BackgroupGroup/BackgroupImageRes.java

@@ -0,0 +1,21 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import java.time.ZonedDateTime;
+
+public class BackgroupImageRes {
+    private   Long id;
+    private String name;
+    private  String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime deletedAt;
+    private Integer groupType;
+    private String groupTypeName;
+    private Integer groupTypeId;
+    private String image;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/testController.java

@@ -7,20 +7,15 @@ import cn.hutool.json.JSONUtil;
 import com.webflux.launchadmin.context.UserContext;
 import com.webflux.launchadmin.context.XxlSsoUser;
 import com.webflux.launchadmin.mysql.entity.listening.ListeningAudio;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
 import com.webflux.launchadmin.mysql.entity.planNew.Image;
 import com.webflux.launchadmin.mysql.entity.test.Tweet;
 import com.webflux.launchadmin.mysql.repository.test.TweetRepository;
 import com.webflux.launchadmin.mysql.task.SyncImageToRedis;
+import com.webflux.launchadmin.mysql.service.test.TweetService;
 import com.webflux.launchadmin.mysql.task.SyncListeningAudioToRedis;
-import com.webflux.launchadmin.mysql.task.SyncPlanNewListenToRedis;
 import com.webflux.launchcommon.returnObj.Paged;
-import com.webflux.launchcommon.returnObj.RData;
 import com.webflux.launchcommon.returnObj.RStatus;
-import io.r2dbc.spi.Connection;
-import io.r2dbc.spi.ConnectionFactories;
-import io.r2dbc.spi.ConnectionFactory;
-import io.r2dbc.spi.ConnectionMetadata;
+import com.weblux.launchredis.test.TweetTest;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.http.HttpEntity;
@@ -37,6 +32,7 @@ import org.springframework.data.relational.core.query.Criteria;
 import org.springframework.data.relational.core.query.Query;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import reactor.core.publisher.Mono;
 
@@ -63,16 +59,28 @@ public class testController {
     private SyncImageToRedis redis;
     @Resource
     private SyncListeningAudioToRedis redis1;
+
+    @Resource
+    TweetService tweetService;
+
+
     @GetMapping("get5")
     public Mono<List<ListeningAudio>>  get5()   {
         redis1.syncLinteningAudioPlan();
         return redis1.byRedisGetLinteningAudioIfErByMysql(3);
     }
+
     @GetMapping("get8")
-    public Mono<Void>  get8()   {
+    public Mono<Void>  get8() {
         redis1.deleteAll();
         return Mono.empty();
     }
+    @GetMapping("get9")
+    public Mono<TweetTest>  get9(@RequestParam("id") Long id)   {
+        //return syncPlanNewListenToRedis.syncLinteningPlan();
+        Mono<TweetTest> personById = tweetService.getPersonById(id);
+        return personById;
+    }
     @GetMapping("get4")
     public Mono<List<Image>>  get4()   {
         redis.syncImagePlan();

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/planNew/PlanNew.java

@@ -5,10 +5,11 @@ import io.r2dbc.spi.Parameter;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.io.Serializable;
 import java.time.ZonedDateTime;
 
 @Table("plan_new")
-public record PlanNew(
+public record PlanNew  (
         @Id
         String planNewId,
         String name, //计划名
@@ -51,5 +52,5 @@ public record PlanNew(
         String listButton,
         Integer groupListDisplay
 
-) {
+) implements Serializable{
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/SourceMaterialImpl.java

@@ -0,0 +1,177 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial;
+
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.planNew.req.PosterTemplateRequset;
+import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.PosterTemplate;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql.Where;
+import com.webflux.launchadmin.mysql.task.SyncPlanNewListenToRedis;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.data.relational.core.query.Update;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.RequestBody;
+import reactor.core.publisher.Mono;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.function.Function;
+
+
+@Service
+public class SourceMaterialImpl implements SourceMaterialInterface{
+    @Resource
+    private R2dbcEntityTemplate template;
+    @Override
+    public <T> Mono<RStatus<Paged<T>>> page(List<Where> wheres, Class<T> domainType,Integer size ,Integer page){
+      return   pageAndFunction(wheres, domainType,  size ,  page, (x)-> x);
+    }
+    @Override
+    public <T> Mono<RStatus<Paged<T>>> pageAndFunction(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,List<T>> function){
+        Criteria criteria = Criteria.empty();
+        if (!wheres.isEmpty()) {
+            for (Where entry: wheres){
+                String key = entry.getKey();
+                Object value = entry.getValue();
+                if(entry.getWhereType()==1){
+                    criteria=criteria.and(key).is(value);
+                }
+                if(entry.getWhereType()==2){
+                    criteria=criteria.and(key).like("%"+value+"%");
+                }
+                if(entry.getWhereType()==3){
+                    criteria=criteria.and(key).in(value);
+                }
+            }
+        }
+        Query query = Query.query(criteria);
+        Criteria finalCriteria = criteria;
+        Mono<Paged<T>> pagedMono = template.count(query, domainType).flatMap(fm ->
+                template.select(Query.query(finalCriteria)
+                        .offset((long) (page - 1) * size)
+                        .limit(size)
+                        .sort(Sort.by(Sort.Order.asc("created_at"))), domainType)
+                        .collectList()
+                        .map(list -> {
+                                    List<T> apply = function.apply(list);
+                                    return new Paged<T>(fm, apply, page, size);
+                                }
+                        )
+        );
+        return RStatus.successList(pagedMono);
+    }
+    @Override
+    public <T,E> Mono<RStatus<Paged<E>>> pageAndFunctionRtE(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,List<E>> function){
+        Criteria criteria = Criteria.empty();
+        if (!wheres.isEmpty()) {
+            for (Where entry: wheres){
+                String key = entry.getKey();
+                Object value = entry.getValue();
+                if(entry.getWhereType()==1){
+                    criteria=criteria.and(key).is(value);
+                }
+                if(entry.getWhereType()==2){
+                    criteria=criteria.and(key).like("%"+value+"%");
+                }
+                if(entry.getWhereType()==3){
+                    criteria=criteria.and(key).in(value);
+                }
+            }
+        }
+        Query query = Query.query(criteria);
+        Criteria finalCriteria = criteria;
+        Mono<Paged<E>> pagedMono = template.count(query, domainType).flatMap(fm ->
+                template.select(Query.query(finalCriteria)
+                        .offset((long) (page - 1) * size)
+                        .limit(size)
+                        .sort(Sort.by(Sort.Order.asc("created_at"))), domainType)
+                        .collectList()
+                        .map(list -> {
+                            List<E> apply = function.apply(list);
+                            return new Paged<E>(fm, apply, page, size);
+                                }
+                        )
+        );
+        return RStatus.successList(pagedMono);
+    }
+    @Override
+    public <T>  Mono<RStatus<Long>> deleteById(String column, Long columnValue,Class<T> domainType) {
+        return RStatus.success(template.delete(Query.query(Criteria.where(column).is(columnValue)),domainType));
+    }
+    @Override
+    public <T>  Mono<RStatus<Long>> deleteByIdDeleteAt(String column, Long columnValue,Class<T> domainType,String delete) {
+        Update update =Update.update(delete, ZonedDateTime.now());
+        Query query = Query.query(Criteria.where("column").is(columnValue));
+        return RStatus.success(template.update(query, update, domainType));
+    }
+    @Override
+    public <T> Mono<RStatus<T>> save( String ObjStr,Class<T> domainType) {
+        T t = strParseT(ObjStr, domainType);
+        Mono<T> insert = template.insert(t);
+        return RStatus.success(insert);
+    }
+    @Override
+    public <T> Mono<RStatus<T>> update( String ObjStr,Class<T> domainType) {
+        T t = strParseT(ObjStr, domainType);
+        Mono<T> insert = template.update(t);
+        return RStatus.success(insert);
+    }
+    @Override
+    public  <T> String  tToString(T t) {
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        try {
+            // 将 record 转换为 JSON 字符串
+            return objectMapper.writeValueAsString(t);
+        } catch (JsonProcessingException e) {
+            throw new BaseException(" 将对象转换为JSON字符串异常：："+e.getMessage());
+        }
+    }
+    @Override
+    public <T> T strParseT(String str,Class<T> domainType) {
+        // 创建 ObjectMapper 实例并配置
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(ZonedDateTime.class, new CustomZonedDateTimeDeserializer());
+        objectMapper.registerModule(module);
+        try {
+            // 将 JSON 字符串转换为 record
+            return objectMapper.readValue(str,domainType);
+        } catch (JsonProcessingException e) {
+            throw new BaseException(" 将JSON字符串转换异常：：："+e.getMessage());
+        }
+    }
+    public static class CustomZonedDateTimeDeserializer extends JsonDeserializer<ZonedDateTime> {
+        private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        @Override
+        public ZonedDateTime deserialize(JsonParser p, DeserializationContext ctxt)
+                throws IOException, JsonProcessingException {
+            String date = p.getText();
+            LocalDateTime localDateTime = LocalDateTime.parse(date, FORMATTER);
+            // 使用系统默认时区，可以根据需要修改
+            return ZonedDateTime.of(localDateTime, ZoneId.systemDefault());
+        }
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/SourceMaterialInterface.java

@@ -0,0 +1,91 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.entity.planNew.PosterTemplate;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql.Where;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.web.bind.annotation.PathVariable;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.function.Function;
+
+public interface SourceMaterialInterface {
+    /**
+     * 通用查询
+     * @param wheres
+     * @param domainType
+     * @param size
+     * @param page
+     * @param <T>
+     * @return
+     */
+     <T> Mono<RStatus<Paged<T>>> page(List<Where> wheres, Class<T> domainType, Integer size , Integer page);
+    /**
+     * 通用查询 结果进行Function函数处理
+     * @param wheres
+     * @param domainType
+     * @param size
+     * @param page
+     * @param <T>
+     * @return
+     */
+     <T> Mono<RStatus<Paged<T>>> pageAndFunction(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,List<T>> function);
+     <T,E> Mono<RStatus<Paged<E>>> pageAndFunctionRtE(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,List<E>> function);
+    /**
+     * 物理通过id删除
+     * @param column
+     * @param columnValue
+     * @param domainType
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    <T>  Mono<RStatus<Long>> deleteById(String column, Long columnValue,Class<T> domainType);
+
+    /**
+     * 逻辑删除
+     * @param column
+     * @param columnValue
+     * @param domainType
+     * @param delete column
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+     <T>  Mono<RStatus<Long>> deleteByIdDeleteAt(String column, Long columnValue,Class<T> domainType,String delete);
+
+    /**
+     * 保存
+     * @param ObjStr
+     * @param domainType
+     * @return {@link Mono}<{@link RStatus}<{@link T}>>
+     */
+    <T> Mono<RStatus<T>> save( String ObjStr,Class<T> domainType);
+
+    /**
+     * 修改
+     * @param ObjStr
+     * @param domainType
+     * @return {@link Mono}<{@link RStatus}<{@link T}>>
+     */
+    <T> Mono<RStatus<T>> update( String ObjStr,Class<T> domainType);
+
+    /**
+     * 静态对象转string
+     * @param t
+     * @return {@link String}
+     */
+    <T> String  tToString(T t);
+
+
+    /**
+     * String转静态对象
+     * @param str
+     * @param domainType
+     * @return {@link T}
+     */
+    <T> T strParseT(String str,Class<T> domainType);
+
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/data/sql/Where.java

@@ -0,0 +1,13 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql;
+
+import lombok.Data;
+
+@Data
+public class Where {
+    private String key;
+    private Object value;
+    /**
+     * 1:eq 2:like 3:in
+     */
+    private Integer whereType;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/MaterialManagementImpl.java

@@ -0,0 +1,36 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement;
+
+import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.SourceMaterialInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class MaterialManagementImpl implements MaterialManagementInterface {
+
+    @Resource
+    private SourceMaterialInterface sourceMaterialInterface;
+    @Resource
+    private R2dbcEntityTemplate template;
+    @Override
+    public Mono<RStatus<Paged<BackgroupImageRes>>> pageBackgroup(Integer page, Integer size) {
+        sourceMaterialInterface.pageAndFunctionRtE(List.of(),BackgroupImage.class,size,page,(f)->{
+          return  f.stream().map(fe->{
+              String string = sourceMaterialInterface.tToString(fe);
+              BackgroupImageRes backgroupImageRes1 = sourceMaterialInterface.strParseT(string, BackgroupImageRes.class);
+              BackgroupImageRes backgroupImageRes = new BackgroupImageRes();
+                return backgroupImageRes;
+            }).collect(Collectors.toList());
+        });
+
+        return null;
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/MaterialManagementInterface.java

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement;
+
+import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import reactor.core.publisher.Mono;
+
+public interface MaterialManagementInterface {
+    Mono<RStatus<Paged<BackgroupImageRes>>> pageBackgroup(Integer page, Integer size);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/test/TweetService.java

@@ -1,15 +1,65 @@
 package com.webflux.launchadmin.mysql.service.test;
 
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
 import com.webflux.launchadmin.mysql.entity.test.Tweet;
 import com.webflux.launchadmin.mysql.repository.test.TweetRepository;
+import com.weblux.launchredis.test.TweetTest;
 import jakarta.annotation.Resource;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.stereotype.Service;
 import org.springframework.web.reactive.DispatcherHandler;
 import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 
 @Service
 public class TweetService {
+
+    @Resource
+    private R2dbcEntityTemplate template;
+
+    // 读取缓存，如果缓存中有则直接返回，没有则从数据库查询并缓存
+    @Cacheable(cacheNames = "TweetTest", key = "#id")
+    public Mono<TweetTest> getPersonById(Long id) {
+        return template.selectOne(Query.query(Criteria.where("id").is(id)), TweetTest.class);
+    }
+
+    // 更新缓存，每次调用该方法时都会更新缓存
+    @CachePut(cacheNames = "TweetTest", key = "#tweetTest.id")
+    public Mono<TweetTest> updatePerson(TweetTest tweetTest) {
+        return template.update(tweetTest);
+    }
+
+    // 删除缓存
+    @CacheEvict(cacheNames = "TweetTest", key = "#id")
+    public Mono<Long> deletePersonById(Long id) {
+        return template.delete(Query.query(Criteria.where("id").is(id)), TweetTest.class);
+    }
+
+    // 清除整个缓存
+    @CacheEvict(cacheNames = "TweetTest", allEntries = true)
+    public Mono<Void> clearCache() {
+        return Mono.empty();
+    }
+
+
+    /**
+     * Cacheable：用于从缓存中读取数据，缓存中不存在数据则调用方法并将结果存入缓存。
+     * CacheEvict：用于从缓存中删除数据，可以根据条件删除。
+     * @param id
+     * @return
+     */
+    @Cacheable(cacheNames = "TweetTest", key = "#id")
+    @CacheEvict(cacheNames = "TweetTest", key = "#id", condition = "#result == null")
+    public Mono<TweetTest> getAndEvictIfNotFound(Long id) {
+        return template.selectOne(Query.query(Criteria.where("id").is(id)), TweetTest.class);
+    }
+
 //    @Resource
 //    private R2dbcRepository repository;
 //    @Resource

launch-admin/src/main/java/com/webflux/launchadmin/mysql/task/SyncPlanNewListenToRedis.java

@@ -116,6 +116,7 @@ public class SyncPlanNewListenToRedis {
         }
     }
 
+
     /**
      * 通过code从数据库获取PlanNew并缓存redis
      * @param code

launch-admin/src/main/java/com/webflux/launchadmin/redis/controller/test/UserController.java

@@ -5,6 +5,7 @@ import com.webflux.launchadmin.redis.service.test.UserService;
 
 import com.webflux.launchcommon.returnObj.RStatus;
 import com.weblux.launchredis.test.CacheService;
+import com.weblux.launchredis.test.DomainTest;
 import com.weblux.launchredis.test.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
@@ -43,6 +44,11 @@ public class UserController {
         return userService.saveUser(user);
     }
 
+    @PostMapping("domain")
+    public Mono<Boolean> createdomain(@RequestBody DomainTest user) {
+        return userService.saveDomain(user);
+    }
+
 
     /**
      * putCache

launch-admin/src/main/java/com/webflux/launchadmin/redis/service/test/UserService.java

@@ -6,6 +6,7 @@ import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
 
 
+import com.weblux.launchredis.test.DomainTest;
 import com.weblux.launchredis.test.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.ReactiveRedisOperations;
@@ -25,9 +26,11 @@ public class UserService {
     @Autowired
     ReactiveRedisOperations<String, User> typedOperations;
     @Autowired
+    ReactiveRedisOperations<String, DomainTest> domainTestReactiveRedisOperations;
+    @Autowired
     ReactiveRedisOperations<String, Object> objectOperations;
     private final String USER_KEY_PREFIX = "user:";
-
+    private final String Domain_KEY_PREFIX = "domain:";
     public Mono<User> getUserById(String id) {
         return typedOperations.opsForValue().get(USER_KEY_PREFIX + id);
 
@@ -57,4 +60,8 @@ public class UserService {
     public Mono<Boolean> saveUser(User user) {
         return typedOperations.opsForValue().set(USER_KEY_PREFIX + user.getId(), user);
     }
+
+    public Mono<Boolean> saveDomain(DomainTest user) {
+        return domainTestReactiveRedisOperations.opsForValue().set(Domain_KEY_PREFIX + user.id(), user);
+    }
 }

launch-admin/src/main/resources/application-dev.yml

@@ -4,10 +4,10 @@ spring:
       host: 47.103.172.247
       port: 52525
       password: NTZY_LOg666%$_redis
-      database: 0
+      database: 1
       timeout: 10000
   r2dbc:
-    url: r2dbcs:mysql://rm-uf6xylut5n33hb3o5ro.mysql.rds.aliyuncs.com:3306/wx_share_8?serverZoneId=GMT%2b8&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&ssl=false&sslMode=DISABLED
+    url: r2dbcs:mysql://rm-uf6xylut5n33hb3o5ro.mysql.rds.aliyuncs.com:3306/wx_share_test?serverZoneId=GMT%2b8&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&ssl=false&sslMode=DISABLED
     username: wx_share_liuwei
     password: Wx_ShARe56578AwCH
 

launch-admin/src/main/resources/application.yml

@@ -1,5 +1,5 @@
 server:
-  port: 8800
+  port: 8899
 
 spring:
   application:

launch-redis/pom.xml

@@ -25,6 +25,10 @@
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
         </dependency>
         <dependency>
@@ -40,6 +44,10 @@
             <artifactId>launch-common</artifactId>
         </dependency>
         <dependency>
+            <groupId>com.launch.webflux</groupId>
+            <artifactId>launch-r2dbc</artifactId>
+        </dependency>
+        <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
         </dependency>
@@ -49,7 +57,6 @@
             <version>3.2.0</version>
         </dependency>
 
-
     </dependencies>
 
 </project>

launch-redis/src/main/java/com/weblux/launchredis/config/RedisConfig.java

@@ -4,15 +4,24 @@ package com.weblux.launchredis.config;
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
+import java.time.Duration;
+
 
 @Configuration
+
 public class RedisConfig {
 
     /**

launch-redis/src/main/java/com/weblux/launchredis/test/DomainTest.java

@@ -0,0 +1,10 @@
+package com.weblux.launchredis.test;
+
+import org.springframework.data.annotation.Id;
+
+public record DomainTest(
+         String id,
+         String name, //类型 1素材分类2清水分类
+        Integer age //域名
+) {
+}

launch-redis/src/main/java/com/weblux/launchredis/test/TweetTest.java

@@ -0,0 +1,14 @@
+package com.weblux.launchredis.test;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.io.Serializable;
+
+/**
+ * Created by rajeevkumarsingh on 08/09/17.
+ */
+@Table("t_weet")
+public record TweetTest(@Id Long id, String text)  implements Serializable {
+
+}