@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<ErrorResponse> NullPointerException(NullPointerException n) {
        n.printStackTrace();
        ErrorResponse response = new ErrorResponse(404, n.getMessage());
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(SQLSyntaxErrorException.class)
    public ResponseEntity<ErrorResponse> SqlSyntaxErrorException(SQLSyntaxErrorException s) {
        System.out.println("sql syntax error");
        ErrorResponse response = new ErrorResponse(404, s.getMessage());
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(BadSqlGrammarException.class)
    public ResponseEntity<ErrorResponse> BadSqlGrammarException(BadSqlGrammarException b) {
        b.printStackTrace();
        ErrorResponse response = new ErrorResponse(404, b.getMessage());
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public String Exception(Exception e) {
        System.out.println("Exception");
        return "sql grammar error";
    }

    @ExceptionHandler(RuntimeException.class)
    public String RuntimeException(RuntimeException r) {
        System.out.println("run time exception");
        return "run time exception";
    }

    @ExceptionHandler(NotFoundException.class)
    public ResponseEntity<ErrorResponse> NotFoundException(NotFoundException n) {
        ErrorResponse response = new ErrorResponse(404, n.getMessage());
        return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
    }

}

// ErrorResponse.java

@Getter
public class ErrorResponse {
    private String message;
    private int status;

    public ErrorResponse(int i, String message) {
        this.status = i;
        this.message = message;
    }
}

@ExceptionHandler(BadSqlGrammarException.class)
public ResponseEntity<ErrorResponse> BadSqlGrammarException(BadSqlGrammarException b){
        System.out.println("bad grammar");
        ErrorResponse response=new ErrorResponse(404,b.getMessage());
        return new ResponseEntity<>(response,HttpStatus.BAD_REQUEST);
        }

@ExceptionHandler(NullPointerException.class)
public ResponseEntity<ErrorResponse> NullPointerException(NullPointerException n){
        n.printStackTrace();
        ErrorResponse response=new ErrorResponse(404,n.getMessage());
        return new ResponseEntity<>(response,HttpStatus.BAD_REQUEST);
        }

@Configuration
@RequiredArgsConstructor
public class WebConfig implements WebMvcConfigurer {
    private final MemberInterceptor memberInterceptor;

    private static final List<String> interceptorUrlPatterns = Arrays.asList("/user/*", "/board/*");
    private static final List<String> excludeInterceptorUrlPatterns = Arrays.asList("/user/login", "/user/register", "/house/*");

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(memberInterceptor)
                .addPathPatterns(interceptorUrlPatterns)
                .excludePathPatterns(excludeInterceptorUrlPatterns);
    }
}

@Component
public class MemberInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 컨트롤러 메서드에 매핑된 uri가 호출 되면 실행 되는 메서드 controller 진입 직전 수행
        HttpSession session = request.getSession(false);
        if (session != null) {
            Member member = (Member) session.getAttribute("member");
            if (member == null) {
                response.sendRedirect(request.getContextPath() + "/");
                return false;
            }
            request.setAttribute("member", member);
            return true;
        }
        response.sendRedirect(request.getContextPath() + "/");
        return false;
    }
}

@GetMapping("detail/{code}")
public String detail(@PathVariable String code,HttpServletRequest req){
        BoardDto boardDto=boardService.select(code);
        req.setAttribute("detail",boardDto);
        return"board/detail";
        }

@Configuration
public class SwaggerConfiguration {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

@Api(tags = {"users"})
@Controller
@RequestMapping("/user")
@RequiredArgsConstructor
public class MemberController {
    @PostMapping("/login")
    @ResponseBody
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "로그인 성공")
    })
    public ResponseEntity<ResponseDTO> login(
            @ApiParam(value = "member")
            @RequestBody LoginDTO member,
            HttpServletRequest req) {
        ResponseDTO res = new ResponseDTO();
        try {
            // 로그인 프로세스 추가
            Member user = memberService.login(member);
            HttpSession session = req.getSession();
            session.setAttribute("member", user);

            res.setStatus("success");
            res.setMsg("login success");
            res.setBody(user);
            return new ResponseEntity<>(res, HttpStatus.OK);
        } catch (Exception e) {
            res.setStatus("fail");
            res.setErrMsg("로그인 정보가 잘못되었습니다. 다시 로그인해 주세요");
            return new ResponseEntity<>(res, HttpStatus.NOT_FOUND);
        }
    }
}

import javax.crypto.KeyGenerator;

public class Encrypt {
...

    public static byte[] generateKey(String algorithm, int keySize) throws
            NoSuchAlgorithmException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(keySize);
        SecretKey key = keyGenerator.generateKey();
        return key.getEncoded();
    }
...
}

public static String byteArrayToHex(byte[]ba){
        if(ba==null||ba.length==0){
        return null;
        }
        StringBuffer sb=new StringBuffer(ba.length*2);
        String hexNumber;
        for(int x=0;x<ba.length;x++){
        hexNumber="0"+Integer.toHexString(0xff&ba[x]);
        sb.append(hexNumber.substring(hexNumber.length()-2));
        }
        return sb.toString();
        }

byte[]key=generateKey("AES",128);
        System.out.println("key length: "+key.length);
        String hexKey=byteArrayToHex(key);
        System.out.println(hexKey);

/*
key length: 16
9880ac1ecc316c9929b700a95b38b372
*/

public static String aesEncrypt(String msg,byte[]key)throws Exception{
        SecretKeySpec skeySpec=new SecretKeySpec(key,"AES");
        Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
        String iv="AAAAAAAAAAAAAAAA";
        cipher.init(Cipher.ENCRYPT_MODE,
        skeySpec,
        new IvParameterSpec(iv.getBytes()));
        byte[]encrypted=cipher.doFinal(msg.getBytes());
        return byteArrayToHex(encrypted);
        }
/*
평문: lee
encrypt: 91f0742622d1defa32ca78f399cd62e7
*/

public static byte[]getSHA256(String source,String salt){
        byte byteData[]=null;
        try{
        MessageDigest md=MessageDigest.getInstance("SHA-256");
        md.update(source.getBytes());
        md.update(salt.getBytes());
        byteData=md.digest();
        System.out.println("원문: "+source+" SHA-256: "+
        byteData.length+","+byteArrayToHex(byteData));
        }catch(NoSuchAlgorithmException e){
        e.printStackTrace();
        }
        return byteData;
        }
/*
원문: 1234
SHA-256: 4b3bed8af7b7612e8c1e25f63ba24496f5b16b2df44efb2db7ce3cb24b7e96f7
pw encrypt: K;���a.�%�;�D���k-�N�-��<�K~��
*/

public Member login(String id,String pw){
        // password 암호화 후 데이터베이스와 비교
        String databasePw=securityService.selectByUserId(id); // 사용자 salt 받아오기 
        String hashedPassword=new String(CipherUtil.getSHA256(pw,databasePw)); // 사용자 입력 비밀번호 평문 -> 암호화 
        return memberDao.login(id,hashedPassword);
        }