docker-compose.yml — 전체 스택

복사# docker-compose.ymlversion: '3.9'

services:
  oracle:
    image: gvenzl/oracle-xe:21-slim
    environment:
      ORACLE_PASSWORD: oracle123
      APP_USER: appuser
      APP_USER_PASSWORD: apppass
    ports:
      - "1521:1521"
    volumes:
      - oracle-data:/opt/oracle/oradata
    healthcheck:
      test: ["CMD", "healthcheck.sh"]
      interval: 30s
      timeout: 10s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data

  backend:
    build: ./backend
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:oracle:thin:@oracle:1521/XEPDB1
      SPRING_DATASOURCE_USERNAME: appuser
      SPRING_DATASOURCE_PASSWORD: apppass
      SPRING_REDIS_HOST: redis
    depends_on:
      oracle:
        condition: service_healthy
      redis:
        condition: service_started

  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - backend

volumes:
  oracle-data:
  redis-data:

Spring Boot application.yml

복사# src/main/resources/application.ymlspring:
  datasource:
    url: jdbc:oracle:thin:@localhost:1521/XEPDB1
    username: appuser
    password: apppass
    driver-class-name: oracle.jdbc.OracleDriver
    hikari:
      maximum-pool-size: 10
      connection-timeout: 30000
      idle-timeout: 600000

  data:
    redis:
      host: localhost
      port: 6379
      timeout: 3000

  cache:
    type: redis
    redis:
      time-to-live: 300000   # 5분

mybatis:
  mapper-locations: classpath:mapper/**/\*.xml
  configuration:
    map-underscore-to-camel-case: true
    default-fetch-size: 100
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl

server:
  port: 8080

logging:
  level:
    com.yourcompany.mapper: DEBUG  # MyBatis SQL 로그

Vite 프록시 설정 (React)

복사// vite.config.tsimport { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  server: {
    port: 3000,
    proxy: {
      '/api': {
        target: 'http://localhost:8080',
        changeOrigin: true,
        // /api/users → http://localhost:8080/api/users
      }
    }
  }
})

1. 글로벌 예외 처리 — @ControllerAdvice

복사// 표준 에러 응답 DTO
@Getter
@Builder
public class ErrorResponse {
    private String code;
    private String message;
    private LocalDateTime timestamp;
    private String path;

    public static ErrorResponse of(String code, String message, String path) {
        return ErrorResponse.builder()
            .code(code).message(message).path(path)
            .timestamp(LocalDateTime.now()).build();
    }
}

// 글로벌 예외 핸들러
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusiness(
            BusinessException ex, HttpServletRequest req) {
        return ResponseEntity.status(ex.getStatus())
            .body(ErrorResponse.of(ex.getCode(), ex.getMessage(), req.getRequestURI()));
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidation(
            MethodArgumentNotValidException ex, HttpServletRequest req) {
        String msg = ex.getBindingResult().getFieldErrors().stream()
            .map(f -> f.getField() + ": " + f.getDefaultMessage())
            .collect(Collectors.joining(", "));
        return ResponseEntity.badRequest()
            .body(ErrorResponse.of("VALIDATION_ERROR", msg, req.getRequestURI()));
    }
}

2. Spring Security 6.x + JWT (람다 DSL)

복사@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .cors(cors -> cors.configurationSource(corsSource()))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**", "/actuator/health").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(new JwtAuthFilter(jwtProvider),
                            UsernamePasswordAuthenticationFilter.class)
            .build();
    }

    @Bean
    public CorsConfigurationSource corsSource() {
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowedOrigins(List.of("http://localhost:3000"));
        config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE"));
        config.setAllowedHeaders(List.of("*"));
        config.setAllowCredentials(true);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return source;
    }
}

3. @Async 비동기 처리 + 외부 API 연동

복사@Service
public class ExternalApiService {

    private final WebClient webClient;

    public ExternalApiService(WebClient.Builder builder) {
        this.webClient = builder
            .baseUrl("https://api.external.com")
            .defaultHeader("Accept", "application/json")
            .build();
    }

    // 동기 호출 — 응답을 기다려야 할 때
    public ExternalData fetchData(String id) {
        return webClient.get()
            .uri("/data/{id}", id)
            .retrieve()
            .onStatus(HttpStatusCode::is4xxClientError,
                res -> Mono.error(new BusinessException("EXTERNAL_API_ERROR")))
            .bodyToMono(ExternalData.class)
            .timeout(Duration.ofSeconds(5))
            .block();
    }

    // 비동기 병렬 호출 — 여러 API를 동시에 호출
    @Async
    public CompletableFuture<ExternalData> fetchDataAsync(String id) {
        ExternalData data = fetchData(id);
        return CompletableFuture.completedFuture(data);
    }
}

1. Mapper 인터페이스 + XML

복사// UserMapper.java@Mapper
public interface UserMapper {
    List<UserDto> findByCondition(UserSearchParam param);
    Optional<UserDto> findById(Long id);
    void insert(UserDto user);
    void update(UserDto user);
    void delete(Long id);
    int countByCondition(UserSearchParam param);
}

복사<!-- mapper/UserMapper.xml --><mapper namespace="com.example.mapper.UserMapper">

  <resultMap id="UserResultMap" type="UserDto">
    <id     property="id"        column="USER_ID"/>
    <result property="name"      column="USER_NM"/>
    <result property="email"     column="EMAIL_ADDR"/>
    <result property="status"    column="STATUS_CD"/>
    <result property="createdAt" column="REG_DT"/>
    <!-- 연관 객체 -->
    <association property="dept" javaType="DeptDto">
      <result property="deptId"   column="DEPT_ID"/>
      <result property="deptName" column="DEPT_NM"/>
    </association>
  </resultMap>

  <!-- Oracle 페이징: ROW_NUMBER() OVER 권장 (ROWNUM은 서브쿼리 필수) -->
  <select id="findByCondition" resultMap="UserResultMap">
    SELECT *
    FROM (
      SELECT A.*, ROW_NUMBER() OVER (ORDER BY A.REG_DT DESC) AS RNUM
      FROM (
        SELECT U.USER_ID, U.USER_NM, U.EMAIL_ADDR, U.STATUS_CD, U.REG_DT,
               D.DEPT_ID, D.DEPT_NM
        FROM   TB_USER U
        LEFT   JOIN TB_DEPT D ON D.DEPT_ID = U.DEPT_ID
        <where>
          <if test="name != null and name != ''">
            AND U.USER_NM LIKE '%' || #{name} || '%'
          </if>
          <if test="status != null">
            AND U.STATUS_CD = #{status}
          </if>
          <if test="fromDate != null">
            AND U.REG_DT >= TO_DATE(#{fromDate}, 'YYYY-MM-DD')
          </if>
        </where>
      ) A
    )
    WHERE RNUM BETWEEN #{offset} + 1 AND #{offset} + #{limit}
  </select>

  <!-- 동적 UPDATE (변경된 컬럼만) -->
  <update id="update">
    UPDATE TB_USER
    <set>
      <if test="name != null">USER_NM = #{name},</if>
      <if test="email != null">EMAIL_ADDR = #{email},</if>
      UPD_DT = SYSDATE
    </set>
    WHERE USER_ID = #{id}
  </update>

  <!-- Oracle Sequence로 PK 채번 -->
  <insert id="insert">
    <selectKey keyProperty="id" resultType="long" order="BEFORE">
      SELECT SEQ_USER.NEXTVAL FROM DUAL
    </selectKey>
    INSERT INTO TB_USER (USER_ID, USER_NM, EMAIL_ADDR, STATUS_CD, REG_DT)
    VALUES (#{id}, #{name}, #{email}, #{status}, SYSDATE)
  </insert>

</mapper>

2. Oracle 필수 방언 — 면접 대비

3. CONNECT BY — 계층형 쿼리

복사-- 조직도 계층 조회 (부서 트리)
SELECT
    LEVEL,
    LPAD(' ', (LEVEL-1) * 4) || DEPT_NM AS DEPT_NM_TREE,
    DEPT_ID,
    PARENT_DEPT_ID,
    SYS_CONNECT_BY_PATH(DEPT_NM, '>') AS FULL_PATH
FROM   TB_DEPT
START WITH  PARENT_DEPT_ID IS NULL        -- 최상위 노드
CONNECT BY PRIOR DEPT_ID = PARENT_DEPT_ID  -- 부모→자식 방향
ORDER SIBLINGS BY SORT_ORD;

1. Redis @Cacheable 캐싱 전략

복사@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .disableCachingNullValues()
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));

        // 캐시별 TTL 다르게 설정
        Map<String, RedisCacheConfiguration> configs = Map.of(
            "users",    defaultConfig.entryTtl(Duration.ofMinutes(5)),
            "products", defaultConfig.entryTtl(Duration.ofHours(1)),
            "codes",    defaultConfig.entryTtl(Duration.ofHours(24))
        );
        return RedisCacheManager.builder(factory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(configs)
            .build();
    }
}

@Service
public class UserService {

    @Cacheable(value = "users", key = "#userId")
    public UserDto findById(Long userId) {
        return userMapper.findById(userId).orElseThrow(
            () -> new BusinessException("USER_NOT_FOUND"));
    }

    @CacheEvict(value = "users", key = "#user.id")
    public void update(UserDto user) {
        userMapper.update(user);
    }

    // 특정 조건에만 캐싱
    @Cacheable(value = "products", key = "#id",
               condition = "#id > 0", unless = "#result == null")
    public ProductDto getProduct(Long id) { ... }
}

2. Kafka Producer / Consumer

복사// Producer
@Service
public class OrderEventProducer {

    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void sendOrderEvent(OrderEvent event) {
        kafkaTemplate.send("order-events", event.getOrderId().toString(), event)
            .whenComplete((result, ex) -> {
                if (ex != null) {
                    log.error("Kafka 전송 실패: {}", ex.getMessage());
                } else {
                    log.info("Kafka 전송 성공: partition={}, offset={}",
                        result.getRecordMetadata().partition(),
                        result.getRecordMetadata().offset());
                }
            });
    }
}

// Consumer
@Component
public class OrderEventConsumer {

    @KafkaListener(topics = "order-events", groupId = "order-service")
    public void consume(ConsumerRecord<String, OrderEvent> record) {
        log.info("수신: key={}, value={}", record.key(), record.value());
        try {
            processOrder(record.value());
        } catch (Exception e) {
            // DLQ(Dead Letter Queue)로 이동 처리
            log.error("처리 실패 → DLQ 이동: {}", e.getMessage());
        }
    }
}

1. Axios 인스턴스 + 글로벌 인터셉터

복사// src/lib/api.tsimport axios, { AxiosError, InternalAxiosRequestConfig } from 'axios'

export const api = axios.create({
  baseURL: '/api',           // Vite proxy → localhost:8080
  timeout: 10000,
  headers: { 'Content-Type': 'application/json' }
})

// 요청 인터셉터 — JWT 토큰 자동 첨부
api.interceptors.request.use((config: InternalAxiosRequestConfig) => {
  const token = localStorage.getItem('accessToken')
  if (token) config.headers.Authorization = `Bearer ${token}`
  return config
})

// 응답 인터셉터 — 토큰 만료 시 자동 갱신
api.interceptors.response.use(
  res => res,
  async (error: AxiosError) => {
    const originalRequest = error.config as any
    if (error.response?.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true
      try {
        const { data } = await api.post('/auth/refresh')
        localStorage.setItem('accessToken', data.accessToken)
        originalRequest.headers.Authorization = `Bearer ${data.accessToken}`
        return api(originalRequest)
      } catch {
        localStorage.clear()
        window.location.href = '/login'
      }
    }
    return Promise.reject(error)
  }
)

2. Custom Hook — 비동기 상태 관리

복사// src/hooks/useAsync.tsimport { useState, useCallback } from 'react'

interface AsyncState<T> {
  data: T | null
  loading: boolean
  error: Error | null
}

export function useAsync<T>(asyncFn: (...args: any[]) => Promise<T>) {
  const [state, setState] = useState<AsyncState<T>>({
    data: null, loading: false, error: null
  })

  const execute = useCallback(async (...args: any[]) => {
    setState(s => ({ ...s, loading: true, error: null }))
    try {
      const data = await asyncFn(...args)
      setState({ data, loading: false, error: null })
      return data
    } catch (err) {
      setState(s => ({ ...s, loading: false, error: err as Error }))
      throw err
    }
  }, [asyncFn])

  return { ...state, execute }
}

// 사용 예시
const { data: users, loading, error, execute: fetchUsers } = useAsync(
  () => api.get('/users').then(r => r.data)
)

3. Promise.all 병렬 호출

복사// 여러 API를 병렬로 호출하고 모두 완료된 후 처리
const loadDashboardData = async () => {
  try {
    const [users, products, orders] = await Promise.all([
      api.get('/users'),
      api.get('/products'),
      api.get('/orders?status=pending')
    ])
    setDashboard({ users: users.data, products: products.data, orders: orders.data })
  } catch (err) {
    // 하나라도 실패하면 catch로 빠짐
    console.error('대시보드 로드 실패:', err)
  }
}

// 실패해도 계속 진행 — allSettled
const results = await Promise.allSettled([
  api.get('/optional-data-1'),
  api.get('/optional-data-2')
])
results.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value.data)
  else console.warn('부분 실패:', r.reason)
})

1주차 합류 액션 플랜

일반 기능 개발 프로세스

꼭 물어봐야 할 것들 (합류 직후)

Git Flow 브랜치 전략

커밋 메시지 컨벤션

복사# 형식: type(scope): 간단한 설명

feat(user): 사용자 목록 페이징 기능 추가
fix(order): 주문 금액 계산 오류 수정
refactor(cache): Redis 캐시 TTL 정책 개선
docs(api): 사용자 API 명세 업데이트
test(user): 사용자 서비스 단위테스트 추가
chore(deps): spring-boot 3.2.1로 업그레이드

# Body: 왜 변경했는지 (선택)
# 기존: NVL 함수 사용 → 성능 이슈 발생
# 변경: COALESCE로 교체하여 인덱스 활용 가능하게 수정

PR 템플릿 (좋은 PR 작성법)

복사## 변경 내용
사용자 목록 조회 API에 페이징 및 검색 필터 기능 추가

## 변경 이유
데이터 증가로 인해 전체 조회 시 응답시간 5초 이상 발생

## 변경 사항
- UserMapper.xml: ROW_NUMBER() 기반 페이징 쿼리 추가
- UserService: 페이지 파라미터 검증 로직 추가
- Redis 캐시 무효화 처리 (@CacheEvict)

## 테스트
- [x] 로컬 실행 확인
- [x] 단위 테스트 통과
- [ ] QA 환경 배포 (진행 중)

## 스크린샷 (UI 변경이 있는 경우)

Spring Boot 자주 나오는 이슈

Oracle / MyBatis 자주 나오는 이슈

Redis 관련

복사# 캐시 상태 확인
redis-cli KEYS "users::*"       # 특정 캐시 키 목록
redis-cli TTL "users::123"      # TTL 남은 시간(초)
redis-cli GET "users::123"      # 캐시 값 확인
redis-cli FLUSHDB               # 개발환경 전체 캐시 삭제 (주의!)

# 연결 문제
redis-cli ping                  # PONG 응답 확인
redis-cli INFO server           # 서버 정보 확인