게시글 작성/수정시 금칙어 체크 로직 추가

- update ftl path
- delete duplicate security settings

README.md

@@ -3,7 +3,7 @@
 ### 0. 개요
 - SpringBoot2 framework 기반에서 RESTful api 서비스를 Step by Step으로 만들어 나가는 프로젝트
 - daddyprogrammer.org에서 연재 및 소스 Github 등록
-    - https://daddyprogrammer.org/post/series/springboot2%EB%A1%9C-rest-api-%EB%A7%8C%EB%93%A4%EA%B8%B0/
+    - https://daddyprogrammer.org/post/series/springboot2-make-rest-api/
 
 ### 1. 개발환경
 - Java 8~11
@@ -115,3 +115,8 @@ alter table user_roles
         - https://daddyprogrammer.org/post/2695/springboot2-simple-jpa-board/
     - Git
         - https://github.com/codej99/SpringRestApi/tree/feature/board
+  - SpringBoot2로 Rest api 만들기(15) – Redis로 api 결과 캐싱(Caching)처리
+    - Document
+        - https://daddyprogrammer.org/post/3870/spring-rest-api-redis-caching/
+    - Git
+        - https://github.com/codej99/SpringRestApi/tree/cache-data-redis

build.gradle

@@ -26,6 +26,9 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-security'
     implementation 'org.springframework.boot:spring-boot-starter-actuator'
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+    //embedded-redis
+    implementation 'it.ozimov:embedded-redis:0.7.2'
     implementation 'io.jsonwebtoken:jjwt:0.9.1'
     implementation 'io.springfox:springfox-swagger2:2.6.1'
     implementation 'io.springfox:springfox-swagger-ui:2.6.1'

src/main/java/com/rest/api/advice/ExceptionAdvice.java

@@ -77,6 +77,12 @@ public class ExceptionAdvice {
         return responseService.getFailResult(Integer.valueOf(getMessage("resourceNotExist.code")), getMessage("resourceNotExist.msg"));
     }
 
+    @ExceptionHandler(CForbiddenWordException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public CommonResult forbiddenWordException(HttpServletRequest request, CForbiddenWordException e) {
+        return responseService.getFailResult(Integer.valueOf(getMessage("forbiddenWord.code")), getMessage("forbiddenWord.msg", new Object[]{e.getMessage()}));
+    }
+
     // code정보에 해당하는 메시지를 조회합니다.
     private String getMessage(String code) {
         return getMessage(code, null);

src/main/java/com/rest/api/advice/exception/CForbiddenWordException.java

@@ -0,0 +1,16 @@
+package com.rest.api.advice.exception;
+
+public class CForbiddenWordException extends RuntimeException {
+
+    public CForbiddenWordException(String msg, Throwable t) {
+        super(msg, t);
+    }
+
+    public CForbiddenWordException(String msg) {
+        super(msg);
+    }
+
+    public CForbiddenWordException() {
+        super();
+    }
+}

src/main/java/com/rest/api/annotation/ForbiddenWordCheck.java

@@ -0,0 +1,15 @@
+package com.rest.api.annotation;
+
+import com.rest.api.model.board.ParamsPost;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ForbiddenWordCheck {
+    String param() default "paramsPost.content";
+    Class<?> checkClazz() default ParamsPost.class;
+}

src/main/java/com/rest/api/annotation/aspect/ForbiddenWordCheckAspect.java

@@ -0,0 +1,74 @@
+package com.rest.api.annotation.aspect;
+
+import com.rest.api.advice.exception.CForbiddenWordException;
+import com.rest.api.annotation.ForbiddenWordCheck;
+import io.micrometer.core.instrument.util.StringUtils;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+@Aspect
+@Component
+public class ForbiddenWordCheckAspect {
+
+    // 어노테이션이 설정된 메서드의 메인 프로세스가 시작되기전(Before)에 금칙어 체크 로직이 적용된다.
+    @Before(value = "@annotation(forbiddenWordCheck)")
+    public void forbiddenWordCheck(JoinPoint pjp, ForbiddenWordCheck forbiddenWordCheck) throws Throwable {
+        // 금칙어를 체크할 메서드의 파라미터가 객체인지(객체.필드명) 일반 String인지에 따라 구분하여 처리한다.
+        String[] param = forbiddenWordCheck.param().split("\\.");
+        String paramName;
+        String fieldName = "";
+        if (param.length == 2) {
+            paramName = param[0];
+            fieldName = param[1];
+        } else {
+            paramName = forbiddenWordCheck.param();
+        }
+        // 메서드의 파라미터 이름으로 메서드의 몇번째 파라미터인지 구한다.
+        Integer parameterIdx = getParameterIdx(pjp, paramName);
+        if (parameterIdx == -1)
+            throw new IllegalArgumentException();
+
+        String checkWord;
+        // 객체내의 필드값에서 금칙어 체크 문장을 얻어내야 할 경우
+        if (StringUtils.isNotEmpty(fieldName)) {
+            Class<?> clazz = forbiddenWordCheck.checkClazz();
+            Field field = clazz.getDeclaredField(fieldName);
+            field.setAccessible(true);
+            checkWord = (String) field.get(pjp.getArgs()[parameterIdx]);
+        // 금칙어 체크 문장이 String형의 파라미터로 넘어오는 경우
+        } else {
+            checkWord = (String) pjp.getArgs()[parameterIdx];
+        }
+        // 체크할 문장에 금칙어가 포함되어 있는지 확인
+        checkForbiddenWord(checkWord);
+    }
+
+    // 메서드의 파라미터 이름으로 몇번째에 파라미터가 위치하는지 구함
+    private Integer getParameterIdx(JoinPoint joinPoint, String paramName) {
+        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
+        String[] parameterNames = methodSignature.getParameterNames();
+        for (int i = 0; i < parameterNames.length; i++) {
+            String parameterName = parameterNames[i];
+            if (paramName.equals(parameterName)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    // 입력된 문장에 금칙어가 포함되어 있으면 Exception을 발생시킨다.
+    private void checkForbiddenWord(String word) {
+        List<String> forbiddenWords = Arrays.asList("개새끼", "쌍년", "씨발");
+        Optional<String> forbiddenWord = forbiddenWords.stream().filter(word::contains).findFirst();
+        if (forbiddenWord.isPresent())
+            throw new CForbiddenWordException(forbiddenWord.get());
+    }
+}

src/main/java/com/rest/api/common/CacheKey.java

@@ -0,0 +1,14 @@
+package com.rest.api.common;
+
+public class CacheKey {
+
+    public static final int DEFAULT_EXPIRE_SEC = 60; // 1 minutes
+    public static final String USER = "user";
+    public static final int USER_EXPIRE_SEC = 60 * 5; // 5 minutes
+    public static final String BOARD = "board";
+    public static final int BOARD_EXPIRE_SEC = 60 * 10; // 10 minutes
+    public static final String POST = "post";
+    public static final String POSTS = "posts";
+    public static final int POST_EXPIRE_SEC = 60 * 5; // 5 minutes
+
+}

src/main/java/com/rest/api/config/EmbeddedRedisConfig.java

@@ -0,0 +1,35 @@
+package com.rest.api.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import redis.embedded.RedisServer;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+
+/**
+ * 로컬 환경일경우 내장 레디스가 실행된다.
+ */
+@Profile("local")
+@Configuration
+public class EmbeddedRedisConfig {
+
+    @Value("${spring.redis.port}")
+    private int redisPort;
+
+    private RedisServer redisServer;
+
+    @PostConstruct
+    public void redisServer() {
+        redisServer = new RedisServer(redisPort);
+        redisServer.start();
+    }
+
+    @PreDestroy
+    public void stopRedis() {
+        if (redisServer != null) {
+            redisServer.stop();
+        }
+    }
+}

src/main/java/com/rest/api/config/RedisConfig.java

@@ -0,0 +1,47 @@
+package com.rest.api.config;
+
+import com.rest.api.common.CacheKey;
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.CacheKeyPrefix;
+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.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+
+@RequiredArgsConstructor
+@EnableCaching
+@Configuration
+public class RedisConfig {
+
+    @Bean(name = "cacheManager")
+    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
+
+        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
+                .disableCachingNullValues()
+                .entryTtl(Duration.ofSeconds(CacheKey.DEFAULT_EXPIRE_SEC))
+                .computePrefixWith(CacheKeyPrefix.simple())
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
+
+        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
+        // 캐시 default 유효시간 설정
+        cacheConfigurations.put(CacheKey.USER, RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofSeconds(CacheKey.USER_EXPIRE_SEC)));
+        cacheConfigurations.put(CacheKey.BOARD, RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofSeconds(CacheKey.BOARD_EXPIRE_SEC)));
+        cacheConfigurations.put(CacheKey.POST, RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofSeconds(CacheKey.POST_EXPIRE_SEC)));
+        cacheConfigurations.put(CacheKey.POSTS, RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofSeconds(CacheKey.POST_EXPIRE_SEC)));
+
+        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory).cacheDefaults(configuration)
+                .withInitialCacheConfigurations(cacheConfigurations).build();
+    }
+}

src/main/java/com/rest/api/config/security/JwtTokenProvider.java

@@ -25,7 +25,7 @@ public class JwtTokenProvider { // JWT 토큰을 생성 및 검증 모듈
     @Value("${spring.jwt.secret}")
     private String secretKey;
 
-    private long tokenValidMilisecond = 1000L * 60 * 60; // 1시간만 토큰 유효
+    private long tokenValidMilisecond = 1000L * 60 * 60 * 24; // 24시간만 토큰 유효
 
     private final UserDetailsService userDetailsService;
 

src/main/java/com/rest/api/config/security/SecurityConfiguration.java

@@ -32,7 +32,7 @@ public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
             .and()
                 .authorizeRequests() // 다음 리퀘스트에 대한 사용권한 체크
                     .antMatchers("/*/signin", "/*/signin/**", "/*/signup", "/*/signup/**", "/social/**").permitAll() // 가입 및 인증 주소는 누구나 접근가능
-                    .antMatchers(HttpMethod.GET, "/exception/**", "/helloworld/**","/actuator/health", "/v1/board/**").permitAll() // hellowworld로 시작하는 GET요청 리소스는 누구나 접근가능
+                    .antMatchers(HttpMethod.GET, "/exception/**", "/helloworld/**","/actuator/health", "/v1/board/**", "/favicon.ico").permitAll() // 등록된 GET요청 리소스는 누구나 접근가능
                     .anyRequest().hasRole("USER") // 그외 나머지 요청은 모두 인증된 회원만 접근 가능
             .and()
                 .exceptionHandling().accessDeniedHandler(new CustomAccessDeniedHandler())

src/main/java/com/rest/api/controller/HelloController.java

@@ -37,7 +37,7 @@ public class HelloController {
 
     @GetMapping(value = "/helloworld/page")
     public String helloworld() {
-        return HELLO;
+        return "helloworld";
     }
 
     @GetMapping("/helloworld/long-process")

src/main/java/com/rest/api/controller/v1/board/BoardController.java

@@ -28,6 +28,15 @@ public class BoardController {
     private final BoardService boardService;
     private final ResponseService responseService;
 
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "X-AUTH-TOKEN", value = "로그인 성공 후 access_token", required = true, dataType = "String", paramType = "header")
+    })
+    @ApiOperation(value = "게시판 생성", notes = "신규 게시판을 생성한다.")
+    @PostMapping(value = "/{boardName}")
+    public SingleResult<Board> createBoard(@PathVariable String boardName) {
+        return responseService.getSingleResult(boardService.insertBoard(boardName));
+    }
+
     @ApiOperation(value = "게시판 정보 조회", notes = "게시판 정보를 조회한다.")
     @GetMapping(value = "/{boardName}")
     public SingleResult<Board> boardInfo(@PathVariable String boardName) {
@@ -44,7 +53,7 @@ public class BoardController {
             @ApiImplicitParam(name = "X-AUTH-TOKEN", value = "로그인 성공 후 access_token", required = true, dataType = "String", paramType = "header")
     })
     @ApiOperation(value = "게시글 작성", notes = "게시글을 작성한다.")
-    @PostMapping(value = "/{boardName}")
+    @PostMapping(value = "/{boardName}/post")
     public SingleResult<Post> post(@PathVariable String boardName, @Valid @ModelAttribute ParamsPost post) {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
         String uid = authentication.getName();

src/main/java/com/rest/api/entity/User.java

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.rest.api.entity.common.CommonDateEntity;
 import lombok.*;
+import org.hibernate.annotations.Proxy;
 import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.authority.SimpleGrantedAuthority;
 import org.springframework.security.core.userdetails.UserDetails;
@@ -22,6 +23,7 @@ import java.util.stream.Collectors;
 @AllArgsConstructor // 인자를 모두 갖춘 생성자를 자동으로 생성합니다.
 @Table(name = "user") // 'user' 테이블과 매핑됨을 명시
 @JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) // Post Entity에서 User와의 관계를 Json으로 변환시 오류 방지를 위한 코드
+@Proxy(lazy = false)
 public class User extends CommonDateEntity implements UserDetails {
     @Id // pk
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/com/rest/api/entity/board/Board.java

@@ -1,15 +1,20 @@
 package com.rest.api.entity.board;
 
 import com.rest.api.entity.common.CommonDateEntity;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 import javax.persistence.*;
+import java.io.Serializable;
 
+@Builder
 @Entity
 @Getter
 @NoArgsConstructor
-public class Board extends CommonDateEntity {
+@AllArgsConstructor
+public class Board extends CommonDateEntity implements Serializable {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long boardId;

src/main/java/com/rest/api/entity/board/Post.java

@@ -1,16 +1,21 @@
 package com.rest.api.entity.board;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.rest.api.entity.User;
 import com.rest.api.entity.common.CommonDateEntity;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.Proxy;
 
 import javax.persistence.*;
+import java.io.Serializable;
 
 @Entity
 @Getter
+@Setter
 @NoArgsConstructor
-public class Post extends CommonDateEntity {
+public class Post extends CommonDateEntity implements Serializable {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long postId;
@@ -25,13 +30,13 @@ public class Post extends CommonDateEntity {
     @JoinColumn(name = "board_id")
     private Board board; // 게시글 - 게시판의 관계 - N:1
 
-
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "msrl")
     private User user;  // 게시글 - 회원의 관계 - N:1
 
     // Join 테이블이 Json결과에 표시되지 않도록 처리.
-    protected Board getBoard() {
+    @JsonIgnore
+    public Board getBoard() {
         return board;
     }
 

src/main/java/com/rest/api/entity/common/CommonDateEntity.java

@@ -7,12 +7,13 @@ import org.springframework.data.jpa.domain.support.AuditingEntityListener;
 
 import javax.persistence.EntityListeners;
 import javax.persistence.MappedSuperclass;
+import java.io.Serializable;
 import java.time.LocalDateTime;
 
 @Getter
 @MappedSuperclass
 @EntityListeners(AuditingEntityListener.class)
-public abstract class CommonDateEntity {
+public abstract class CommonDateEntity implements Serializable {
     @CreatedDate
     private LocalDateTime createdAt;
     @LastModifiedDate

src/main/java/com/rest/api/repo/board/PostJpaRepo.java

@@ -7,5 +7,5 @@ import org.springframework.data.jpa.repository.JpaRepository;
 import java.util.List;
 
 public interface PostJpaRepo extends JpaRepository<Post, Long> {
-    List<Post> findByBoard(Board board);
+    List<Post> findByBoardOrderByPostIdDesc(Board board);
 }

src/main/java/com/rest/api/service/board/BoardService.java

@@ -1,8 +1,11 @@
 package com.rest.api.service.board;
 
+import com.rest.api.advice.exception.CForbiddenWordException;
 import com.rest.api.advice.exception.CNotOwnerException;
 import com.rest.api.advice.exception.CResourceNotExistException;
 import com.rest.api.advice.exception.CUserNotFoundException;
+import com.rest.api.annotation.ForbiddenWordCheck;
+import com.rest.api.common.CacheKey;
 import com.rest.api.entity.User;
 import com.rest.api.entity.board.Board;
 import com.rest.api.entity.board.Post;
@@ -10,13 +13,20 @@ import com.rest.api.model.board.ParamsPost;
 import com.rest.api.repo.UserJpaRepo;
 import com.rest.api.repo.board.BoardJpaRepo;
 import com.rest.api.repo.board.PostJpaRepo;
+import com.rest.api.service.cache.CacheSevice;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
 import javax.transaction.Transactional;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
+@Slf4j
 @Service
 @Transactional
 @RequiredArgsConstructor
@@ -25,47 +35,62 @@ public class BoardService {
     private final BoardJpaRepo boardJpaRepo;
     private final PostJpaRepo postJpaRepo;
     private final UserJpaRepo userJpaRepo;
+    private final CacheSevice cacheSevice;
+
+    public Board insertBoard(String boardName) {
+        return boardJpaRepo.save(Board.builder().name(boardName).build());
+    }
 
     // 게시판 이름으로 게시판을 조회. 없을경우 CResourceNotExistException 처리
+    @Cacheable(value = CacheKey.BOARD, key = "#boardName", unless = "#result == null")
     public Board findBoard(String boardName) {
         return Optional.ofNullable(boardJpaRepo.findByName(boardName)).orElseThrow(CResourceNotExistException::new);
     }
 
-    // 게시판 이름으로 게시물 리스트 조회.
+    // 게시판 이름으로 게시글 리스트 조회.
+    @Cacheable(value = CacheKey.POSTS, key = "#boardName", unless = "#result == null")
     public List<Post> findPosts(String boardName) {
-        return postJpaRepo.findByBoard(findBoard(boardName));
+        return postJpaRepo.findByBoardOrderByPostIdDesc(findBoard(boardName));
     }
 
-    // 게시물ID로 게시물 단건 조회. 없을경우 CResourceNotExistException 처리
+    // 게시글ID로 게시글 단건 조회. 없을경우 CResourceNotExistException 처리
+    @Cacheable(value = CacheKey.POST, key = "#postId", unless = "#result == null")
     public Post getPost(long postId) {
         return postJpaRepo.findById(postId).orElseThrow(CResourceNotExistException::new);
     }
 
-    // 게시물을 등록합니다. 게시물의 회원UID가 조회되지 않으면 CUserNotFoundException 처리합니다.
+    // 게시글을 등록합니다. 게시글의 회원UID가 조회되지 않으면 CUserNotFoundException 처리합니다.
+    @CacheEvict(value = CacheKey.POSTS, key = "#boardName")
+    @ForbiddenWordCheck
     public Post writePost(String uid, String boardName, ParamsPost paramsPost) {
         Board board = findBoard(boardName);
         Post post = new Post(userJpaRepo.findByUid(uid).orElseThrow(CUserNotFoundException::new), board, paramsPost.getAuthor(), paramsPost.getTitle(), paramsPost.getContent());
         return postJpaRepo.save(post);
     }
 
-    // 게시물을 수정합니다. 게시물 등록자와 로그인 회원정보가 틀리면 CNotOwnerException 처리합니다.
+    // 게시글을 수정합니다. 게시글 등록자와 로그인 회원정보가 틀리면 CNotOwnerException 처리합니다.
+    //@CachePut(value = CacheKey.POST, key = "#postId") 갱신된 정보만 캐시할경우에만 사용!
+    @ForbiddenWordCheck
     public Post updatePost(long postId, String uid, ParamsPost paramsPost) {
         Post post = getPost(postId);
         User user = post.getUser();
         if (!uid.equals(user.getUid()))
             throw new CNotOwnerException();
 
+        // 영속성 컨텍스트의 변경감지(dirty checking) 기능에 의해 조회한 Post내용을 변경만 해도 Update쿼리가 실행됩니다.
         post.setUpdate(paramsPost.getAuthor(), paramsPost.getTitle(), paramsPost.getContent());
+        cacheSevice.deleteBoardCache(post.getPostId(), post.getBoard().getName());
         return post;
     }
 
-    // 게시물을 삭제합니다. 게시물 등록자와 로그인 회원정보가 틀리면 CNotOwnerException 처리합니다.
+    // 게시글을 삭제합니다. 게시글 등록자와 로그인 회원정보가 틀리면 CNotOwnerException 처리합니다.
     public boolean deletePost(long postId, String uid) {
         Post post = getPost(postId);
         User user = post.getUser();
         if (!uid.equals(user.getUid()))
             throw new CNotOwnerException();
         postJpaRepo.delete(post);
+        cacheSevice.deleteBoardCache(post.getPostId(), post.getBoard().getName());
         return true;
     }
 }

src/main/java/com/rest/api/service/cache/CacheSevice.java

@@ -0,0 +1,21 @@
+package com.rest.api.service.cache;
+
+import com.rest.api.common.CacheKey;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Caching;
+import org.springframework.stereotype.Service;
+
+@Slf4j
+@Service
+public class CacheSevice {
+
+    @Caching(evict = {
+            @CacheEvict(value = CacheKey.POST, key = "#postId"),
+            @CacheEvict(value = CacheKey.POSTS, key = "#boardName")
+    })
+    public boolean deleteBoardCache(long postId, String boardName) {
+        log.debug("deleteBoardCache - postId {}, boardName {}", postId, boardName);
+        return true;
+    }
+}

src/main/java/com/rest/api/service/security/CustomUserDetailService.java

@@ -1,8 +1,10 @@
 package com.rest.api.service.security;
 
 import com.rest.api.advice.exception.CUserNotFoundException;
+import com.rest.api.common.CacheKey;
 import com.rest.api.repo.UserJpaRepo;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.stereotype.Service;
@@ -13,6 +15,7 @@ public class CustomUserDetailService implements UserDetailsService {
 
     private final UserJpaRepo userJpaRepo;
 
+    @Cacheable(value = CacheKey.USER, key = "#userPk", unless = "#result == null")
     public UserDetails loadUserByUsername(String userPk) {
         return userJpaRepo.findById(Long.valueOf(userPk)).orElseThrow(CUserNotFoundException::new);
     }

src/main/resources/application-alpha.yml

@@ -21,4 +21,7 @@ spring:
     showSql: true
     generate-ddl: false
   url:
-    base: http://dev-api.daddyprogrammer.org
+    base: http://dev-api.daddyprogrammer.org
+  redis:
+    host: Standalone Redis 호스트
+    port: Standalone Redis 포트

src/main/resources/application-local.yml

@@ -1,6 +1,6 @@
 logging:
   level:
-    root: info
+    root: debug
     com.rest.api: debug
 
 spring:
@@ -18,3 +18,6 @@ spring:
     generate-ddl: true
   url:
     base: http://localhost:8080
+  redis:
+    host: localhost
+    port: 6379

src/main/resources/i18n/exception_en.yml

@@ -24,4 +24,7 @@ notOwner:
   msg: "You are not the owner of this resource."
 resourceNotExist:
   code: "-1007"
-  msg: "This resource does not exist."
+  msg: "This resource does not exist."
+forbiddenWord:
+  code: "-1008"
+  msg: "forbidden words ({0}) are included in the input."

src/main/resources/i18n/exception_ko.yml

@@ -24,4 +24,7 @@ notOwner:
   msg: "해당 자원의 소유자가 아닙니다."
 resourceNotExist:
   code: "-1007"
-  msg: "요청한 자원이 존재 하지 않습니다."
+  msg: "요청한 자원이 존재 하지 않습니다."
+forbiddenWord:
+  code: "-1008"
+  msg: "입력한 내용에 금칙어({0})가 포함되어 있습니다."

src/test/java/com/rest/api/cache/CacheRepo.java

@@ -0,0 +1,67 @@
+package com.rest.api.cache;
+
+import com.rest.api.entity.board.Post;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class CacheRepo {
+
+    private static final String CACHE_KEY = "CACHE_TEST";
+
+    @Cacheable(value = CACHE_KEY, key = "#postId")
+    public Post getPost(long postId) {
+        Post post = new Post();
+        post.setPostId(postId);
+        post.setTitle("title_" + postId);
+        post.setAuthor("author_" + postId);
+        post.setContent("content_" + postId);
+        return post;
+    }
+
+    @CachePut(value = CACHE_KEY, key = "#post.postId")
+    public Post updatePost(Post post) {
+        return post;
+    }
+
+    @Cacheable(value = CACHE_KEY, key = "{#postId, #title}")
+    public Post getPostMultiKey(long postId, String title) {
+        Post post = new Post();
+        post.setPostId(postId);
+        post.setTitle("title_" + postId);
+        post.setAuthor("author_" + postId);
+        post.setContent("content_" + postId);
+        return post;
+    }
+
+    @CachePut(value = CACHE_KEY, key = "{#post.postId, #post.title}")
+//    @CachePut(value = CACHE_KEY, key = "{#post.postId, #post.getTitle()}")
+    public Post updatePostMultiKey(Post post) {
+        return post;
+    }
+
+    @CacheEvict(cacheNames = {CACHE_KEY}, allEntries = true)
+    public void clearCache(){}
+
+    @Cacheable(value = CACHE_KEY, key = "{#postId}", condition="#postId > 10")
+    public Post getPostCondition(long postId) {
+        Post post = new Post();
+        post.setPostId(postId);
+        post.setTitle("title_" + postId);
+        post.setAuthor("author_" + postId);
+        post.setContent("content_" + postId);
+        return post;
+    }
+
+    @Cacheable(value = CACHE_KEY, key = "T(com.rest.api.cache.CustomKeyGenerator).create(#postId, #title)")
+    public Post getPostKeyGenerator(long postId, String title) {
+        Post post = new Post();
+        post.setPostId(postId);
+        post.setTitle("title_" + postId);
+        post.setAuthor("author_" + postId);
+        post.setContent("content_" + postId);
+        return post;
+    }
+}

src/test/java/com/rest/api/cache/CacheTest.java

@@ -0,0 +1,67 @@
+package com.rest.api.cache;
+
+import com.rest.api.entity.board.Post;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.junit.Assert.*;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class CacheTest {
+
+    @Autowired
+    private CacheRepo cacheRepo;
+
+    @Test
+    public void cacheTest() throws Exception {
+        // get cache
+        Post post = cacheRepo.getPost(1L);
+        assertSame(1L, post.getPostId());
+        assertEquals("title_1", post.getTitle());
+        // update cache
+        post.setTitle("title_modified");
+        post.setContent("content_modified");
+        cacheRepo.updatePost(post);
+        // get cache
+        Post postModified = cacheRepo.getPost(1L);
+        assertEquals("title_modified", postModified.getTitle());
+        assertEquals("content_modified", postModified.getContent());
+    }
+
+    @Test
+    public void cacheTestMultiKey() throws Exception {
+        // get cache
+        Post post = cacheRepo.getPostMultiKey(1L, "title_1");
+        assertSame(1L, post.getPostId());
+        assertEquals("title_1", post.getTitle());
+        // update cache
+        post.setTitle("title_modified");
+        post.setContent("content_modified");
+        cacheRepo.updatePostMultiKey(post);
+        // get cache
+        Post postModified = cacheRepo.getPostMultiKey(1L, "title_modified");
+        assertEquals("title_modified", postModified.getTitle());
+        assertEquals("content_modified", postModified.getContent());
+    }
+
+    @Test
+    public void cacheTestCustomKeyGenerator() throws Exception {
+        // get cache
+        Post post = cacheRepo.getPostKeyGenerator(1L, "title_1");
+        assertSame(1L, post.getPostId());
+        assertEquals("title_1", post.getTitle());
+    }
+
+    @Test
+    public void deleteAllCache() {
+        cacheRepo.getPost(1L);
+        cacheRepo.getPost(2L);
+        cacheRepo.getPost(3L);
+        cacheRepo.getPost(4L);
+        cacheRepo.clearCache();
+    }
+}

src/test/java/com/rest/api/cache/CustomKeyGenerator.java

@@ -0,0 +1,7 @@
+package com.rest.api.cache;
+
+public class CustomKeyGenerator {
+    public static Object create(Object o1, Object o2) {
+        return "FRONT:" + o1 + ":" + o2;
+    }
+}