Browse Source

feat : redis 완료

pull/7/head
qkr7828 7 months ago
parent
commit
c2df8e6f56
  1. 5
      README.md
  2. 9
      app/kac-app/build.gradle
  3. 96
      app/kac-app/src/main/java/kr/co/palnet/kac/app/config/CachingConfig.java
  4. 101
      app/kac-app/src/main/java/kr/co/palnet/kac/app/config/RedisCacheConfig.java
  5. 8
      app/kac-app/src/main/resources/application.yml
  6. 15
      data/com/src/main/java/kr/co/palnet/kac/data/com/domain/ComCdGroupBas.java
  7. 34
      data/com/src/main/java/kr/co/palnet/kac/data/com/service/ComCodeDomainService.java
  8. 7
      docker-compose.yml
  9. 18
      web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/controller/ComCodeController.java
  10. 14
      web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/model/CodeGroupRSWrapper.java
  11. 12
      web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/model/CodeRsWrapper.java
  12. 65
      web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/service/ComCodeService.java

5
README.md

@ -17,6 +17,11 @@
```
docker-compose up -d database
```
### 1-1. redis 설치
docker-compose up -d redis
cmd -> docker exec -it redis_cache /bin/bash -> redis-cli 명령어로 접근 가능하다.
### 2. application.yml 설정 변경

9
app/kac-app/build.gradle

@ -25,9 +25,12 @@ dependencies {
//cache
implementation 'org.springframework.boot:spring-boot-starter-cache'
implementation 'org.ehcache:ehcache:3.10.0'
implementation 'org.hibernate:hibernate-jcache:6.0.2.Final'
implementation 'javax.cache:cache-api:1.1.1'
// implementation 'org.ehcache:ehcache:3.10.0'
// implementation 'org.hibernate:hibernate-jcache:6.0.2.Final'
// implementation 'javax.cache:cache-api:1.1.1'
//redis
implementation 'org.springframework.boot:spring-boot-starter-data-redis:3.2.2'
// rest doc
asciidoctorExt 'org.springframework.restdocs:spring-restdocs-asciidoctor'

96
app/kac-app/src/main/java/kr/co/palnet/kac/app/config/CachingConfig.java

@ -1,46 +1,50 @@
package kr.co.palnet.kac.app.config;
import java.time.Duration;
import javax.cache.CacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.ExpiryPolicyBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.EntryUnit;
import org.ehcache.config.units.MemoryUnit;
import org.ehcache.jsr107.Eh107Configuration;
import org.hibernate.cache.jcache.ConfigSettings;
import org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@EnableCaching
@Configuration
public class CachingConfig {
private final javax.cache.configuration.Configuration<Object, Object> jCacheConfiguration;
public CachingConfig() {
this.jCacheConfiguration = Eh107Configuration.fromEhcacheCacheConfiguration(CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
ResourcePoolsBuilder.newResourcePoolsBuilder()
.heap(10000, EntryUnit.ENTRIES))
.withSizeOfMaxObjectSize(1000, MemoryUnit.B)
.withExpiry(ExpiryPolicyBuilder.timeToIdleExpiration(Duration.ofSeconds(200)))
.withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(400))));
}
@Bean
public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(CacheManager cacheManager) {
return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
}
@Bean
public JCacheManagerCustomizer cacheManagerCustomizer() {
return cm -> {
cm.createCache("code", jCacheConfiguration);
};
}
}
//package kr.co.palnet.kac.app.config;
//
//import java.time.Duration;
//
//import javax.cache.CacheManager;
//
//import org.ehcache.config.builders.CacheConfigurationBuilder;
//import org.ehcache.config.builders.ExpiryPolicyBuilder;
//import org.ehcache.config.builders.ResourcePoolsBuilder;
//import org.ehcache.config.units.EntryUnit;
//import org.ehcache.config.units.MemoryUnit;
//import org.ehcache.jsr107.Eh107Configuration;
//import org.hibernate.cache.jcache.ConfigSettings;
//import org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer;
//import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
//import org.springframework.cache.annotation.EnableCaching;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//
//@EnableCaching
//@Configuration
//public class CachingConfig {
//
// private final javax.cache.configuration.Configuration<Object, Object> jCacheConfiguration;
//
// public CachingConfig() {
// this.jCacheConfiguration = Eh107Configuration.fromEhcacheCacheConfiguration(CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
// ResourcePoolsBuilder.newResourcePoolsBuilder()
// .heap(10000, EntryUnit.ENTRIES))
// .withSizeOfMaxObjectSize(1000, MemoryUnit.B)
// .withExpiry(ExpiryPolicyBuilder.timeToIdleExpiration(Duration.ofSeconds(200)))
// .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(400))));
// }
//
//
// @Bean
// public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(CacheManager cacheManager) {
// return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
// }
//
// @Bean
// public JCacheManagerCustomizer cacheManagerCustomizer() {
// return new JCacheManagerCustomizer() {
// @Override
// public void customize(javax.cache.CacheManager cm) {
// cm.createCache("code", jCacheConfiguration);
// }
// };
// }
//}

101
app/kac-app/src/main/java/kr/co/palnet/kac/app/config/RedisCacheConfig.java

@ -0,0 +1,101 @@
package kr.co.palnet.kac.app.config;
import java.time.Duration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
@Configuration
@EnableCaching
public class RedisCacheConfig {
@Value("${spring.data.redis.host}")
private String redisHost;
@Value("${spring.data.redis.port}")
private int redisPort;
@Value("${spring.data.redis.password}")
private String redisPwd;
@Bean
public RedisConnectionFactory redisConnectionFactory() {
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(redisHost);
redisStandaloneConfiguration.setPort(redisPort);
redisStandaloneConfiguration.setPassword(redisPwd);
LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(redisStandaloneConfiguration);
return lettuceConnectionFactory;
}
// @Bean
// public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
// // local date time 역직렬화 위해 추가 코드
// ObjectMapper objectMapper = new ObjectMapper();
// objectMapper.registerModule(new JavaTimeModule());
// objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
//
// RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
// .entryTtl(Duration.ofSeconds(600))
// .disableCachingNullValues()
// .serializeKeysWith(
// RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
// )
// .serializeValuesWith(
// RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer)
// );
//
// Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
// for (CacheType value : CacheType.values()) {
// cacheConfigurations.put(value.name(),
// RedisCacheConfiguration.defaultCacheConfig()
// .prefixCacheNameWith("code")
// .entryTtl(Duration.ofSeconds(600))
// .disableCachingNullValues()
// .serializeKeysWith(
// RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
// )
// .serializeValuesWith(
// RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer)
// ));
// }
//
// return RedisCacheManager.RedisCacheManagerBuilder
// .fromConnectionFactory(connectionFactory)
// .cacheDefaults(configuration)
// .withInitialCacheConfigurations(cacheConfigurations).build();
// }
@Bean
public CacheManager redisCacheManager(RedisConnectionFactory cf) {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JavaTimeModule());
objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
.entryTtl(Duration.ofMinutes(3L));
return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(cf).cacheDefaults(redisCacheConfiguration).build();
}
}

8
app/kac-app/src/main/resources/application.yml

@ -11,7 +11,13 @@ spring:
ddl-auto: none
naming:
physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
cache:
type: redis
data:
redis:
host: 127.0.0.1
port: 6379
password : palnet!234
logging:
level:
kr.co.palnet: DEBUG

15
data/com/src/main/java/kr/co/palnet/kac/data/com/domain/ComCdGroupBas.java

@ -1,14 +1,21 @@
package kr.co.palnet.kac.data.com.domain;
import jakarta.persistence.*;
import java.time.LocalDateTime;
import java.util.List;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.Lob;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
import java.util.List;
@Data
@NoArgsConstructor

34
data/com/src/main/java/kr/co/palnet/kac/data/com/service/ComCodeDomainService.java

@ -1,30 +1,28 @@
package kr.co.palnet.kac.data.com.service;
import kr.co.palnet.kac.data.com.domain.ComCdBas;
import kr.co.palnet.kac.data.com.domain.ComCdGroupBas;
import kr.co.palnet.kac.data.com.domain.ComCdLangCtg;
import kr.co.palnet.kac.data.com.repository.ComCdBasRepository;
import kr.co.palnet.kac.data.com.repository.ComCdGroupBasRepository;
import kr.co.palnet.kac.data.com.repository.ComCdLangCtgRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import java.time.LocalDateTime;
import java.util.List;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import kr.co.palnet.kac.data.com.domain.ComCdBas;
import kr.co.palnet.kac.data.com.domain.ComCdGroupBas;
import kr.co.palnet.kac.data.com.domain.ComCdLangCtg;
import kr.co.palnet.kac.data.com.repository.ComCdBasRepository;
import kr.co.palnet.kac.data.com.repository.ComCdGroupBasRepository;
import kr.co.palnet.kac.data.com.repository.ComCdLangCtgRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Transactional
@RequiredArgsConstructor
@Service
@CacheConfig(cacheNames = "code")
public class ComCodeDomainService {
private final ComCdGroupBasRepository comCdGroupBasRepository;
@ -33,45 +31,38 @@ public class ComCodeDomainService {
// 그룹 조회
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "'all'")
public List<ComCdGroupBas> getComCdGroupBasList() {
return comCdGroupBasRepository.findAll();
}
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "#siteCd")
public List<ComCdGroupBas> getComCdGroupBasList(String siteCd) {
return comCdGroupBasRepository.findBySiteCd(siteCd);
}
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "#groupCd")
public ComCdGroupBas getComCdGroupBas(String groupCd) {
return comCdGroupBasRepository.findById(groupCd).orElse(null);
}
// 코드 조회
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "#groupCd")
public List<ComCdBas> getComCdBasList(String groupCd) {
return comCdBasRepository.findByGroupCdAndUseYnOrderBySortOrdrAsc(groupCd, "Y");
}
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "'KeyIs' + #groupCd + #cdId")
public ComCdBas getComCdBas(String groupCd, String cdId) {
return comCdBasRepository.findByGroupCdAndCdIdAndUseYn(groupCd, cdId, "Y");
}
// 언어 조회
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "'KeyIs' + #groupCd + #cdId")
public List<ComCdLangCtg> getComCdLangCtgList(String groupCd, String cdId) {
return comCdLangCtgRepository.findByGroupCdAndCdId(groupCd, cdId);
}
@Transactional(readOnly = true)
@Cacheable(value = "code", key = "'KeyIs' + #groupCd + #cdId + #langDivCd")
public ComCdLangCtg getComCdLangCtg(String groupCd, String cdId, String langDivCd) {
ComCdLangCtg.ComCdLangCtgId id = ComCdLangCtg.ComCdLangCtgId.builder()
.groupCd(groupCd)
@ -143,7 +134,6 @@ public class ComCodeDomainService {
// TODO Exception 처리
// 그룹 수정
@CachePut(value = "code", key = "#comCdGroupBas.groupCd")
public ComCdGroupBas updateComCdGroupBas(ComCdGroupBas comCdGroupBas) {
var bas = comCdGroupBasRepository.findById(comCdGroupBas.getGroupCd()).orElseThrow(() -> {
throw new RuntimeException("존재하지 않는 코드 그룹입니다.");
@ -160,7 +150,6 @@ public class ComCodeDomainService {
// TODO 일자 및 사용자 넣기
// TODO Exception 처리
// 코드 수정
@CachePut(value = "code", key = "'KeyIs' + #comCdGBas.groupCd + #comCdBas.cdId")
public ComCdBas updateComCdBas(ComCdBas comCdBas) {
var id = ComCdBas.ComCdBasId.builder()
@ -202,13 +191,11 @@ public class ComCodeDomainService {
}
// 그룹 삭제
@CacheEvict(value = "code", key = "#groupCd")
public void deleteComCdGroupBas(String groupCd) {
comCdGroupBasRepository.deleteById(groupCd);
}
// 코드 삭제
@CacheEvict(value = "code", key = "'KeyIs' + #groupCd + #cdId")
public void deleteComCdBas(String groupCd, String cdId) {
var id = ComCdBas.ComCdBasId.builder()
.groupCd(groupCd)
@ -218,7 +205,6 @@ public class ComCodeDomainService {
}
// 언어 삭제
@CacheEvict(value = "code", key = "'KeyIs' + #groupCd + #cdId + langDivCd")
public void deleteComCdLangCtg(String groupCd, String cdId, String langDivCd) {
var id = ComCdLangCtg.ComCdLangCtgId.builder()
.groupCd(groupCd)

7
docker-compose.yml

@ -1,5 +1,11 @@
version: "3"
services:
redis:
image: redis:latest
container_name: kac_redis
command: redis-server --requirepass palnet!234 --port 6379
ports:
- 6379:6379
database:
image: mysql
container_name: kac-db
@ -30,6 +36,5 @@ services:
SPRING_PROFILES_ACTIVE: dev
networks:
- pav_kac_networks
networks: #네트워크 설정
pav_kac_networks:

18
web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/controller/ComCodeController.java

@ -3,6 +3,8 @@ package kr.co.palnet.kac.api.v1.common.code.controller;
import java.util.List;
import kr.co.palnet.kac.api.v1.common.code.service.ComCodeService;
import kr.co.palnet.kac.data.com.domain.ComCdGroupBas;
import kr.co.palnet.kac.data.com.domain.ComCdLangCtg;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
@ -21,8 +23,10 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import kr.co.palnet.kac.api.v1.common.code.model.CodeDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupRS;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupRSWrapper;
import kr.co.palnet.kac.api.v1.common.code.model.CodeLangDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeRS;
import kr.co.palnet.kac.api.v1.common.code.model.CodeRsWrapper;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeGroupRQ;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeLangRQ;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeRQ;
@ -38,30 +42,30 @@ import lombok.RequiredArgsConstructor;
public class ComCodeController {
private final ComCodeService comCodeService;
/* 사용 용도 */
// 전체 코드 조회 - 코드그룹-코드-언어
@GetMapping("/all")
@Operation(summary = "전체 코드 조회", description = "전체 코드를 조회합니다.")
public ResponseEntity<List<CodeGroupRS>> getAllGroup(SearchCodeAllRQ rq) {
List<CodeGroupRS> allCode = comCodeService.getAllGroup(rq);
return ResponseEntity.ok(allCode);
CodeGroupRSWrapper allCode = comCodeService.getAllGroup(rq);
return ResponseEntity.ok(allCode.getCodeGroupRS());
}
// 그룹 목록 조회 - 코드 그룹만
@GetMapping("/group")
@Operation(summary = "코드 그룹 조회", description = "코드 그룹을 조회합니다.")
public ResponseEntity<List<CodeGroupRS>> getAllGroupCode() {
List<CodeGroupRS> codeGroupRSList = comCodeService.getAllGroupCode();
return ResponseEntity.ok(codeGroupRSList);
CodeGroupRSWrapper codeGroupRSList = comCodeService.getAllGroupCode();
return ResponseEntity.ok(codeGroupRSList.getCodeGroupRS());
}
// 코드 목록 조회 - 코드 - 언어
@GetMapping("/code")
@Operation(summary = "코드 목록 조회", description = "코드 목록을 조회합니다.")
public ResponseEntity<List<CodeRS>> getAllCodeByGroup(SearchCodeRQ rq) {
List<CodeRS> list = comCodeService.getAllCodeByGroup(rq);
return ResponseEntity.ok(list);
CodeRsWrapper list = comCodeService.getAllCodeByGroup(rq);
return ResponseEntity.ok(list.getCodeRS());
}
/* 관리 용도 */

14
web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/model/CodeGroupRSWrapper.java

@ -0,0 +1,14 @@
package kr.co.palnet.kac.api.v1.common.code.model;
import java.util.List;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class CodeGroupRSWrapper {
private List<CodeGroupRS> codeGroupRS;
}

12
web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/model/CodeRsWrapper.java

@ -0,0 +1,12 @@
package kr.co.palnet.kac.api.v1.common.code.model;
import java.util.List;
import lombok.Data;
@Data
public class CodeRsWrapper {
private List<CodeRS> CodeRS;
}

65
web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/service/ComCodeService.java

@ -1,26 +1,44 @@
package kr.co.palnet.kac.api.v1.common.code.service;
import kr.co.palnet.kac.api.v1.common.code.model.*;
import java.util.Comparator;
import java.util.List;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import kr.co.palnet.kac.api.v1.common.code.model.CodeDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupRS;
import kr.co.palnet.kac.api.v1.common.code.model.CodeGroupRSWrapper;
import kr.co.palnet.kac.api.v1.common.code.model.CodeLangDTO;
import kr.co.palnet.kac.api.v1.common.code.model.CodeRS;
import kr.co.palnet.kac.api.v1.common.code.model.CodeRsWrapper;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeGroupRQ;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeLangRQ;
import kr.co.palnet.kac.api.v1.common.code.model.FormCodeRQ;
import kr.co.palnet.kac.api.v1.common.code.model.SearchCodeAllRQ;
import kr.co.palnet.kac.api.v1.common.code.model.SearchCodeRQ;
import kr.co.palnet.kac.data.com.domain.ComCdBas;
import kr.co.palnet.kac.data.com.domain.ComCdGroupBas;
import kr.co.palnet.kac.data.com.domain.ComCdLangCtg;
import kr.co.palnet.kac.data.com.service.ComCodeDomainService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Comparator;
import java.util.List;
@Slf4j
@RequiredArgsConstructor
@Service
@CacheConfig(cacheNames = "code")
public class ComCodeService {
private final ComCodeDomainService comCodeDomainService;
// 모든 코드 조회
public List<CodeGroupRS> getAllGroup(SearchCodeAllRQ rq) {
@Cacheable(value = "code", key = "#rq?.siteCd", cacheManager = "redisCacheManager")
public CodeGroupRSWrapper getAllGroup(SearchCodeAllRQ rq) {
List<ComCdGroupBas> comCdGroupBasList = comCodeDomainService.getComCdGroupBasList(rq.getSiteCd());
List<CodeGroupRS> codeGroupRSList = comCdGroupBasList.stream().map(group -> {
@ -28,7 +46,7 @@ public class ComCodeService {
List<ComCdBas> comCdBasList = group.getComCdBasList();
if (comCdBasList != null && !comCdBasList.isEmpty()) {
// TODO 계층 구조 필요시 적용
// TODO 계층 구조 필요시 적용
List<CodeRS> codeRSList = comCdBasList.stream().map(code -> {
CodeRS codeRS = CodeRS.toRS(code);
if (code.getComCdLangCtgList() != null && !code.getComCdLangCtgList().isEmpty()) {
@ -43,20 +61,28 @@ public class ComCodeService {
return codeGroupRS;
}).toList();
return codeGroupRSList;
CodeGroupRSWrapper rs = new CodeGroupRSWrapper();
rs.setCodeGroupRS(codeGroupRSList);
return rs;
}
// 그룹 목록 조회 - 코드 그룹만
public List<CodeGroupRS> getAllGroupCode() {
@Cacheable(value = "code", key = "'all'" , cacheManager = "reidsCacheManager")
public CodeGroupRSWrapper getAllGroupCode() {
List<ComCdGroupBas> comCdGroupBasList = comCodeDomainService.getComCdGroupBasList();
return comCdGroupBasList.stream().map(CodeGroupRS::toRS).toList();
List<CodeGroupRS> rs = comCdGroupBasList.stream().map(CodeGroupRS::toRS).toList();
CodeGroupRSWrapper result = new CodeGroupRSWrapper();
result.setCodeGroupRS(rs);
return result;
}
// 코드 목록 조회 - 코드 - 언어
public List<CodeRS> getAllCodeByGroup(SearchCodeRQ rq) {
@Cacheable(value = "code", key = "#rq?.groupCd", cacheManager = "redisCacheManager")
public CodeRsWrapper getAllCodeByGroup(SearchCodeRQ rq) {
List<ComCdBas> comCdBasList = comCodeDomainService.getComCdBasList(rq.getGroupCd());
return comCdBasList.stream().map(entity -> {
List<CodeRS> rs = comCdBasList.stream().map(entity -> {
CodeRS codeRS = CodeRS.toRS(entity);
if (entity.getComCdLangCtgList() != null && !entity.getComCdLangCtgList().isEmpty()) {
entity.getComCdLangCtgList().stream().filter(lang ->
@ -65,6 +91,11 @@ public class ComCodeService {
}
return codeRS;
}).toList();
CodeRsWrapper result = new CodeRsWrapper();
result.setCodeRS(rs);
return result;
}
// 코드 그룹 등록
@ -90,6 +121,7 @@ public class ComCodeService {
// 코드 그룹 수정
@CachePut(value = "code", cacheManager = "redisCacheManager")
public CodeGroupDTO updateCodeGroup(FormCodeGroupRQ rq) {
ComCdGroupBas entity = rq.toEntity();
ComCdGroupBas comCdGroupBas = comCodeDomainService.updateComCdGroupBas(entity);
@ -97,6 +129,7 @@ public class ComCodeService {
}
// 코드 수정
@CachePut(value = "code", cacheManager = "redisCacheManager")
public CodeDTO updateCode(FormCodeRQ rq) {
ComCdBas entity = rq.toEntity();
ComCdBas comCdBas = comCodeDomainService.updateComCdBas(entity);
@ -104,6 +137,7 @@ public class ComCodeService {
}
// 언어 수정
@CachePut(value = "code", cacheManager = "redisCacheManager")
public CodeLangDTO updateCodeLang(FormCodeLangRQ rq) {
ComCdLangCtg entity = rq.toEntity();
ComCdLangCtg comCdLangCtg = comCodeDomainService.updateComCdLangCtg(entity);
@ -111,16 +145,19 @@ public class ComCodeService {
}
// 코드 그룹 삭제
@CacheEvict(value = "code", key = "#groupCd" , cacheManager = "redisCacheManager")
public void deleteCodeGroup(String groupCd) {
comCodeDomainService.deleteComCdGroupBas(groupCd);
}
// 코드 삭제
@CacheEvict(value = "code", key = "'KeyIs' + #groupCd + #cdId" , cacheManager = "redisCacheManager")
public void deleteCode(String groupCd, String cdId) {
comCodeDomainService.deleteComCdBas(groupCd, cdId);
}
// 언어 삭제
@CacheEvict(value = "code", key = "'KeyIs' + #groupCd + #cdId + #langDivCd" , cacheManager = "redisCacheManager")
public void deleteLang(String groupCd, String cdId, String langDivCd) {
comCodeDomainService.deleteComCdLangCtg(groupCd, cdId, langDivCd);
}

Loading…
Cancel
Save