package com.takensoft.cms.token.service.impl;

 import com.takensoft.cms.token.dao.RefreshTokenDAO;

 import com.takensoft.cms.token.service.RefreshTokenService;

 import com.takensoft.cms.mber.vo.MberAuthorVO;

 import com.takensoft.cms.mber.vo.MberVO;

 import com.takensoft.cms.token.vo.RefreshTknVO;

 import com.takensoft.common.util.HttpRequestUtil;

 import com.takensoft.common.util.JWTUtil;

 import io.jsonwebtoken.ExpiredJwtException;

 import lombok.RequiredArgsConstructor;

 import org.egovframe.rte.fdl.cmmn.EgovAbstractServiceImpl;

     private final RefreshTokenDAO refreshTokenDAO;

     private final JWTUtil jwtUtil;

     private final HttpRequestUtil httpRequestUtil;

     private final RedisTemplate<String, String> redisTemplate;

     @Value("${jwt.accessTime}")

             refreshTknVO.setMbrId((String) jwtUtil.getClaim(refreshTokenCheck(req).get("refreshToken").toString(), "mbrId"));

             //중복로그인 비허용시 삭제

                 redisTemplate.delete("jwt:" + refreshTknVO.getMbrId()); // 기존 JWT 삭제

             }

             return delete(req, refreshTknVO);

             String userId = (String) jwtUtil.getClaim(refreshToken, "mbrId");

             // 중복 로그인 비허용 체크 (DB에 저장된 리프레시 토큰과 비교)

                 String storedRefreshToken = redisTemplate.opsForValue().get("jwt:" + userId);

                 if (storedRefreshToken == null || !storedRefreshToken.equals(refreshToken)) {

     public int delete(HttpServletRequest req, RefreshTknVO refreshTknVO) {

             refreshTknVO.setUseIp(httpRequestUtil.getIp(req));

             //중복로그인 비허용시 삭제

                 redisTemplate.delete("jwt:" + refreshTknVO.getMbrId()); // 기존 JWT 삭제

             }

             return refreshTokenDAO.deleteByRefresh(refreshTknVO);

 package com.takensoft.cms.token.web;

 import com.takensoft.cms.token.service.RefreshTokenService;

 import com.takensoft.common.message.MessageCode;

 import com.takensoft.common.util.ResponseData;

 import com.takensoft.common.util.ResponseUtil;

 import lombok.RequiredArgsConstructor;

 import lombok.extern.slf4j.Slf4j;

 import org.springframework.http.HttpHeaders;

 import org.springframework.http.HttpStatus;

 import org.springframework.http.MediaType;

 import org.springframework.http.ResponseEntity;

 import org.springframework.web.bind.annotation.PostMapping;

 import org.springframework.web.bind.annotation.RestController;

     private final ResponseUtil resUtil;

     private final RefreshTokenService refreshTokenService;

     /**

      * @param req - HTTP 요청 객체

      * @param res - HTTP 응답 객체

      */

     @PostMapping(value = "/mbr/logout.json")

     public ResponseEntity<?> logout(HttpServletRequest req, HttpServletResponse res){

             return resUtil.successRes(result, MessageCode.LOGOUT_SUCCESS);

         }

     }

     /**

 package com.takensoft.common.config;

 import com.takensoft.cms.accesCtrl.service.AccesCtrlService;

 import com.takensoft.cms.mber.service.LgnHstryService;

 import com.takensoft.cms.token.service.RefreshTokenService;

 import com.takensoft.common.filter.AccesFilter;

 import com.takensoft.common.exception.CustomAccessDenieHandler;

 import com.takensoft.common.exception.CustomAuthenticationEntryPoint;

 import com.takensoft.common.util.JWTUtil;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

     private final CustomAccessDenieHandler accessDenieHandler;

     private final HttpRequestUtil httpRequestUtil;

     private final AppConfig appConfig;

     private static String FRONT_URL;    // 프론트 접근 허용 URL

     private static long JWT_ACCESSTIME; // access 토큰 유지 시간

      * @param jwtUtil - JWT 유틸리티 객체

      * @param authenticationEntryPoint - 인증 실패 시 처리 엔트리 포인트

      * @param accessDenieHandler - 접근 거부 처리 핸들러

      * @param fUrl - 프론트엔드 URL (application.yml에서 값을 읽어 옴)

      * @param aTime - JWT 접근 토큰 유효 시간 (application.yml에서 값을 읽어 옴)

      * @param rTime - JWT 리프레시 토큰 유효 시간 (application.yml에서 값을 읽어 옴)

      * @param redisTemplate

 *

      */

                           LgnHstryService lgnHstryService, CustomAuthenticationEntryPoint authenticationEntryPoint, CustomAccessDenieHandler accessDenieHandler, HttpRequestUtil httpRequestUtil,

         this.authenticationConfiguration = authenticationConfiguration;

         this.refreshTokenService = refreshTokenService;

         this.jwtUtil = jwtUtil;

         this.httpRequestUtil = httpRequestUtil;

         this.appConfig = appConfig;

         this.FRONT_URL = fUrl;

         this.JWT_ACCESSTIME = aTime;

         this.JWT_REFRESHTIME = rTime;

 //                .anyRequest().permitAll() // 모든 사용자 접근 가능

         );

         } else {

         }

         http.addFilterBefore(new AccesFilter(accesCtrlService, httpRequestUtil, appConfig), JWTFilter.class); // 아이피 검증

         http.addFilterAt(new LoginFilter(authenticationManager(authenticationConfiguration), jwtUtil, refreshTokenService, lgnHstryService, httpRequestUtil,

         return http.build();

     }

 package com.takensoft.common.filter;

 import com.takensoft.cms.mber.vo.MberAuthorVO;

 import com.takensoft.cms.mber.vo.MberVO;

 import com.takensoft.common.config.AppConfig;

 import com.takensoft.common.exception.FilterExceptionHandler;

 import com.takensoft.common.util.ErrorResponse;

 import com.takensoft.common.util.JWTUtil;

 import io.jsonwebtoken.ExpiredJwtException;

 import io.jsonwebtoken.JwtException;

 import org.springframework.data.redis.core.RedisTemplate;

     private static final String AUTHORIZATION_HEADER = "Authorization";

     private final JWTUtil jwtUtil;

     private final AppConfig appConfig;

     private final RedisTemplate<String, String> redisTemplate;

     /**

      * @param jwtUtil JWT 유틸리티 클래스의 인스턴스

      *

      * JWTFilter 생성자

      */

         this.jwtUtil = jwtUtil;

         this.appConfig = appConfig;

         this.redisTemplate = redisTemplate;

     }

     /**

             // 중복 로그인 비허용 설정이면 Redis에서 최신 JWT 가져와 비교

             String userId = (String) jwtUtil.getClaim(accessToken, "mbrId");

                 String storedToken = redisTemplate.opsForValue().get("jwt:" + userId);

                 if (storedToken == null) {

                 } else if (!storedToken.equals(accessToken)) {

 package com.takensoft.common.filter;

 import com.fasterxml.jackson.databind.ObjectMapper;

 import com.takensoft.cms.mber.dto.LoginDTO;

 import com.takensoft.cms.mber.service.LgnHstryService;

 import com.takensoft.cms.token.service.RefreshTokenService;

 import com.takensoft.common.exception.FilterExceptionHandler;

 import com.takensoft.common.util.HttpRequestUtil;

 import com.takensoft.common.util.JWTUtil;

 import lombok.SneakyThrows;

 import org.springframework.beans.factory.annotation.Value;

 import org.springframework.data.redis.core.RedisTemplate;

 import org.springframework.security.authentication.AuthenticationManager;

 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

 import org.springframework.security.core.Authentication;

     private final RefreshTokenService refreshTokenService;

     private final LgnHstryService lgnHstryService;

     private final HttpRequestUtil httpRequestUtil;

     private static long JWT_ACCESSTIME; // access 토큰 유지 시간

     private static long JWT_REFRESHTIME; // refresh 토큰 유지 시간

      * LoginFilter 생성자

      */

     public LoginFilter(AuthenticationManager authenticationManager, JWTUtil jwtUtil, RefreshTokenService refreshTokenService, LgnHstryService lgnHstryService, HttpRequestUtil httpRequestUtil,

         this.authenticationManager = authenticationManager;

         this.jwtUtil = jwtUtil;

         this.refreshTokenService = refreshTokenService;

         this.lgnHstryService = lgnHstryService;

         this.httpRequestUtil = httpRequestUtil;

         this.JWT_ACCESSTIME = aTime;

         this.JWT_REFRESHTIME = rTime;

         this.COOKIE_TIME = ctime;

      */

     @SneakyThrows

     @Override

         MberVO mber = (MberVO) authentication.getPrincipal();

         // 로그인 이력 등록

         lgnHstryVO.setBrwsrNm(httpRequestUtil.getBrowser(httpRequestUtil.getUserAgent(req)));

         lgnHstryService.LgnHstrySave(lgnHstryVO);

         // 토큰 생성(access, refresh)

         String accessToken = jwtUtil.createJwt("Authorization", mber.getMbrId(), mber.getLgnId(), mber.getMbrNm(), (List) mber.getAuthorities(), JWT_ACCESSTIME);

         String refreshToken = jwtUtil.createJwt("refresh", mber.getMbrId(), mber.getLgnId(), mber.getMbrNm(), (List) mber.getAuthorities(), JWT_REFRESHTIME);

         }

         // refreshToken DB 저장

         refresh.setToken(refreshToken);

         }

     }

     /**

 package com.takensoft.common.filter;

 import com.takensoft.cms.mber.vo.MberAuthorVO;

 import com.takensoft.cms.mber.vo.MberVO;

 import com.takensoft.common.util.JWTUtil;

 import jakarta.servlet.FilterChain;

 import jakarta.servlet.ServletException;

 import jakarta.servlet.http.HttpServletRequest;

     private final JWTUtil jwtUtil;

     private final RedisTemplate<String, String> redisTemplate;

         this.jwtUtil = jwtUtil;

         this.redisTemplate = redisTemplate;

     }

     /**

      * @param request HttpServletRequest 객체

      * 세션 Filter 검증

      */

     @Override

         HttpSession session = request.getSession(false);

         if (session == null || session.getAttribute("JWT_TOKEN") == null) {

             response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");

         }

         // 중복 로그인 허용 여부 확인

             String mbrId = (String) jwtUtil.getClaim(accessToken, "mbrId");

             String storedToken = redisTemplate.opsForValue().get("jwt:" + mbrId);

             if (storedToken != null && !storedToken.equals(accessToken)) {

         mber.setMbrNm((String) jwtUtil.getClaim(accessToken, "mbrNm"));

         mber.setAuthorList(roles);

         filterChain.doFilter(request, response);

     }

     // 로그인 방식

     @Bean(name = "loginModeIdgen")

     public IdgenService loginModeIdgen() {

     }

 }