Coding Study

public class B20260213_25757 {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int num = Integer.parseInt(st.nextToken());
        String game = st.nextToken();
        int result = 0;

        Set<String> set = new HashSet<>();

        for(int i = 0; i < num; i++) {
            set.add(br.readLine());
        }
        
        if("Y".equals(game)) {
            result = set.size();
        } else if("F".equals(game)) {
            result = set.size() / 2;
        } else if("O".equals(game)) {
            result = set.size() / 3;
        }

        System.out.println(result);

        br.close();

    }
}

.formLogin(form -> form
    .loginProcessingUrl("/login") //리액트에서 POST 요청을 보낼 주소
    .successHandler((request, response, authentication) -> {
        response.setStatus(HttpServletResponse.SC_OK); // 성공 시 200 OK 반환
    })
    .failureHandler((request, response, exception) -> {
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 실패 시 401 반환
    })
)

npm install react-router-dom

import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
import Login from './Login';

function App() {
  return (
    <Router>
      <div style={{ padding: '20px' }}>
        <h1>Spring Boot, React 연동</h1>
        <nav>
           <a href="/login">로그인 이동</a> | <a href="/join">회원가입 이동</a>
        </nav>
        <hr />

	//URL 변경에 따라 화면 변경
        <Routes>
          <Route path="/login" element={<Login />} />
          <Route path="/main" element={<h2>메인 페이지입니다.</h2>} />
        </Routes>
      </div>
    </Router>
  );
}

export default App;

import { useState } from 'react';
import axios from 'axios';

function Login() {
  const [username, setUsername] = useState('');
  const [password, setPassword] = useState('');

  const handleLogin = (e) => {
    e.preventDefault(); // 폼 제출 시 페이지 새로고침 방지

    // 스프링 시큐리티는 기본적으로 x-www-form-urlencoded 형식을 기대한다.
    const formData = new FormData();
    formData.append('username', username);
    formData.append('password', password);

    axios.post('http://localhost:8080/login', formData, {
      withCredentials: true // 세션 쿠키를 받아오기 위해 필수
    })
    .then(res => {
        alert("로그인 성공!");
        window.location.reload(); // 성공 후 상태 업데이트를 위해 새로고침
    })
    .catch(err => {
        alert("로그인 실패: 아이디 또는 비밀번호를 확인하세요.");
    });
  };

  return (
    <div style={{ maxWidth: '300px', margin: '50px auto' }}>
      <h2>커스텀 로그인</h2>
      <form onSubmit={handleLogin}>
        <input
          type="text"
          placeholder="아이디"
          value={username}
          onChange={(e) => setUsername(e.target.value)}
          style={{ display: 'block', width: '100%', marginBottom: '10px' }}
        />
        <input
          type="password"
          placeholder="비밀번호"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
          style={{ display: 'block', width: '100%', marginBottom: '10px' }}
        />
        <button type="submit" style={{ width: '100%' }}>로그인</button>
      </form>
    </div>
  );
}

export default Login;

const [sessionInfo, setSessionInfo] = useState("데이터를 가져오는 중...");

  useEffect(() => {
    // 스프링 부트에서 만든 세션 체크 API 호출
    axios.get('http://localhost:8080/check', {
      withCredentials: true // 세션 쿠키를 함께 보내기 위한 필수 옵션!
    })
    .then(response => {
      setSessionInfo(JSON.stringify(response.data));
    })
    .catch(error => {
      setSessionInfo("에러 발생! 콘솔(F12)을 확인하세요.");
      console.error("통신 에러:", error);
    });
  }, []);

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration configuration = new CorsConfiguration();

    // 리액트 서버 주소 허용
    configuration.setAllowedOrigins(List.of("http://localhost:5173"));
    configuration.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
    configuration.setAllowedHeaders(List.of("*"));

    // 자격 증명(쿠키/세션) 허용
    configuration.setAllowCredentials(true);

    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", configuration);
    return source;
}

.cors(cors -> cors.configurationSource(corsConfigurationSource()))

@GetMapping("/userInfo")
@ResponseBody
public String userInfo(@AuthenticationPrincipal CustomUserLogin customUser) {
    
    return customUser.getUsername();
}

# 세션 유지 시간 설정(30분)
server.servlet.session.timeout=30m   

http	
    .sessionManagement(session -> session
        .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED) // 세션 생성 전략
        .maximumSessions(1) // 동시 접속 허용 개수 (1이면 중복 로그인 방지)
        .maxSessionsPreventsLogin(false) // true: 신규 로그인 차단, false: 기존 세션 만료
        .expiredUrl("/login?expired=true") // 세션이 만료되었을 때 이동될 페이지
    );
return http.build();

@EqualsAndHashCode(of = "id")
public class User {
    @Id
    @GeneratedValue //AutoIncrement
    @Column
    private Long id;

@EqualsAndHashCode(of = "user")
public class CustomUserLogin implements UserDetails {

    private final User user;

public void encodePassword(PasswordEncoder passwordEncoder) {
    this.password = passwordEncoder.encode(this.password);
}

@Service
@RequiredArgsConstructor
// UserDetailsService 빈 등록
public class CustomUserLoginService implements UserDetailsService {

    private final UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException {

        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("사용자 없음"));

        return new CustomUserLogin(user);
    }
}

public class UserService {
    private UserRepository userRepository = new UserRepository();
}

@Service
public class UserService {

    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

private final UserRepository userRepository;
public UserService(UserRepository userRepository) { // Spring이 밖에서 넣어줌
    this.userRepository = userRepository;
}

@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
}

# JPA가 실행하는 SQL을 콘솔에 출력
spring.jpa.show-sql=true

# 출력되는 SQL을 보기 좋게 포맷팅
spring.jpa.properties.hibernate.format_sql=true

# DDL(create, alter, drop) 자동 생성 전략
# create : 기존 테이블 삭제 후 다시 생성
# update : 변경된 부분만 반영 (운영 환경에서는 주의)
# validate : 테이블 생성, 수정 절대 X, 어플리케이션 시작 시 엔티티 <> DB 스키마 일치 여부만 검증하여 불일치 시 기동 X
# none : DDL 관련 작업 X, 엔티티와 DB 구조가 달라도 실행됨
spring.jpa.hibernate.ddl-auto=update

# 세션 유지 시간 설정
server.servlet.session.timeout=30m  #30분

package com.project.project1.domain;

import jakarta.persistence.*;
import lombok.*;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.time.LocalDateTime;

@Entity
@Table(name = "T_USER")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Builder
public class User {
    @Id
    @GeneratedValue //AutoIncrement
    private Long id;
    private String username;
    private String password;
    private String email;
    private LocalDateTime createTime;
    private LocalDateTime modifyTime;

    @PrePersist
    protected void onCreate() {
        this.createTime = LocalDateTime.now();
        this.modifyTime = LocalDateTime.now();
    }

    @PreUpdate
    protected void onUpdate() {
        this.modifyTime = LocalDateTime.now();
    }

    public void encodePassword(PasswordEncoder passwordEncoder) {
        this.password = passwordEncoder.encode(this.password);
    }

}

User user = User.builder()
        .name("남기문")
        .loginId("ngm011")
        .password("1234")
        .email("ngm011@naver.com")
        .createTime(LocalDateTime.now())
        .build();