性能优化1

launch-admin/pom.xml

@@ -29,10 +29,27 @@
         <cola-component-dto>4.3.2</cola-component-dto>
         <revision>2022.0.0.0</revision>
         <redis.clients>5.0.2</redis.clients>
+        <aliyun-oss>3.17.2</aliyun-oss>
     </properties>
 
     <dependencies>
         <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.2.3</version> <!-- 使用最新版本 -->
+        </dependency>
+        <!-- R2DBC Pooling -->
+        <dependency>
+            <groupId>io.r2dbc</groupId>
+            <artifactId>r2dbc-pool</artifactId>
+        </dependency>
+        <!-- oss 上传 start-->
+        <dependency>
+            <groupId>com.aliyun.oss</groupId>
+            <artifactId>aliyun-sdk-oss</artifactId>
+            <version>${aliyun-oss}</version>
+        </dependency>
+        <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>

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

@@ -3,6 +3,10 @@ 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.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.planNew.Image;
 import com.weblux.launchredis.test.DomainTest;
 import com.weblux.launchredis.test.TweetTest;
 import com.weblux.launchredis.test.User;
@@ -47,6 +51,56 @@ public class ReactiveRedisConfig {
      * Configures a {@link ReactiveRedisTemplate} with {@link String} keys and a typed
      * {@link Jackson2JsonRedisSerializer}.
      */
+
+    @Bean
+    public ReactiveRedisTemplate<String, GroupType> reactiveJsonGroupTypeRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<GroupType>(GroupType.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, GroupType> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+    @Bean
+    public ReactiveRedisTemplate<String, BackgroupImageItem> reactiveJsonBackgroupImageItemRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<BackgroupImageItem>(BackgroupImageItem.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, BackgroupImageItem> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+    @Bean
+    public ReactiveRedisTemplate<String, BackgroupImage> reactiveJsonBackgroupImageRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<BackgroupImage>(BackgroupImage.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, BackgroupImage> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+    @Bean
+    public ReactiveRedisTemplate<String, Image> reactiveJsonImageRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+
+        var serializer = new Jackson2JsonRedisSerializer<Image>(Image.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, Image> builder = RedisSerializationContext
+                .newSerializationContext(new StringRedisSerializer());
+
+        var serializationContext = builder.value(serializer).build();
+
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+
     @Bean
     public ReactiveRedisTemplate<String, User> reactiveJsonUserRedisTemplate(
             ReactiveRedisConnectionFactory connectionFactory) {

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

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.controller.oss;
+
+import lombok.Data;
+
+@Data
+public class ImageDataRes {
+    private Long id;
+    private String name;
+    private String  url;
+}

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

@@ -0,0 +1,35 @@
+package com.webflux.launchadmin.mysql.controller.oss;
+
+import com.webflux.launchadmin.mysql.service.upload.UploadOssInterface;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.codec.multipart.FilePart;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+
+/**
+ * 文件上传接口
+ * @author lw12420
+ * @date 2024/08/05
+ */
+@RestController
+@RequestMapping("in/file")
+public class ImageUploadController {
+
+@Resource
+private UploadOssInterface uploadService;
+
+    /**
+     * 上传文件
+     * @param filePartMono
+     * @return {@link Mono}<{@link RStatus}<{@link String}>>
+     */
+    @PostMapping("/upload")
+    @ResponseStatus(HttpStatus.CREATED)
+    public Mono<RStatus<ImageDataRes>> uploadFile(@RequestPart("file") Mono<FilePart> filePartMono) {
+        return RStatus.success(uploadService.uploadFile( filePartMono));
+    }
+
+}

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

@@ -0,0 +1,71 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.BackgroupImagInfoeResNew;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.BackgroupImageResNew;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.BackgroupImageSaveReqNew;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.BackgroupImageSaveResNew;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumDto;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumReq;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+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.*;
+import reactor.core.publisher.Mono;
+
+/**
+ * 相册接口
+ * @author lw12420
+ * @date 2024/08/07
+ */
+@RestController
+@RequestMapping("out/album")
+public class AlbumController {
+    @Resource
+    private MaterialManagementInterface sourceMaterialInterface;
+
+
+    /**
+     * 列表查询
+     * @param albumDto
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link BackgroupImage}>>>
+     */
+    @GetMapping("list")
+    public Mono<RStatus<Paged<Album>>> pageAlbum(@RequestBody AlbumDto albumDto){
+        return  sourceMaterialInterface.pageAlbum(albumDto);
+    }
+
+
+    /**
+     * 保存
+     * @param albumReq
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageSaveResNew}>>
+     */
+    @PostMapping("addOrUpdate")
+    public Mono<RStatus<Boolean>> addAlbum(@RequestBody AlbumReq albumReq) {
+        return  sourceMaterialInterface.addOrUpdate(albumReq);
+    }
+
+    /**
+     * 回显
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImagInfoeResNew}>>
+     */
+    @GetMapping("infoAlbum/{id}")
+    public Mono<RStatus<AlbumReq>> infoAlbum(@PathVariable("id") Long id) {
+        return  sourceMaterialInterface.infoAlbum(id);
+    }
+
+    /**
+     * 删除
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageSaveResNew}>>
+     */
+    @DeleteMapping("deleteAlbum/{id}")
+    public Mono<RStatus<Boolean>> deleteAlbum(@PathVariable("id") Long id) {
+        return  sourceMaterialInterface.deleteAlbum(id);
+    }
+
+}

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

@@ -1,15 +1,14 @@
 package com.webflux.launchadmin.mysql.controller.sourceMaterial;
 
 import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.*;
 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 org.springframework.web.bind.annotation.*;
 import reactor.core.publisher.Mono;
 
 /**
@@ -18,7 +17,7 @@ import reactor.core.publisher.Mono;
  * @date 2024/08/01
  */
 @RestController
-@RequestMapping("/in/background/")
+@RequestMapping("/out/background/")
 public class BackgroupGroupController {
 
     @Resource
@@ -32,7 +31,50 @@ public class BackgroupGroupController {
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link BackgroupImage}>>>
      */
     @GetMapping("list")
-    public Mono<RStatus<Paged<BackgroupImageRes>>> pageBackgroup(Integer page, Integer size){
+    public Mono<RStatus<Paged<BackgroupImageResNew>>> pageBackgroup(Integer page, Integer size){
        return  sourceMaterialInterface.pageBackgroup(page,size);
     }
+
+
+    /**
+     * 保存
+     * @param takeawayDto
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageSaveResNew}>>
+     */
+    @PostMapping("add")
+    public Mono<RStatus<BackgroupImageSaveResNew>> add(@RequestBody BackgroupImageSaveReqNew takeawayDto) {
+        return  sourceMaterialInterface.add(takeawayDto);
+    }
+
+    /**
+     * 回显
+     * @param dto
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImagInfoeResNew}>>
+     */
+    @PostMapping("info")
+    public Mono<RStatus<BackgroupImagInfoeResNew>> info(@RequestBody BackgroupImageSaveResNew dto) {
+        return  sourceMaterialInterface.info(dto);
+    }
+
+    /**
+     * 删除
+     * @param dto
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageSaveResNew}>>
+     */
+    @PostMapping("delete")
+    public Mono<RStatus<BackgroupImageSaveResNew>> delete(@RequestBody BackgroupImageSaveResNew dto) {
+        return  sourceMaterialInterface.delete(dto);
+    }
+    /**
+     * 修改
+     * @param takeawayDto
+     * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageSaveResNew}>>
+     */
+    @PostMapping("update")
+    public Mono<RStatus<BackgroupImageSaveResNew>> update(@RequestBody BackgroupImageSaveReqNew takeawayDto) {
+        return  sourceMaterialInterface.update(takeawayDto);
+    }
+
+
+
 }

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

@@ -0,0 +1,42 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.ExcelDataRes;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.image.ImageSaveRes;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.MaterialManagementInterface;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.codec.multipart.FilePart;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+@RestController
+@RequestMapping("out/image")
+public class ImageExcelController {
+
+    @Resource
+    MaterialManagementInterface materialManagementInterface;
+
+    /**
+     * 图片素材 上传xlsx
+     * @param file
+     * @return {@link Mono}<{@link RStatus}<{@link ExcelDataRes}>>
+     */
+    @PostMapping(value = "/upload")
+    @ResponseStatus(HttpStatus.CREATED)
+    public Mono<RStatus<ExcelDataRes>> uploadExcel(@RequestPart("file") Mono<FilePart> file) {
+        Mono<ExcelDataRes> excelDataResMono = materialManagementInterface.importExcel(  file);
+       return RStatus.success(excelDataResMono);
+    }
+
+    /**
+     * 导入xlsx
+     * @param data
+     * @return {@link Mono}<{@link RStatus}<{@link ExcelDataRes}>>
+     */
+    @PostMapping(value = "/import")
+    public Mono<RStatus<String>> importExcel(@RequestBody ImageSaveRes data) {
+        Mono<String> excelDataResMono = materialManagementInterface.importDataExcel( data);
+        return RStatus.success(excelDataResMono);
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+@Data
+public class BackgroupImagInfoeResNew {
+    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 List<ImageItem> images;
+    private String     itemId;
+}

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

@@ -6,7 +6,7 @@ import org.springframework.data.annotation.Id;
 
 import java.time.ZonedDateTime;
 @Data
-public class BackgroupImageReq {
+public class BackgroupImageReqNew {
     private   Long id;
     private String name;
     private  String createUser;

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

@@ -1,10 +1,12 @@
 package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
 
 import java.time.ZonedDateTime;
 
-public class BackgroupImageRes {
+@Data
+public class BackgroupImageResNew {
     private   Long id;
     private String name;
     private  String createUser;
@@ -18,4 +20,5 @@ public class BackgroupImageRes {
     private String groupTypeName;
     private Integer groupTypeId;
     private String image;
+    private  String itemIds;
 }

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

@@ -0,0 +1,16 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+@Data
+public class BackgroupImageSaveReqNew {
+    private   Long id;
+    private String name;
+    private String groupTypeName;
+    private List<ImageItem> images;
+
+}

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

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class BackgroupImageSaveResNew {
+    private   Long id;
+}

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

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import lombok.Data;
+
+@Data
+public class ExcelDataRes {
+   private Long id;
+   private String name;
+   private String url;
+}

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

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class ImageItem {
+   private String image;
+   private  Integer index;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/album/AlbumDto.java

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album;
+
+import lombok.Data;
+
+@Data
+public class AlbumDto {
+    private  Long groupId;
+    private  String userName;
+    private  Integer page;
+    private  Integer size;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/album/AlbumItemReq.java

@@ -0,0 +1,19 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album;
+
+import lombok.Data;
+
+@Data
+public class AlbumItemReq {
+    /**
+     * 回显使用
+     */
+    private   Long id;
+    /**
+     * 图片url
+     */
+    private  String url;
+    /**
+     * //0：免费 1：解锁
+     */
+    private  Integer status ;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/album/AlbumReq.java

@@ -0,0 +1,36 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class AlbumReq {
+    /**
+     * 修改必填
+     */
+    private Long albumId;
+    /**
+     *
+     昵称
+     */
+    private  String userName;
+    /**
+     * 分类id
+     */
+    private  Long groupId;
+    /**
+     * 分类name
+     */
+    private String groupName;
+    /**
+     * 头像url
+     */
+    private String headUrl;
+    /**
+     * 图片结合
+     */
+    private List<AlbumItemReq> list;
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/sourceMaterial/data/image/ImageSaveRes.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.controller.sourceMaterial.data.image;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+@Data
+public class ImageSaveRes {
+    @NotNull
+    private   Long id;
+}

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

@@ -7,6 +7,7 @@ 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.planNew.BackgroupImage;
 import com.webflux.launchadmin.mysql.entity.planNew.Image;
 import com.webflux.launchadmin.mysql.entity.test.Tweet;
 import com.webflux.launchadmin.mysql.repository.test.TweetRepository;
@@ -37,6 +38,7 @@ import org.springframework.web.bind.annotation.RestController;
 import reactor.core.publisher.Mono;
 
 import java.io.IOException;
+import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Objects;
 
@@ -76,10 +78,12 @@ public class testController {
         return Mono.empty();
     }
     @GetMapping("get9")
-    public Mono<TweetTest>  get9(@RequestParam("id") Long id)   {
+    public Mono<BackgroupImage>  get9()   {
         //return syncPlanNewListenToRedis.syncLinteningPlan();
-        Mono<TweetTest> personById = tweetService.getPersonById(id);
-        return personById;
+        Mono<TweetTest> tweetTestMono = tweetService.updatePerson(new TweetTest(1L, "12", ZonedDateTime.now()));
+        Mono<BackgroupImage> personById = tweetService.uinPerson(new BackgroupImage(null,"22","1",
+                ZonedDateTime.now(),ZonedDateTime.now(),null,1,"1",1,null));
+        return tweetTestMono.then(personById);
     }
     @GetMapping("get4")
     public Mono<List<Image>>  get4()   {

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

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonFormat;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.io.Serializable;
 import java.time.ZonedDateTime;
 
 @Table("backgroup_image")
@@ -16,8 +17,9 @@ public record BackgroupImage(
         @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime deletedAt,
         Integer groupType,
         String groupTypeName,
-        Integer groupTypeId
+        Integer groupTypeId,
+        String itemIds //数组string
 
-) {
+) implements Serializable {
 
 }

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

@@ -1,11 +1,14 @@
 package com.webflux.launchadmin.mysql.entity.planNew;
 
 import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.io.Serializable;
+
 @Table("backgroup_image_item")
 public record BackgroupImageItem(@Id Long id,
                                  String image,
                                  Integer index,
-                                 Long groupId) {
+                                 Long groupId)implements Serializable {
 }

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

@@ -3,10 +3,12 @@ package com.webflux.launchadmin.mysql.entity.planNew;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.io.Serializable;
+
 @Table("group_type")
 public record GroupType(
         @Id Long id,
         String name,
         String groupType
-) {
+)implements Serializable {
 }

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

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonFormat;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.io.Serializable;
 import java.time.ZonedDateTime;
 
 @Table("image")
@@ -19,6 +20,6 @@ public record Image(
         String groupTypeName,
         Integer groupTypeId,
         Integer sizeType
-) {
+) implements Serializable {
 
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/sourceMaterial/Album.java

@@ -0,0 +1,24 @@
+package com.webflux.launchadmin.mysql.entity.sourceMaterial;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+
+@Table("album")
+public record Album(@Id Long albumId,
+                    String headUrl,
+                    Long groupId,
+                    String groupName,
+                    Integer imageSize,
+                    String createUser,
+                    String createId,
+                    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt,
+                    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt,
+                    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime deletedAt,
+                    String imageListId,
+                    String userName
+                    ) implements Serializable {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/sourceMaterial/AlbumItem.java

@@ -0,0 +1,14 @@
+package com.webflux.launchadmin.mysql.entity.sourceMaterial;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.io.Serializable;
+
+@Table("album_item")
+public record AlbumItem(@Id Long id,
+                        String url,
+                        Integer status //0：免费 1：解锁
+
+                    )  implements Serializable {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/sourceMaterial/AlbumItemRepository.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.repository.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+
+@Repository
+public interface AlbumItemRepository extends ReactiveCrudRepository<AlbumItem,Long> {
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/sourceMaterial/AlbumRepository.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.repository.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface AlbumRepository extends ReactiveCrudRepository<Album,Long> {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/sourceMaterial/BackgroupImageItemRepository.java

@@ -0,0 +1,20 @@
+package com.webflux.launchadmin.mysql.repository.sourceMaterial;
+
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+@Repository
+public interface BackgroupImageItemRepository extends ReactiveCrudRepository<BackgroupImageItem,Long> {
+
+    Flux<BackgroupImageItem> findByGroupId(Long groupId);
+
+    @Query("INSERT INTO backgroup_image_item (image, `index`, group_id) VALUES (:image, :index, :groupId)")
+    Mono<Void> insertImageItem( String image, Integer index, Long groupId);
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/sourceMaterial/BackgroupImageRepository.java

@@ -0,0 +1,20 @@
+package com.webflux.launchadmin.mysql.repository.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+
+@Repository
+public interface BackgroupImageRepository extends ReactiveCrudRepository<BackgroupImage,Long> {
+    @Modifying
+    @Query("UPDATE backgroup_image SET deleted_at = :deletedAt where id = :id")
+    Mono<BackgroupImage> deleteLogicFor(ZonedDateTime deletedAt, Long id);
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/sourceMaterial/GroupTypeRepository.java

@@ -0,0 +1,19 @@
+package com.webflux.launchadmin.mysql.repository.sourceMaterial;
+
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+
+import java.io.File;
+
+@Repository
+public interface GroupTypeRepository extends ReactiveCrudRepository<GroupType,Long> {
+
+    Flux<GroupType> findByGroupType(String groupType);
+
+    Flux<GroupType> findByName(String name);
+
+
+
+}

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

@@ -12,28 +12,43 @@ 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.controller.sourceMaterial.data.BackgroupGroup.ExcelDataRes;
 import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.Image;
 import com.webflux.launchadmin.mysql.entity.planNew.PosterTemplate;
 import com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql.Where;
+import com.webflux.launchadmin.mysql.service.upload.UploadOssInterface;
 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.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
 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.http.codec.multipart.FilePart;
 import org.springframework.stereotype.Service;
 import org.springframework.web.bind.annotation.RequestBody;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 
 
@@ -41,13 +56,15 @@ import java.util.function.Function;
 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();
+        Criteria criteria = Criteria.where("deleted_at").isNull();
         if (!wheres.isEmpty()) {
             for (Where entry: wheres){
                 String key = entry.getKey();
@@ -80,8 +97,8 @@ public class SourceMaterialImpl implements SourceMaterialInterface{
         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();
+    public <T,E> Mono<RStatus<Paged<E>>> pageAndFunctionRtE(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,Mono<List<E>>> function){
+        Criteria criteria = Criteria.where("deleted_at").isNull();
         if (!wheres.isEmpty()) {
             for (Where entry: wheres){
                 String key = entry.getKey();
@@ -104,11 +121,8 @@ public class SourceMaterialImpl implements SourceMaterialInterface{
                         .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);
-                                }
+                        .collectList().flatMap(function)
+                        .map(list -> new Paged<>(fm, list, page, size)
                         )
         );
         return RStatus.successList(pagedMono);
@@ -162,6 +176,9 @@ public class SourceMaterialImpl implements SourceMaterialInterface{
             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

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

@@ -1,5 +1,6 @@
 package com.webflux.launchadmin.mysql.service.sourceMaterial;
 
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.ExcelDataRes;
 import com.webflux.launchadmin.mysql.entity.planNew.PosterTemplate;
 import com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql.Where;
 import com.webflux.launchcommon.returnObj.Paged;
@@ -7,6 +8,7 @@ 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.http.codec.multipart.FilePart;
 import org.springframework.web.bind.annotation.PathVariable;
 import reactor.core.publisher.Mono;
 
@@ -34,7 +36,7 @@ public interface SourceMaterialInterface {
      * @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);
+     <T,E> Mono<RStatus<Paged<E>>> pageAndFunctionRtE(List<Where> wheres, Class<T> domainType, Integer size , Integer page, Function<List<T>,Mono<List<E>>> function);
     /**
      * 物理通过id删除
      * @param column

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/data/image/ImageExcelRedisCache.java

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.data.image;
+
+import lombok.Data;
+
+@Data
+public class ImageExcelRedisCache {
+    private String image;
+    private Integer type;
+    private String groupTypeName;
+    private Integer sizeType;
+}

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

@@ -1,16 +1,55 @@
 package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement;
 
-import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONUtil;
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.*;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumDto;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumItemReq;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumReq;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.image.ImageSaveRes;
 import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.planNew.Image;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.*;
 import com.webflux.launchadmin.mysql.service.sourceMaterial.SourceMaterialInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.data.image.ImageExcelRedisCache;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.data.sql.Where;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.AlbumInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.AlbumItemInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.BackgroupImageInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.BackgroupImageItemService;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.GroupTypeinterface;
+import com.webflux.launchadmin.mysql.service.upload.UploadOssInterface;
 import com.webflux.launchcommon.returnObj.Paged;
 import com.webflux.launchcommon.returnObj.RStatus;
+import com.webflux.launchcommon.utils.StringUtils;
 import jakarta.annotation.Resource;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+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.http.codec.multipart.FilePart;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-import java.util.List;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.time.Duration;
+import java.time.ZonedDateTime;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
 @Service
@@ -19,18 +58,574 @@ public class MaterialManagementImpl implements MaterialManagementInterface {
     @Resource
     private SourceMaterialInterface sourceMaterialInterface;
     @Resource
+    private BackgroupImageRepository backgroupImageRepository;
+    @Resource
+    private GroupTypeRepository groupTypeRepository;
+    @Resource
+    private BackgroupImageItemRepository backgroupImageItemRepository;
+    @Resource
     private R2dbcEntityTemplate template;
+    @Resource
+    private UploadOssInterface uploadService;
+    @Resource
+    ReactiveRedisTemplate<String, Image> reactiveRedisImageTemplate;
+    @Resource
+    ReactiveRedisTemplate<String, Object> reactiveRedisTemplate;
+    @Resource
+    GroupTypeinterface groupTypeinterface;
+    @Resource
+    BackgroupImageInterface backgroupImageInterface;
+    @Resource
+    BackgroupImageItemService backgroupImageItemInterface;
+    //素材图片缓存
+    private static final String hashKey = "execel_upload_cache_Image_";
+
+
+    //Todo  GroupType
+    @Override
+    public Mono<GroupType> saveMysqlAndRedisGroupType( GroupType groupType) {
+        return groupTypeRepository.save(  groupType)
+                .onErrorResume(throwable -> Mono.error(new BaseException("保存GroupType失败" + throwable.getMessage())))
+                .flatMap(groupTypeinterface::saveMysqlAndRedisGroupType);
+    }
+
+
+
+    //Todo  BackgroupImage <<<<<<<<<<<<<<
+    @Override
+    public Mono<Void> saveMysqlAndRedisBackgroupItem(BackgroupImageItem backgroupImageItem) {
+        return backgroupImageItemRepository.insertImageItem(backgroupImageItem.image(),backgroupImageItem.index(),backgroupImageItem.groupId());
+    }
+
+    @Override
+    public Mono<BackgroupImage> saveMysqlAndRedisBackgroupImage(BackgroupImage backgroupImage) {
+        return template.insert(backgroupImage)
+                .onErrorResume(throwable -> Mono.error(new BaseException("保存backgroupImage失败" + throwable.getMessage())))
+                .flatMap(backgroupImageInterface::saveMysqlAndRedisBackgroupImageCache);
+    }
+
+    public Mono<BackgroupImage> updateMysqlAndRedisBackgroupImage(BackgroupImage backgroupImage) {
+        return template.update(backgroupImage)
+                .onErrorResume(throwable -> Mono.error(new BaseException("保存backgroupImage失败" + throwable.getMessage())))
+                .flatMap(backgroupImageInterface::saveMysqlAndRedisBackgroupImageCache);
+    }
+
+    @Override
+    public Mono<BackgroupImage> removeRedisAndMysqlBackgroupImage(Long id) {
+        return backgroupImageRepository.deleteLogicFor(ZonedDateTime.now(),id)
+                .onErrorResume(throwable -> Mono.error(new BaseException("删除失败" + throwable.getMessage())))
+                .flatMap(backgroupImage -> backgroupImageInterface.deleteMysqlAndRedisBackgroupImageCache(backgroupImage))
+                .flatMap(backgroupImage -> {
+                    Mono<List<BackgroupImageItem>> listMono =
+                            backgroupImageItemRepository
+                                    .findByGroupId(backgroupImage.id())
+                                    .flatMap(backgroupImageItem ->
+                                            backgroupImageItemInterface
+                                                    .deleteMysqlAndRedisBackgroupImageCache(backgroupImageItem))
+                                    .collectList();
+                    return listMono.then(Mono.just(backgroupImage));
+                });
+    }
+    // Todo Api
+    @Override
+    public Mono<RStatus<Paged<BackgroupImageResNew>>> pageBackgroup(Integer page, Integer size) {
+        return  sourceMaterialInterface.pageAndFunctionRtE(List.of(),BackgroupImage.class,size,page,(f)-> Flux.fromIterable(f).flatMap(fe -> {
+            String string = sourceMaterialInterface.tToString(fe);
+            BackgroupImageResNew backgroupImageRes = sourceMaterialInterface.strParseT(string, BackgroupImageResNew.class);
+            Mono<List<BackgroupImageItem>> listMono =
+                    template.select(Query.query(Criteria.where("group_id").is(fe.id())),
+                            BackgroupImageItem.class).collectList();
+
+            return Mono.zip(Mono.just(backgroupImageRes), listMono).flatMap(all -> {
+                BackgroupImageResNew t1 = all.getT1();
+                List<BackgroupImageItem> t2 = all.getT2();
+                Mono<Boolean> backgroupImageMono=Mono.just(true);
+                if (Objects.isNull(t1.getItemIds()) || "".equals(t1.getItemIds())) {
+                    //主任务绑定子任务id 实现缓存cache 查询 此表是go服务设计 不能修改只能兼容
+                    List<Long> collect = t2.stream().map(BackgroupImageItem::id).collect(Collectors.toList());
+                    if (!collect.isEmpty()) {
+                        String ids = JSONUtil.toJsonStr(collect);
+                        backgroupImageMono = template.update(Query.query(Criteria.where("id").is(t1.getId())),
+                                Update.update("item_ids", ids),
+                                BackgroupImage.class)
+                                .flatMap(id -> backgroupImageRepository
+                                        .findById(id)
+                                        .flatMap(backgroupImage1 ->
+                                                backgroupImageInterface
+                                                        .saveMysqlAndRedisBackgroupImageCache(backgroupImage1))).then(Mono.just(true));
+                    }
+                }
+                if (!t2.isEmpty()) {
+                    t2.stream().filter(f1->f1.index()==1).map(BackgroupImageItem::image).findFirst().ifPresent(t1::setImage);
+                }
+                return backgroupImageMono.then(Mono.just(t1));
+            });
+        }).collectList());
+    }
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Mono<RStatus<BackgroupImageSaveResNew>> add(BackgroupImageSaveReqNew dto) {
+        String groupTypeName = dto.getGroupTypeName();
+        String userName = BaseContextHandler.getUserName();
+        Mono<BackgroupImageSaveResNew> end = groupTypeRepository.findByName(groupTypeName).collectList()
+                .switchIfEmpty(Mono.just(List.of()))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询GroupType Error：：" + throwable.getMessage())))
+                .flatMap(list -> {
+                    Mono<GroupType> groupTypeMono;
+                    if (list.isEmpty()) {
+                        groupTypeMono = saveMysqlAndRedisGroupType(new GroupType(null, groupTypeName, "1"));
+                    } else {
+                        groupTypeMono = Mono.just(list.get(0));
+                    }
+                    return groupTypeMono;
+                }).flatMap(groupType -> {
+                    BackgroupImage backgroupImage = new BackgroupImage(null,
+                            dto.getName(),
+                            userName,
+                            ZonedDateTime.now(),
+                            null,
+                            null,
+                            1,
+                            groupType.name(),
+                            Integer.valueOf(String.valueOf(groupType.id())),null);
+                    return  saveMysqlAndRedisBackgroupImage(backgroupImage);
+                }).flatMap(backgroupImage -> {
+                    List<ImageItem> images = dto.getImages();
+                    if (images.isEmpty()) {
+                        return Mono.error(new BaseException("图片素材不可为空"));
+                    }
+                    Mono<List<BackgroupImageItem>> then = Flux.fromIterable(images)
+                            .flatMap(imageItem ->
+                                    saveMysqlAndRedisBackgroupItem(new BackgroupImageItem(null,
+                                            imageItem.getImage(),
+                                            imageItem.getIndex(),
+                                            backgroupImage.id()))
+                            ).collectList().then(backgroupImageItemRepository
+                                    .findByGroupId(backgroupImage.id())
+                                    .flatMap(backgroupImageItem ->
+                                            backgroupImageItemInterface
+                                                    .saveMysqlAndRedisBackgroupImageCache(backgroupImageItem))
+                                    .collectList());
+                    return Mono.zip(then, Mono.just(backgroupImage)).flatMap(all -> {
+                        BackgroupImageSaveResNew backgroupImageSaveResNew = new BackgroupImageSaveResNew();
+                        backgroupImageSaveResNew.setId(all.getT2().id());
+                        //主任务绑定子任务id 实现缓存cache 查询 此表是go服务设计 不能修改只能兼容
+                        List<Long> collect = all.getT1().stream().map(BackgroupImageItem::id).collect(Collectors.toList());
+                        Mono<BackgroupImage> backgroupImageMono;
+                        if (!collect.isEmpty()) {
+                            String ids = JSONUtil.toJsonStr(collect);
+                            backgroupImageMono = template.update(Query.query(Criteria.where("id")
+                                            .is(backgroupImageSaveResNew.getId())),
+                                    Update.update("item_ids", ids),
+                                    BackgroupImage.class)
+                                    .flatMap(id -> backgroupImageRepository
+                                            .findById(id)
+                                            .flatMap(backgroupImage1 ->
+                                                    backgroupImageInterface
+                                                            .saveMysqlAndRedisBackgroupImageCache(backgroupImage1)));
+                        }else {
+                            backgroupImageMono=Mono.just(all.getT2());
+                        }
+                        return  backgroupImageMono.then(Mono.just(backgroupImageSaveResNew));
+                    });
+                });
+        return RStatus.success(end);
+    }
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Mono<RStatus<BackgroupImageSaveResNew>> update(BackgroupImageSaveReqNew dto) {
+        if (Objects.isNull(dto.getId())) {
+            return Mono.error(new BaseException("id is null"));
+        }
+        String groupTypeName = dto.getGroupTypeName();
+        Mono<BackgroupImageSaveResNew> end = groupTypeRepository.findByName(groupTypeName).collectList()
+                .switchIfEmpty(Mono.just(List.of()))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询GroupType Error：：" + throwable.getMessage())))
+                .flatMap(list -> {
+                    Mono<GroupType> groupTypeMono;
+                    if (list.isEmpty()) {
+                        groupTypeMono = saveMysqlAndRedisGroupType(new GroupType(null, groupTypeName, "1"));
+                    } else {
+                        groupTypeMono = Mono.just(list.get(0));
+                    }
+                    return groupTypeMono;
+                }).flatMap(groupType ->backgroupImageRepository.findById(dto.getId())
+                        .switchIfEmpty(Mono.error(new BaseException("id 查询结果为空")))
+                        .flatMap(backgroupImage -> {
+                            BackgroupImage backgroupImagesave = new BackgroupImage(dto.getId(),
+                                    dto.getName(),
+                                    backgroupImage.createUser(),
+                                    backgroupImage.createdAt(),
+                                    ZonedDateTime.now(),
+                                    null,
+                                    1,
+                                    groupType.name(),
+                                    Integer.valueOf(String.valueOf(groupType.id())),null);
+                            return  updateMysqlAndRedisBackgroupImage(backgroupImagesave);
+                        }) ).flatMap(backgroupImage -> {
+                    List<ImageItem> images = dto.getImages();
+                    if (images.isEmpty()) {
+                        return Mono.error(new BaseException("图片素材不可为空"));
+                    }
+                    Mono<List<BackgroupImageItem>> listMono1 = backgroupImageItemRepository
+                            .findByGroupId(backgroupImage.id())
+                            .flatMap(backgroupImageItem ->
+                                            backgroupImageItemRepository
+                                                    .deleteById(backgroupImageItem.id())
+                                                    .onErrorResume(throwable ->
+                                                            Mono.error(new BaseException("删除item异常" + throwable.getMessage())))
+                                                    .then(backgroupImageItemInterface
+                                                            .deleteMysqlAndRedisBackgroupImageCache(backgroupImageItem)))
+                            .collectList();
+                    Mono<List<BackgroupImageItem>> then1 = Flux.fromIterable(images)
+                            .flatMap(imageItem ->
+                                    saveMysqlAndRedisBackgroupItem(new BackgroupImageItem(null,
+                                            imageItem.getImage(),
+                                            imageItem.getIndex(),
+                                            backgroupImage.id()))).collectList().then(backgroupImageItemRepository
+                                    .findByGroupId(backgroupImage.id())
+                                    .flatMap(backgroupImageItem ->
+                                            backgroupImageItemInterface
+                                                    .saveMysqlAndRedisBackgroupImageCache(backgroupImageItem))
+                                    .collectList());
+                    Mono<List<BackgroupImageItem>> then = listMono1.then(then1);
+                    return Mono.zip(then, Mono.just(backgroupImage)).flatMap(all -> {
+                        BackgroupImageSaveResNew backgroupImageSaveResNew = new BackgroupImageSaveResNew();
+                        backgroupImageSaveResNew.setId(all.getT2().id());
+                        //主任务绑定子任务id 实现缓存cache 查询 此表是go服务设计 不能修改只能兼容
+                        List<Long> collect = all.getT1().stream().map(BackgroupImageItem::id).collect(Collectors.toList());
+                        Mono<BackgroupImage> backgroupImageMono;
+                        if (!collect.isEmpty()) {
+                            String ids = JSONUtil.toJsonStr(collect);
+                             backgroupImageMono = template.update(Query.query(Criteria.where("id")
+                                            .is(backgroupImageSaveResNew.getId())),
+                                    Update.update("item_ids", ids),
+                                     BackgroupImage.class)
+                                     .flatMap(id -> backgroupImageRepository
+                                             .findById(id)
+                                             .flatMap(backgroupImage1 ->
+                                                     backgroupImageInterface
+                                                             .saveMysqlAndRedisBackgroupImageCache(backgroupImage1)));
+                        }else {
+                            backgroupImageMono=Mono.just(all.getT2());
+                        }
+                        return  backgroupImageMono.then(Mono.just(backgroupImageSaveResNew));
+
+                    });
+                });
+        return RStatus.success(end);
+    }
+    @Override
+    public Mono<RStatus<BackgroupImagInfoeResNew>> info(BackgroupImageSaveResNew dto) {
+        Mono<BackgroupImage> backgroupImageMono = backgroupImageInterface.getRedisOrMysqlBackgroupImage(dto.getId());
+        Mono<BackgroupImagInfoeResNew> backgroupImagInfoeResNewMono = backgroupImageMono.flatMap(backgroupImage -> {
+            BackgroupImagInfoeResNew backgroupImagInfoeResNew = new BackgroupImagInfoeResNew();
+            backgroupImagInfoeResNew.setId(backgroupImage.id());
+            backgroupImagInfoeResNew.setCreateUser(backgroupImage.createUser());
+            backgroupImagInfoeResNew.setCreatedAt(backgroupImage.createdAt());
+            backgroupImagInfoeResNew.setGroupTypeName(backgroupImage.groupTypeName());
+            backgroupImagInfoeResNew.setUpdatedAt(backgroupImage.updatedAt());
+            backgroupImagInfoeResNew.setName(backgroupImage.name());
+            backgroupImagInfoeResNew.setItemId(backgroupImage.itemIds());
+            return Mono.just(backgroupImagInfoeResNew);
+        }).flatMap(res -> {
+            String itemId = res.getItemId();
+            if (Objects.nonNull(itemId)) {
+                List<Long> list = JSONUtil.parseArray(itemId).toList(Long.class);
+              return   Flux.fromIterable(list).flatMap(id->
+                        backgroupImageItemInterface
+                                .getGroupImageItemMonoCache(id))
+                        .collectList()
+                        .flatMap(lists->{
+                    if (lists.isEmpty()) {
+                        return Mono.just(res);
+                    }
+                    List<ImageItem> collect = lists.stream().map(item -> new ImageItem(item.image(), item.index())).collect(Collectors.toList());
+                    res.setImages(collect);
+                    return Mono.just(res);
+                });
+            }else {
+                return backgroupImageItemRepository.findByGroupId(res.getId())
+                        .collectList()
+                        .switchIfEmpty(Mono.just(List.of())).flatMap(list -> {
+                            if (list.isEmpty()) {
+                                return Mono.just(res);
+                            }
+                            List<ImageItem> collect = list.stream().map(item -> new ImageItem(item.image(), item.index())).collect(Collectors.toList());
+                            res.setImages(collect);
+                            return Mono.just(res);
+                        });
+            }}
+        );
+        return RStatus.success(backgroupImagInfoeResNewMono);
+    }
+    @Override
+    public Mono<RStatus<BackgroupImageSaveResNew>> delete(BackgroupImageSaveResNew dto) {
+        Mono<BackgroupImage> backgroupImageMono = removeRedisAndMysqlBackgroupImage(dto.getId());
+        Mono<BackgroupImageSaveResNew> backgroupImageSaveResNewMono = backgroupImageMono.flatMap(f -> {
+            BackgroupImageSaveResNew backgroupImageSaveResNew =
+                    new BackgroupImageSaveResNew();
+            backgroupImageSaveResNew.setId(f.id());
+            return Mono.just(backgroupImageSaveResNew);
+        });
+        return RStatus.success(backgroupImageSaveResNewMono);
+    }
+
+    //Todo  BackgroupImage >>>>>>>>>>>>>>>>>
+
+    //Todo  Image <<<<<<<<<<<<<<
+    @Override
+    public Mono<ExcelDataRes> importExcel(Mono<FilePart> file) {
+        return file.flatMap(filePart -> {
+            String filename = filePart.filename();
+            Mono<ByteArrayInputStream> byteArrayInputStreamMono = uploadService.convertFilePartToByteArrayInputStream(filePart);
+            return byteArrayInputStreamMono.flatMap(in -> {
+                ArrayList<ImageExcelRedisCache> images = new ArrayList<>();
+                try (XSSFWorkbook workbook = new XSSFWorkbook(in)) {
+                    // 处理 Excel 文件
+                    workbook.forEach(sheet -> {
+                        for (Row row : sheet) {
+                            Iterator<Cell> cellIterator = row.cellIterator();
+                            ArrayList<String> strings = new ArrayList<>();
+                            while (cellIterator.hasNext()) {
+                                Cell cell = cellIterator.next();
+                                strings.add(Objects.isNull(cell.getStringCellValue()) ? "" : cell.getStringCellValue());
+                            }
+                            if (!strings.isEmpty()) {
+                                if (Objects.nonNull(strings.get(0))
+                                        && !"图片链接".equals(strings.get(0))
+                                        && !"".equals(strings.get(0).trim())) {
+                                    Integer type = getImageType(strings);
+                                    ImageExcelRedisCache cache =new ImageExcelRedisCache();
+                                    cache.setImage(strings.get(0));
+                                    cache.setType(type);
+                                    cache.setGroupTypeName(strings.get(2));
+                                    cache.setSizeType( getImageSizeType(strings));
+                                    images.add(cache);
+                                }
+                            }
+                        }
+                    });
+                } catch (IOException e) {
+                    throw new RuntimeException("文件处理失败", e);
+                }
+                if (!images.isEmpty()) {
+                    long currentTimeMillis = System.currentTimeMillis();
+                    String k = hashKey + currentTimeMillis;
+                    String cacheJsonStr = JSONUtil.toJsonStr(images);
+                    Mono<Boolean> listMono = reactiveRedisTemplate.opsForValue().set(k, cacheJsonStr, Duration.ofHours(10));
+                    return Mono.zip(listMono, Mono.just(currentTimeMillis)).flatMap(f -> {
+                        ExcelDataRes excelDataRes = new ExcelDataRes();
+                        excelDataRes.setId(f.getT2());
+                        excelDataRes.setName(filename);
+                        return Mono.just(excelDataRes);
+                    });
+                }
+                return Mono.error(new BaseException("上传失败"));
+            });
+        });
+    }
+    private Integer getImageSizeType(ArrayList<String> strings) {
+        int type=1;
+        if(strings.size()>=4){
+            if ("单列".equals(strings.get(3))) {
+                type = 2;
+            }
+        }
+        return type;
+    }
+    private Integer getImageType(ArrayList<String> strings) {
+        int type=0;
+        if(strings.size()<2){
+            return type;
+        }
+        switch (strings.get(1)) {
+            case "群封面" -> type = 1;
+            case "海报背景图" -> type = 2;
+            case "分享背景图" -> type = 3;
+            case "中转动图" -> type = 4;
+            case "简介" -> type = 5;
+            case "微信头像" -> type = 6;
+            case "海报封面" -> type = 7;
+            case "加企微海报" -> type = 8;
+            case "分享封面" -> type = 9;
+            case "海报图片" -> type = 10;
+            case "外卖商品图" -> type = 11;
+            case "企微群码" -> type = 12;
+            case "假视频封面" -> type = 13;
+        }
+        return type;
+    }
+    @Override
+    public Mono<String> importDataExcel(ImageSaveRes data) {
+        Long id = data.getId();
+        String userName = BaseContextHandler.getUserName();
+        Mono<String> objectMono = reactiveRedisImageTemplate.opsForValue().get(hashKey + id).flatMap(f->{
+            if(Objects.nonNull(f)){
+
+            }
+            return Mono.just(f.toString());
+
+        });
+
+//        reactiveRedisImageTemplate.opsForHash().scan(hashKey+id).(entry->{
+//
+//
+//        })
+        return objectMono;
+    }
+
+
+
+    //Todo  Image >>>>>>>>>>>>>>>>>
+    //Todo  相册 Album <<<<<<<<<<<<<<
+
+    @Resource
+    private AlbumInterface albumInterface;
+    @Resource
+    private AlbumRepository albumRepository;
+    @Resource
+    private AlbumItemInterface albumItemInterface;
+    @Resource
+    private AlbumItemRepository albumItemRepository;
+    @Override
+    public Mono<RStatus<Paged<Album>>> pageAlbum(AlbumDto albumDto) {
+
+        ArrayList<Where> wheres = new ArrayList<>();
+        if(StrUtil.isNotBlank(albumDto.getUserName())){
+            Where where = new Where();
+            where.setKey("user_name");
+            where.setWhereType(2);
+            where.setValue(albumDto.getUserName());
+            wheres.add(where);
+        }
+        if(Objects.nonNull(albumDto.getGroupId())){
+            Where where = new Where();
+            where.setKey("group_id");
+            where.setWhereType(1);
+            where.setValue(albumDto.getGroupId());
+            wheres.add(where);
+        }
+        Mono<RStatus<Paged<Album>>> page = sourceMaterialInterface.page(wheres, Album.class, albumDto.getSize(), albumDto.getPage());
+        return page;
+    }
+
+    @Override
+    @Transactional
+    public Mono<RStatus<Boolean>> addOrUpdate(AlbumReq albumReq) {
+        List<AlbumItemReq> list = albumReq.getList();
+        return Objects.isNull(albumReq.getAlbumId())?
+                addAlbum(albumReq,BaseContextHandler.getUserName(),BaseContextHandler.getUserId(),list)
+                :updateAlbum(albumReq, list);
+    }
+
     @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());
+    public Mono<RStatus<AlbumReq>> infoAlbum(Long id) {
+        Mono<AlbumReq> albumReqMono = albumInterface.getRedisOrMysql(id).flatMap(album -> {
+            AlbumReq albumReq = new AlbumReq();
+            albumReq.setAlbumId(album.albumId());
+            albumReq.setGroupId(album.groupId());
+            albumReq.setHeadUrl(album.headUrl());
+            albumReq.setGroupId(album.groupId());
+            albumReq.setUserName(album.groupName());
+            String s = album.imageListId();
+            Mono<List<AlbumItemReq>> listMono = Mono.just(List.of());
+            if (StringUtils.isNotEmpty(s)) {
+                List<Long> list1 = JSONUtil.parseArray(s).toList(Long.class);
+                listMono = Flux.fromIterable(list1).flatMap(itemid -> {
+                    return albumItemInterface.getRedisOrMysql(itemid);
+                }).flatMap(item -> {
+                    AlbumItemReq albumItemReq = new AlbumItemReq();
+                    albumItemReq.setId(item.id());
+                    albumItemReq.setUrl(item.url());
+                    albumItemReq.setStatus(item.status());
+                    return Mono.just(albumItemReq);
+                }).collectList();
+            }
+            return Mono.zip(listMono, Mono.just(albumReq)).flatMap(tuple -> {
+                List<AlbumItemReq> t1 =
+                        tuple.getT1().stream()
+                                .sorted(Comparator.comparing(AlbumItemReq::getStatus))
+                                .collect(Collectors.toList());
+                AlbumReq t2 = tuple.getT2();
+                t2.setList(t1);
+                return Mono.just(t2);
+            });
         });
+        return RStatus.success(albumReqMono);
+    }
 
-        return null;
+    @Override
+    @Transactional
+    public Mono<RStatus<Boolean>> deleteAlbum(Long id) {
+        Mono<Boolean> booleanMono = albumInterface.getRedisOrMysql(id).flatMap(album -> {
+            Mono<Boolean> then = Mono.just(true);
+            if (StringUtils.isNotEmpty(album.imageListId())) {
+                List<Long> list1 = JSONUtil.parseArray(album.imageListId()).toList(Long.class);
+                then = Flux.fromIterable(list1).flatMap(item -> {
+                    return albumItemInterface.deleteMysqlAndRedisCache(item);
+                }).then(Mono.just(true));
+            }
+            return then.then(albumInterface.deleteMysqlAndRedisCache(album.albumId())).then(Mono.just(true));
+        });
+        return RStatus.success(booleanMono);
     }
+
+    private Mono<RStatus<Boolean>> addAlbum(AlbumReq albumReq, String userName, String userId, List<AlbumItemReq> list) {
+
+        Mono<Boolean> then = Flux.fromIterable(list).flatMap(item -> {
+            return albumItemInterface.saveMysqlAndRedisCache(new AlbumItem(null, item.getUrl(), item.getStatus()));
+        }).collectList().switchIfEmpty(Mono.just(List.of()))
+                .flatMap(items -> {
+                    Album album = new Album(albumReq.getAlbumId(),
+                            albumReq.getHeadUrl(),
+                            albumReq.getGroupId(),
+                            albumReq.getGroupName(),
+                            items.size(),
+                            userName,
+                            userId,
+                            ZonedDateTime.now(),
+                            null,
+                            null,
+                            JSONUtil.toJsonStr(items.stream().map(AlbumItem::id).collect(Collectors.toList())),
+                            albumReq.getUserName()
+                    );
+                    return albumInterface.saveMysqlAndRedisCache(album);
+                }).then(Mono.just(true));
+        return RStatus.success(then);
+    }
+    private Mono<RStatus<Boolean>> updateAlbum(AlbumReq albumReq, List<AlbumItemReq> list) {
+        Mono<Boolean> booleanMono = albumInterface.getRedisOrMysql(albumReq.getAlbumId()).flatMap(album -> {
+            String s = album.imageListId();
+            Mono<Boolean> then = Mono.just(true);
+            if (StringUtils.isNotEmpty(s)) {
+                List<Long> list1 = JSONUtil.parseArray(s).toList(Long.class);
+                then = Flux.fromIterable(list1).flatMap(id -> {
+                    return albumItemInterface.deleteMysqlAndRedisCache(id);
+                }).then(Mono.just(true));
+            }
+            return then.then(Flux.fromIterable(list).flatMap(item -> {
+                return albumItemInterface.saveMysqlAndRedisCache(new AlbumItem(null, item.getUrl(), item.getStatus()));
+            }).collectList().switchIfEmpty(Mono.just(List.of()))
+                    .flatMap(items -> {
+                        Album albumNew = new Album(albumReq.getAlbumId(),
+                                albumReq.getHeadUrl(),
+                                albumReq.getGroupId(),
+                                albumReq.getGroupName(),
+                                items.size(),
+                                album.createUser(),
+                                album.createId(),
+                               null,
+                                ZonedDateTime.now(),
+                                null,
+                                JSONUtil.toJsonStr(items.stream().map(AlbumItem::id).collect(Collectors.toList())),
+                                albumReq.getUserName()
+                        );
+                        return albumInterface.saveMysqlAndRedisCache(albumNew);
+                    }).then(Mono.just(true)));
+        });
+        return RStatus.success(booleanMono);
+    }
+
+    //Todo  相册 Album >>>>>>>>>>>>>>>>
 }

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

@@ -1,11 +1,78 @@
 package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement;
 
 import com.webflux.launchadmin.mysql.controller.planNew.res.BackgroupImageRes;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.BackgroupGroup.*;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumDto;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.album.AlbumReq;
+import com.webflux.launchadmin.mysql.controller.sourceMaterial.data.image.ImageSaveRes;
 import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
 import com.webflux.launchcommon.returnObj.Paged;
 import com.webflux.launchcommon.returnObj.RStatus;
+import org.springframework.http.codec.multipart.FilePart;
 import reactor.core.publisher.Mono;
 
 public interface MaterialManagementInterface {
-    Mono<RStatus<Paged<BackgroupImageRes>>> pageBackgroup(Integer page, Integer size);
+
+
+    /**
+     * 保存BackgroupImage到mysqlandredis
+     * @param backgroupImage
+     * @return
+     */
+    Mono<BackgroupImage> saveMysqlAndRedisBackgroupImage(BackgroupImage backgroupImage);
+    /**
+     * 保存GroupType到mysqlandredis
+     * @param groupType
+     * @return
+     */
+    Mono<GroupType> saveMysqlAndRedisGroupType( GroupType groupType);
+    /**
+     * 保存BackgroupImageItem到mysqlandredis
+     * @param backgroupImageItem
+     * @return
+     */
+    Mono<Void> saveMysqlAndRedisBackgroupItem(BackgroupImageItem backgroupImageItem);
+
+
+    Mono<BackgroupImage> removeRedisAndMysqlBackgroupImage(Long id);
+    /**
+     * 背景组列表查询
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link BackgroupImageResNew}>>>
+     */
+    Mono<RStatus<Paged<BackgroupImageResNew>>> pageBackgroup(Integer page, Integer size);
+
+    /**
+     * 接口add
+     * @param dto
+     * @return
+     */
+    Mono<RStatus<BackgroupImageSaveResNew>> add(BackgroupImageSaveReqNew dto);
+    Mono<RStatus<BackgroupImageSaveResNew>> update(BackgroupImageSaveReqNew dto);
+
+    Mono<RStatus<BackgroupImagInfoeResNew>> info(BackgroupImageSaveResNew dto);
+    /**
+     * 逻辑删除backgroupImage
+     * @param dto
+     * @return
+     */
+    Mono<RStatus<BackgroupImageSaveResNew>> delete(BackgroupImageSaveResNew dto);
+
+
+    Mono<ExcelDataRes> importExcel(Mono<FilePart> file);
+
+    Mono<String> importDataExcel(ImageSaveRes data);
+
+    Mono<RStatus<Paged<Album>>> pageAlbum(AlbumDto albumDto);
+
+    Mono<RStatus<Boolean>> addOrUpdate(AlbumReq albumReq);
+
+
+    Mono<RStatus<AlbumReq>> infoAlbum(Long id);
+
+    Mono<RStatus<Boolean>> deleteAlbum(Long id);
 }

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

@@ -0,0 +1,41 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.AlbumItemRepository;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.AlbumRepository;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.AlbumInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.AlbumItemInterface;
+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.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+@Service
+public class AlbumItemService implements AlbumItemInterface {
+
+    @Resource
+    private AlbumItemRepository albumItemRepository;
+
+    @Override
+    @CachePut(cacheNames = MaterialManagementRedisKey.ALBUMITEM, key = "#albumItem.id")
+    public Mono<AlbumItem> saveMysqlAndRedisCache(AlbumItem albumItem) {
+        return albumItemRepository.save(albumItem);
+    }
+
+    // 删除缓存
+    @CacheEvict(cacheNames = MaterialManagementRedisKey.ALBUMITEM, key = "#id")
+    public Mono<Void> deleteMysqlAndRedisCache(Long id) {
+        return albumItemRepository.deleteById(id);
+    }
+    @Cacheable(cacheNames = MaterialManagementRedisKey.ALBUMITEM, key = "#id")
+    public Mono<AlbumItem> getRedisOrMysql(Long id) {
+        return albumItemRepository.findById(id)
+                .switchIfEmpty(Mono.error(new BaseException("id 查询结果为空")))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询异常：：" + throwable.getMessage())));
+    }
+
+}

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

@@ -0,0 +1,41 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.AlbumRepository;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.BackgroupImageRepository;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.AlbumInterface;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.BackgroupImageInterface;
+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.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+@Service
+public class AlbumService implements AlbumInterface {
+
+    @Resource
+    private AlbumRepository albumRepository;
+
+    @Override
+    @CachePut(cacheNames = MaterialManagementRedisKey.ALBUM, key = "#album.albumId")
+    public Mono<Album> saveMysqlAndRedisCache(Album album) {
+        return albumRepository.save(album);
+    }
+
+    // 删除缓存
+    @CacheEvict(cacheNames = MaterialManagementRedisKey.ALBUM, key = "#id")
+    public Mono<Void> deleteMysqlAndRedisCache(Long id) {
+        return albumRepository.deleteById(id);
+    }
+    @Cacheable(cacheNames = MaterialManagementRedisKey.ALBUM, key = "#id")
+    public Mono<Album> getRedisOrMysql(Long id) {
+        return albumRepository.findById(id)
+                .switchIfEmpty(Mono.error(new BaseException("id 查询结果为空")))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询异常：：" + throwable.getMessage())));
+    }
+
+}

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

@@ -0,0 +1,35 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.BackgroupImageItemRepository;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.BackgroupImageItemInterface;
+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.stereotype.Service;
+import reactor.core.publisher.Mono;
+@Service
+public class BackgroupImageItemService implements BackgroupImageItemInterface {
+
+    @Resource
+    private BackgroupImageItemRepository backgroupImageItem;
+
+    @Override
+    @CachePut(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGEITEM, key = "#backgroupImageItem.id")
+    public Mono<BackgroupImageItem> saveMysqlAndRedisBackgroupImageCache(BackgroupImageItem backgroupImageItem) {
+        return Mono.just(backgroupImageItem);
+    }
+    // 删除缓存
+    @Override
+    @CacheEvict(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGEITEM, key = "#backgroupImageItem.id")
+    public Mono<BackgroupImageItem> deleteMysqlAndRedisBackgroupImageCache(BackgroupImageItem backgroupImageItem) {
+        return Mono.just(backgroupImageItem);
+    }
+
+    @Override
+    @Cacheable(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGEITEM, key = "#id")
+    public Mono<BackgroupImageItem> getGroupImageItemMonoCache(Long id) {
+        return backgroupImageItem.findById(id);
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.BackgroupImageRepository;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.BackgroupImageInterface;
+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.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+@Service
+public class BackgroupImageService implements BackgroupImageInterface {
+
+    @Resource
+    private BackgroupImageRepository backgroupImageRepository;
+
+    @Override
+    @CachePut(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGE, key = "#backgroupImage.id")
+    public Mono<BackgroupImage> saveMysqlAndRedisBackgroupImageCache(BackgroupImage backgroupImage) {
+        return Mono.just(backgroupImage);
+    }
+
+    // 删除缓存
+    @CacheEvict(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGE, key = "#backgroupImage.id")
+    public Mono<BackgroupImage> deleteMysqlAndRedisBackgroupImageCache(BackgroupImage backgroupImage) {
+        return Mono.just(backgroupImage);
+    }
+    @Cacheable(cacheNames = MaterialManagementRedisKey.BACKGROUPIMAGE, key = "#id")
+    public Mono<BackgroupImage> getRedisOrMysqlBackgroupImage(Long id) {
+        return backgroupImageRepository.findById(id)
+                .switchIfEmpty(Mono.error(new BaseException("id 查询结果为空")))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询backgroupImage异常：：" + throwable.getMessage())));
+    }
+
+}

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

@@ -0,0 +1,21 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.repository.sourceMaterial.GroupTypeRepository;
+import com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist.GroupTypeinterface;
+import jakarta.annotation.Resource;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+@Service
+public class GroupTypeService implements GroupTypeinterface {
+    @Resource
+    GroupTypeRepository groupTypeRepository;
+
+    @Override
+    @CachePut(cacheNames = MaterialManagementRedisKey.GROUPTYPE,key = "#groupType.id()")
+    public Mono<GroupType> saveMysqlAndRedisGroupType(GroupType groupType) {
+        return Mono.just(groupType);
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache;
+
+
+public class MaterialManagementRedisKey {
+
+
+    //裂变计划缓存
+    public final static String START = "java-material-";
+    /**
+     * 背景图片
+     */
+    public final static String BACKGROUPIMAGE = START+"backgroup-image-cache";
+    /**
+     * 背景item图片
+     */
+    public final static String BACKGROUPIMAGEITEM= START+"backgroup-image-item-cache";
+    /**
+     * 分类
+     */
+    public final static String GROUPTYPE = START+"group-type-cache";
+
+    /**
+     * 相册
+     */
+    public final static String ALBUM = START+"album-cache";
+    /**
+     * 相册item
+     */
+    public final static String ALBUMITEM = START+"album-item-cache";
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/redisCache/interfacelist/AlbumInterface.java

@@ -0,0 +1,14 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import reactor.core.publisher.Mono;
+
+public interface AlbumInterface {
+
+
+    Mono<Album> saveMysqlAndRedisCache(Album album);
+    Mono<Void> deleteMysqlAndRedisCache(Long id);
+    Mono<Album> getRedisOrMysql(Long id);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/redisCache/interfacelist/AlbumItemInterface.java

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist;
+
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.Album;
+import com.webflux.launchadmin.mysql.entity.sourceMaterial.AlbumItem;
+import reactor.core.publisher.Mono;
+
+public interface AlbumItemInterface {
+    Mono<AlbumItem> saveMysqlAndRedisCache(AlbumItem albumItem);
+    Mono<Void> deleteMysqlAndRedisCache(Long id);
+    Mono<AlbumItem> getRedisOrMysql(Long id);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/redisCache/interfacelist/BackgroupImageInterface.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import reactor.core.publisher.Mono;
+
+public interface BackgroupImageInterface {
+    Mono<BackgroupImage> saveMysqlAndRedisBackgroupImageCache(BackgroupImage backgroupImage);
+    Mono<BackgroupImage> deleteMysqlAndRedisBackgroupImageCache(BackgroupImage backgroupImage);
+    Mono<BackgroupImage> getRedisOrMysqlBackgroupImage(Long id);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/redisCache/interfacelist/BackgroupImageItemInterface.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImageItem;
+import reactor.core.publisher.Mono;
+
+public interface BackgroupImageItemInterface {
+     Mono<BackgroupImageItem> saveMysqlAndRedisBackgroupImageCache(BackgroupImageItem backgroupImageItem);
+     Mono<BackgroupImageItem> deleteMysqlAndRedisBackgroupImageCache(BackgroupImageItem backgroupImageItem);
+      Mono<BackgroupImageItem> getGroupImageItemMonoCache(Long id);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/sourceMaterial/materialManagement/redisCache/interfacelist/GroupTypeinterface.java

@@ -0,0 +1,9 @@
+package com.webflux.launchadmin.mysql.service.sourceMaterial.materialManagement.redisCache.interfacelist;
+
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import reactor.core.publisher.Mono;
+
+public interface GroupTypeinterface {
+
+     Mono<GroupType> saveMysqlAndRedisGroupType(GroupType groupType);
+}

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

@@ -0,0 +1,26 @@
+package com.webflux.launchadmin.mysql.service.test;
+
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
+import com.weblux.launchredis.test.TweetTest;
+import jakarta.annotation.Resource;
+import org.springframework.beans.factory.annotation.Autowired;
+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.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+@Service
+public class OtherTweetService {
+
+    @Resource
+    private R2dbcEntityTemplate template;
+
+    @CachePut(cacheNames = "BackgroupImageCache", key = "#backgroupImage.id()")
+    public Mono<BackgroupImage> uinPerson1(BackgroupImage backgroupImage) {
+        return Mono.just(backgroupImage);
+    }
+}

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

@@ -1,10 +1,12 @@
 package com.webflux.launchadmin.mysql.service.test;
 
+import com.webflux.launchadmin.mysql.entity.planNew.BackgroupImage;
 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.beans.factory.annotation.Autowired;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.cache.annotation.Cacheable;
@@ -22,13 +24,37 @@ public class TweetService {
 
     @Resource
     private R2dbcEntityTemplate template;
-
+    @Autowired
+    private OtherTweetService self; // 自引用以确保代理对象调用
     // 读取缓存，如果缓存中有则直接返回，没有则从数据库查询并缓存
     @Cacheable(cacheNames = "TweetTest", key = "#id")
     public Mono<TweetTest> getPersonById(Long id) {
         return template.selectOne(Query.query(Criteria.where("id").is(id)), TweetTest.class);
     }
+    @Cacheable(cacheNames = "BackgroupImageCache", key = "#id")
+    public Mono<BackgroupImage> getBackIm(Long id) {
+        return template.selectOne(Query.query(Criteria.where("id").is(id)), BackgroupImage.class);
+    }
+    @Cacheable(cacheNames = "BackgroupImageCache", key = "#id")
+    public Mono<BackgroupImage> inBackIm(Long id) {
+        return template.selectOne(Query.query(Criteria.where("id").is(id)), BackgroupImage.class).flatMap(f->{
+            return uinPerson(f);
+        });
+    }
+  //  @CachePut(cacheNames = "BackgroupImageCache", key = "#backgroupImage.id")
+    public Mono<BackgroupImage> uinPerson(BackgroupImage backgroupImage) {
+        return template.insert(backgroupImage).flatMap(f -> self.uinPerson1(f));
 
+    }
+
+    @CachePut(cacheNames = "BackgroupImageCache", key = "#backgroupImage.id()")
+    public Mono<BackgroupImage> uinPerson1(BackgroupImage backgroupImage) {
+        return Mono.just(backgroupImage);
+    }
+    @CachePut(cacheNames = "BackgroupImageCache", key = "#backgroupImage.id()")
+    public Mono<BackgroupImage> uinPerson2(BackgroupImage backgroupImage) {
+        return template.update(backgroupImage);
+    }
     // 更新缓存，每次调用该方法时都会更新缓存
     @CachePut(cacheNames = "TweetTest", key = "#tweetTest.id")
     public Mono<TweetTest> updatePerson(TweetTest tweetTest) {

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/upload/UploadOssImpl.java

@@ -0,0 +1,187 @@
+package com.webflux.launchadmin.mysql.service.upload;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.StrUtil;
+import com.aliyun.oss.ClientException;
+import com.aliyun.oss.OSS;
+import com.aliyun.oss.OSSClientBuilder;
+import com.aliyun.oss.OSSException;
+import com.aliyun.oss.common.auth.CredentialsProvider;
+import com.aliyun.oss.common.auth.DefaultCredentialProvider;
+import com.aliyun.oss.model.PutObjectRequest;
+import com.aliyun.oss.model.PutObjectResult;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.oss.ImageDataRes;
+import jakarta.annotation.Resource;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.buffer.DataBufferUtils;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.http.codec.multipart.FilePart;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.util.Date;
+import java.util.UUID;
+
+@Service
+public  class UploadOssImpl implements UploadOssInterface {
+
+
+    // 访问域名
+    @Value("${aliyun.oss.domain}")
+    public String DOMAIN;
+
+    @Value("${aliyun.oss.endpoint}")
+    public String ALIYUN_OSS_ENDPOINT;
+
+    @Value("${aliyun.oss.accessKeyId}")
+    public String ALIYUN_OSS_ACCESSKEYID;
+
+    @Value("${aliyun.oss.accessKeySecret}")
+    public String ALIYUN_OSS_ACCESSKEYSECRET;
+
+    @Value("${aliyun.oss.bucketName}")
+    public String ALIYUN_OSS_BUCKET;
+    // 存储目录
+    @Value("${aliyun.oss.dir.prefix}")
+    public String ALIYUN_OSS_DIR_PRIFIX;
+    public final static String UPLOADHASHNAME = "sync_upload_hash_file_md5";
+    @Resource
+    private ReactiveRedisTemplate<String,String> reactiveRedisTemplate;
+    public String uploadByte(ByteArrayInputStream file, String filename )  {
+        String yyyyMMdd = DateUtil.format(new Date(), "yyyyMMdd");
+        String objectName = ALIYUN_OSS_DIR_PRIFIX+yyyyMMdd+"/"+filename;
+        CredentialsProvider credentialsProvider = new DefaultCredentialProvider(ALIYUN_OSS_ACCESSKEYID, ALIYUN_OSS_ACCESSKEYSECRET);
+        OSS ossClient = new OSSClientBuilder().build(ALIYUN_OSS_ENDPOINT, credentialsProvider);
+        try {
+            ossClient.putObject(ALIYUN_OSS_BUCKET, objectName, file);
+            return DOMAIN + "/" + objectName;
+        } catch (OSSException oe) {
+            String format = StrUtil.format("Error Message:{};Error Code:{};Request ID:{};Host ID:{}",
+                    oe.getErrorMessage(), oe.getErrorCode(), oe.getRequestId(), oe.getHostId());
+            throw new BaseException(format);
+        } catch (ClientException ce) {
+            String format = StrUtil.format("Error Message:{};Error Code:{};Request ID:{}",
+                    ce.getErrorMessage(), ce.getErrorCode(), ce.getRequestId());
+            throw new BaseException(format);
+        } finally {
+            if (ossClient != null) {
+                ossClient.shutdown();
+            }
+        }
+    }
+
+    public Mono<ByteArrayInputStream> convertFilePartToByteArrayInputStream(FilePart filePart) {
+        return filePart.content()
+                .collectList()
+                .flatMap(dataBuffers -> {
+                    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+                    dataBuffers.forEach(dataBuffer -> {
+                        byte[] bytes = new byte[dataBuffer.readableByteCount()];
+                        dataBuffer.read(bytes);
+                        try {
+                            byteArrayOutputStream.write(bytes);
+                        } catch (IOException e) {
+                            throw new RuntimeException("Error while writing data to ByteArrayOutputStream", e);
+                        } finally {
+                            DataBufferUtils.release(dataBuffer);
+                        }
+                    });
+                    return Mono.just(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
+                });
+    }
+
+    @Override
+    public Mono<ImageDataRes> uploadFile(Mono<FilePart> filePartMono) {
+        return  filePartMono.flatMap(filePart -> {
+            Mono<ByteArrayInputStream> byteArrayInputStreamMono = convertFilePartToByteArrayInputStream(filePart);
+            String filename1 = filePart.filename();
+            String[] split = filename1.split("\\.");
+            String filename ;
+            if(split.length>0){
+                 filename = UUID.randomUUID() + "." + split[split.length - 1];
+            }else {
+                 filename = UUID.randomUUID() +"-"+ filename1;
+            }
+            Mono<String> stringMono1 = byteArrayInputStreamMono.flatMap(f -> {
+                String md5 = calculateMd5(f);
+               return reactiveRedisTemplate.opsForHash().get(UPLOADHASHNAME,md5).switchIfEmpty(Mono.just("")).flatMap(redisV->{
+                    if("".equals(redisV)){
+                        String url = uploadByte(f, filename);
+                        Mono<Boolean> put = reactiveRedisTemplate.opsForHash().put(UPLOADHASHNAME, md5, url);
+                     return Mono.zip(put,Mono.just(url)).flatMap(end-> Mono.just(end.getT2()));
+                    }
+                    return Mono.just(redisV.toString());
+                });
+            });
+            return Mono.zip(stringMono1, Mono.just(filename1)).flatMap(f -> {
+                ImageDataRes imageDataRes = new ImageDataRes();
+                imageDataRes.setId(1L);
+                imageDataRes.setName(f.getT2());
+                imageDataRes.setUrl(f.getT1());
+                return Mono.just(imageDataRes);
+            });
+        });
+    }
+
+    public static String calculateMd5(ByteArrayInputStream inputStream)  {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
+            byte[] buffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+                messageDigest.update(buffer, 0, bytesRead);
+            }
+            byte[] digest = messageDigest.digest();
+            StringBuilder sb = new StringBuilder();
+            for (byte b : digest) {
+                sb.append(String.format("%02x", b));
+            }
+            return sb.toString();
+        } catch ( Exception e) {
+            throw new RuntimeException("MD5 algorithm not available", e);
+        }
+    }
+    /**
+     * 文件(未用)
+     * @param file
+     * @param filename
+     * @return
+     */
+    public String upload(File file, String filename ) {
+        String endpoint = ALIYUN_OSS_ENDPOINT;
+        String bucketName = ALIYUN_OSS_BUCKET;
+        String objectName = ALIYUN_OSS_DIR_PRIFIX+filename;
+        CredentialsProvider credentialsProvider = new DefaultCredentialProvider(ALIYUN_OSS_ACCESSKEYID, ALIYUN_OSS_ACCESSKEYSECRET);
+        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);
+        try {
+            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, file);
+            PutObjectResult result = ossClient.putObject(putObjectRequest);
+            String url =DOMAIN + "/" + objectName;
+            System.out.println(url);
+            System.out.println(url);
+            System.out.println(url);
+        } catch (OSSException oe) {
+            System.out.println("Caught an OSSException, which means your request made it to OSS, "
+                    + "but was rejected with an error response for some reason.");
+            System.out.println("Error Message:" + oe.getErrorMessage());
+            System.out.println("Error Code:" + oe.getErrorCode());
+            System.out.println("Request ID:" + oe.getRequestId());
+            System.out.println("Host ID:" + oe.getHostId());
+        } catch (ClientException ce) {
+            System.out.println("Caught an ClientException, which means the client encountered "
+                    + "a serious internal problem while trying to communicate with OSS, "
+                    + "such as not being able to access the network.");
+            System.out.println("Error Message:" + ce.getMessage());
+        } finally {
+            if (ossClient != null) {
+                ossClient.shutdown();
+            }
+        }
+        return "";
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/upload/UploadOssInterface.java

@@ -0,0 +1,19 @@
+package com.webflux.launchadmin.mysql.service.upload;
+
+import com.webflux.launchadmin.mysql.controller.oss.ImageDataRes;
+import org.springframework.http.codec.multipart.FilePart;
+import reactor.core.publisher.Mono;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+
+public interface UploadOssInterface {
+
+     String uploadByte(ByteArrayInputStream file, String filename );
+
+     String upload(File file, String filename );
+
+    Mono<ByteArrayInputStream> convertFilePartToByteArrayInputStream(FilePart filePart);
+
+    Mono<ImageDataRes> uploadFile(Mono<FilePart> filePartMono);
+}

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

@@ -4,12 +4,18 @@ spring:
       host: 47.103.172.247
       port: 52525
       password: NTZY_LOg666%$_redis
-      database: 1
+      database: 2
       timeout: 10000
   r2dbc:
     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
+    pool:
+      initial-size: 20       # 初始化连接数
+      max-size: 100           # 最大连接数
+      max-idle-time: 30m     # 最大空闲时间
+      max-lifetime: 60m      # 连接的最大生命周期时间
+      min-idle: 20            # 最小空闲连接数
 
 go:
   data:

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

@@ -15,8 +15,12 @@ spring:
     username: wx_share_liuwei
     password: Wx_ShARe56578AwCH
     pool:
-      max-size: 1000
-      initial-size: 100
+      initial-size: 20       # 初始化连接数
+      max-size: 200           # 最大连接数
+      max-idle-time: 30m     # 最大空闲时间
+      max-lifetime: 60m      # 连接的最大生命周期时间
+      min-idle: 20            # 最小空闲连接数
+
 
 go:
   data:

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

@@ -9,7 +9,10 @@ spring:
     active: dev
   codec:
     max-in-memory-size: -1  # 或者其他合适的值
-
+  servlet:
+    multipart:
+      max-file-size: 10MB
+      max-request-size: 10MB
 
 xxl:
   sso:
@@ -27,4 +30,14 @@ management:
     health:
       show-details: "always"
   web:
-    base-path: "/actuator"
+    base-path: "/actuator"
+
+aliyun:
+  oss:
+    domain: https://typer-oss.mokamrp.com
+    endpoint: oss-cn-shanghai.aliyuncs.com # oss对外服务的访问域名
+    accessKeyId: LTAI4GGeL2FNtDWkoVFj5hgW # 访问身份验证中用到用户标识
+    accessKeySecret: yupnbKYmIEk41YoiI4pOcfBYugDnt5 # 用户用于加密签名字符串和oss用来验证签名字符串的密钥
+    bucketName: typer # oss的存储空间
+    dir:
+      prefix: wx_share/upload/ # 上传文件夹路径前缀

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

@@ -1,14 +1,16 @@
 package com.weblux.launchredis.test;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.relational.core.mapping.Table;
 
 import java.io.Serializable;
+import java.time.ZonedDateTime;
 
 /**
  * Created by rajeevkumarsingh on 08/09/17.
  */
 @Table("t_weet")
-public record TweetTest(@Id Long id, String text)  implements Serializable {
+public record TweetTest(@Id Long id, String text, @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt)  implements Serializable {
 
 }