@Override

     public String getLoginMode() {

     }

     /**

 import org.springframework.http.ResponseEntity;

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

 /**

  * @author 김혜민

             int result = loginModeService.insertLoginMode(loginModeVO);

                 // JWT 전체 로그아웃

                 Set<String> keys = redisTemplate.keys("jwt:*");

                 if (keys != null && !keys.isEmpty()) redisTemplate.delete(keys);

             } else {

                 // 세션 전체 로그아웃

                 sessionUtil.invalidateAllSessions();

             if (result > 0) {

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

      * refresh token 전체 삭제

      */

     public int deleteAll();

 }

      *

      * refresh token 검증

      */

         Map<String, Object> result = new HashMap <String, Object>();

         // header 방식

 //        String refreshToken = req.getHeader("refresh");

         // 쿠키 방식

             result.put("result", 0);

             return result;

         }

         }

         return refreshTokenDAO.deleteAll(); // DB에서 리프레시 토큰 전부 삭제

     }

 }

             refresh.setMbrId(mbrId);

             int result =  refreshTokenService.delete(req, refresh);

                 // 세션 방식: 세션 만료 + SessionMap에서 제거

                 HttpSession session = req.getSession(false);

                 if (session != null) session.invalidate();

 package com.takensoft.common.config;

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

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.data.redis.connection.RedisConnectionFactory;

     private int redisPort;

     @Bean

     public RedisConnectionFactory redisConnectionFactory() {

         return new LettuceConnectionFactory(redisHost, redisPort);

     }

     @Bean

     public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

         RedisTemplate<String, String> redisTemp = new RedisTemplate<>();

         redisTemp.setConnectionFactory(redisConnectionFactory);

         // 로그인 방식에 따라 필터 적용 (JWT or 세션)

         if (loginModeService.getLoginMode().equals("S")) {

         } else {

             http.addFilterBefore(new JWTFilter(jwtUtil, appConfig, loginPolicyService, redisTemplate), LoginFilter.class);

         }

         refresh.setToken(refreshToken);

             HttpSession session = req.getSession(true);

             session.setAttribute("JWT_TOKEN", accessToken);

 import com.takensoft.cms.loginPolicy.service.LoginPolicyService;

 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;

 import jakarta.servlet.http.HttpServletResponse;

 import jakarta.servlet.http.HttpSession;

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

 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

 import org.springframework.security.core.context.SecurityContextHolder;

     private final JWTUtil jwtUtil;

     private final RedisTemplate<String, String> redisTemplate;

     private final LoginPolicyService loginPolicyService;

         this.jwtUtil = jwtUtil;

         this.redisTemplate = redisTemplate;

         this.loginPolicyService = loginPolicyService;

     }

     /**

      * @param request HttpServletRequest 객체

     @Override

     protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

         HttpSession session = request.getSession(false);

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

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

             return;

         }

         String accessToken = (String) session.getAttribute("JWT_TOKEN");

         if ((Boolean) jwtUtil.getClaim(accessToken, "isExpired")) {

         }

         if (!loginPolicyService.getPolicy()) {

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

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

         mber.setAuthorList(roles);

         UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(mber, null, mber.getAuthorities());

         SecurityContextHolder.getContext().setAuthentication(authToken);

         filterChain.doFilter(request, response);

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

 import io.jsonwebtoken.Claims;

 import io.jsonwebtoken.ExpiredJwtException;

 import io.jsonwebtoken.Jwts;

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

 import org.springframework.security.core.Authentication;

         Claims claims;

         try {

             claims = Jwts.parser()

                     .verifyWith(JWT_SECRET_KEY)

                     .build()

                     .parseSignedClaims(tkn)

         } catch (ExpiredJwtException e) {

             // 만료된 토큰이라도 claims 꺼내기 가능

             claims = e.getClaims();

         }

         switch (knd) {

 package com.takensoft.common.util;

 import jakarta.servlet.http.HttpSession;

 import org.springframework.stereotype.Component;

 import java.util.Map;

         private final Map<String, HttpSession> sessionMap = new ConcurrentHashMap<>();

         public synchronized void registerSession(String mbrId, HttpSession newSession) {

             HttpSession oldSession = sessionMap.get(mbrId);

             if (oldSession != null && oldSession != newSession) {

                 oldSession.invalidate();

             }

             sessionMap.put(mbrId, newSession);

         }

         public void removeSession(String mbrId) {

         }

         public void invalidateAllSessions() {

             for (HttpSession session : sessionMap.values()) {

                 if (session != null) {