🎯 자바 웹 개발의 시작, Servlet이란?

Servlet의 생명주기 (Lifecycle)

public void init(ServletConfig config) throws ServletException {
    // 데이터베이스 연결 설정
    // 설정 파일 로딩
    // 초기 리소스 할당 등
}

protected void doGet(HttpServletRequest request, 
                     HttpServletResponse response) 
                     throws ServletException, IOException {
    // GET 요청 처리
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    out.println("<h1>Hello, Servlet!</h1>");
}

public void destroy() {
    // 데이터베이스 연결 종료
    // 리소스 해제
    // 로그 기록 등
}

실전 Servlet 예제

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    
    @Override
    protected void doPost(HttpServletRequest request, 
                         HttpServletResponse response) 
                         throws ServletException, IOException {
        
        // 1. 요청 파라미터 받기
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        
        // 2. 비즈니스 로직 처리
        boolean isValid = validateUser(username, password);
        
        // 3. 응답 생성
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        
        if (isValid) {
            // 세션에 사용자 정보 저장
            HttpSession session = request.getSession();
            session.setAttribute("user", username);
            
            out.println("<h1>로그인 성공!</h1>");
            out.println("<p>환영합니다, " + username + "님</p>");
        } else {
            out.println("<h1>로그인 실패</h1>");
            out.println("<p>아이디 또는 비밀번호를 확인하세요.</p>");
        }
    }
    
    private boolean validateUser(String username, String password) {
        // 실제로는 데이터베이스 조회
        return "admin".equals(username) && "1234".equals(password);
    }
}

Servlet의 한계

out.println("<table border='1'>");
out.println("  <tr>");
out.println("    <th>번호</th>");
out.println("    <th>이름</th>");
out.println("    <th>이메일</th>");
out.println("  </tr>");
for (User user : userList) {
    out.println("  <tr>");
    out.println("    <td>" + user.getId() + "</td>");
    out.println("    <td>" + user.getName() + "</td>");
    out.println("    <td>" + user.getEmail() + "</td>");
    out.println("  </tr>");
}
out.println("</table>");

🎨 화면을 위한 기술, JSP (JavaServer Pages)

JSP 기본 문법

<%
    String username = "홍길동";
    int age = 25;
    
    if (age >= 20) {
        out.println("성인입니다.");
    }
%>

<p>사용자 이름: <%= username %></p>
<p>나이: <%= age %>세</p>
<p>내년 나이: <%= age + 1 %>세</p>

<%!
    private int visitCount = 0;
    
    public String formatDate(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);
    }
%>

<%@ page language="java" contentType="text/html; charset=UTF-8" 
         pageEncoding="UTF-8" %>
<%@ page import="java.util.*, java.text.*" %>
<%@ page errorPage="error.jsp" %>

실전 JSP 예제

<%@ page language="java" contentType="text/html; charset=UTF-8" 
         pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>로그인 결과</title>
    <style>
        .success { color: green; }
        .error { color: red; }
    </style>
</head>
<body>
    <%
        String username = (String) session.getAttribute("user");
        boolean isLoggedIn = (username != null);
    %>
    
    <% if (isLoggedIn) { %>
        <div class="success">
            <h1>로그인 성공!</h1>
            <p>환영합니다, <%= username %>님</p>
            <p>마지막 로그인: <%= new java.util.Date() %></p>
        </div>
    <% } else { %>
        <div class="error">
            <h1>로그인 실패</h1>
            <p>아이디 또는 비밀번호를 확인하세요.</p>
            <a href="login.html">다시 로그인하기</a>
        </div>
    <% } %>
</body>
</html>

JSP 액션 태그와 EL/JSTL

<!-- 기존 방식 -->
<%= request.getAttribute("username") %>

<!-- EL 방식 -->
${username}

<!-- 객체 속성 접근 -->
${user.name}
${user.email}

<!-- 연산도 가능 -->
${price * quantity}
${age >= 20 ? "성인" : "미성년자"}

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<!-- 조건문 -->
<c:if test="${age >= 20}">
    <p>성인입니다.</p>
</c:if>

<c:choose>
    <c:when test="${score >= 90}">
        <p>A 학점</p>
    </c:when>
    <c:when test="${score >= 80}">
        <p>B 학점</p>
    </c:when>
    <c:otherwise>
        <p>C 학점</p>
    </c:otherwise>
</c:choose>

<!-- 반복문 -->
<table>
    <c:forEach var="user" items="${userList}">
        <tr>
            <td>${user.id}</td>
            <td>${user.name}</td>
            <td>${user.email}</td>
        </tr>
    </c:forEach>
</table>

JSP의 한계와 문제점

🏗️ MVC 패턴의 등장

MVC 패턴 실전 예제

public class Board {
    private int id;
    private String title;
    private String content;
    private String author;
    private Date createdDate;
    
    // 생성자, getter, setter 생략
}

public class BoardDAO {
    private Connection conn;
    
    public List<Board> getAllBoards() {
        List<Board> boards = new ArrayList<>();
        String sql = "SELECT * FROM board ORDER BY created_date DESC";
        
        try (PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            
            while (rs.next()) {
                Board board = new Board();
                board.setId(rs.getInt("id"));
                board.setTitle(rs.getString("title"));
                board.setContent(rs.getString("content"));
                board.setAuthor(rs.getString("author"));
                board.setCreatedDate(rs.getDate("created_date"));
                boards.add(board);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        
        return boards;
    }
}

@WebServlet("/board/list")
public class BoardListServlet extends HttpServlet {
    
    @Override
    protected void doGet(HttpServletRequest request, 
                        HttpServletResponse response) 
                        throws ServletException, IOException {
        
        // 1. Model을 통해 데이터 조회
        BoardDAO dao = new BoardDAO();
        List<Board> boards = dao.getAllBoards();
        
        // 2. 데이터를 request에 저장
        request.setAttribute("boards", boards);
        
        // 3. View로 포워딩
        RequestDispatcher dispatcher = 
            request.getRequestDispatcher("/WEB-INF/views/boardList.jsp");
        dispatcher.forward(request, response);
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
    <title>게시판 목록</title>
</head>
<body>
    <h1>게시판</h1>
    <table border="1">
        <tr>
            <th>번호</th>
            <th>제목</th>
            <th>작성자</th>
            <th>작성일</th>
        </tr>
        <c:forEach var="board" items="${boards}">
            <tr>
                <td>${board.id}</td>
                <td>${board.title}</td>
                <td>${board.author}</td>
                <td>${board.createdDate}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

🌟 Spring MVC 프레임워크의 등장

Spring MVC의 핵심 개념

@Controller
@RequestMapping("/board")
public class BoardController {
    
    @Autowired
    private BoardService boardService;
    
    @GetMapping("/list")
    public String list(Model model) {
        List<Board> boards = boardService.getAllBoards();
        model.addAttribute("boards", boards);
        return "board/list";  // 뷰 이름
    }
    
    @GetMapping("/detail/{id}")
    public String detail(@PathVariable int id, Model model) {
        Board board = boardService.getBoard(id);
        model.addAttribute("board", board);
        return "board/detail";
    }
    
    @PostMapping("/write")
    public String write(@ModelAttribute Board board) {
        boardService.saveBoard(board);
        return "redirect:/board/list";
    }
}

@Service
public class BoardService {
    
    @Autowired
    private BoardDAO boardDAO;
    
    public List<Board> getAllBoards() {
        return boardDAO.getAllBoards();
    }
    
    public Board getBoard(int id) {
        return boardDAO.getBoard(id);
    }
    
    @Transactional
    public void saveBoard(Board board) {
        boardDAO.saveBoard(board);
    }
}

Spring MVC의 요청 처리 흐름

Spring MVC의 주요 어노테이션

실전 Spring MVC 예제

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String username;
    
    @Column(nullable = false)
    private String password;
    
    @Column(nullable = false)
    private String email;
    
    @CreatedDate
    private LocalDateTime createdDate;
    
    // getter, setter, 생성자 생략
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    Optional<User> findByUsername(String username);
    
    boolean existsByUsername(String username);
    
    boolean existsByEmail(String email);
    
    List<User> findByEmailContaining(String keyword);
}

@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    
    public User getUser(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다."));
    }
    
    public User createUser(UserDto userDto) {
        // 중복 체크
        if (userRepository.existsByUsername(userDto.getUsername())) {
            throw new DuplicateUserException("이미 존재하는 사용자명입니다.");
        }
        
        // 비밀번호 암호화
        User user = new User();
        user.setUsername(userDto.getUsername());
        user.setPassword(passwordEncoder.encode(userDto.getPassword()));
        user.setEmail(userDto.getEmail());
        
        return userRepository.save(user);
    }
    
    public User updateUser(Long id, UserDto userDto) {
        User user = getUser(id);
        user.setEmail(userDto.getEmail());
        return userRepository.save(user);
    }
    
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    // 전체 사용자 조회
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return ResponseEntity.ok(users);
    }
    
    // 특정 사용자 조회
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUser(id);
        return ResponseEntity.ok(user);
    }
    
    // 사용자 생성
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody UserDto userDto) {
        User user = userService.createUser(userDto);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
    
    // 사용자 수정
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody UserDto userDto) {
        User user = userService.updateUser(id, userDto);
        return ResponseEntity.ok(user);
    }
    
    // 사용자 삭제
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
    
    // 예외 처리
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException e) {
        ErrorResponse error = new ErrorResponse("USER_NOT_FOUND", e.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
    }
}

Spring Boot의 등장

@SpringBootApplication
public class MyApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

application.properties 설정

# 서버 포트 설정
server.port=8080

# 데이터베이스 설정
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA 설정
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# 로깅 레벨
logging.level.root=INFO
logging.level.com.myapp=DEBUG

# 파일 업로드 설정
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

# Thymeleaf 설정
spring.thymeleaf.cache=false
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html

🔥 최신 트렌드와 실무 팁

1. RESTful API 설계 원칙

2. DTO (Data Transfer Object) 패턴

// Entity (데이터베이스 테이블과 매핑)
@Entity
public class User {
    private Long id;
    private String username;
    private String password;  // 민감한 정보
    private String email;
    private LocalDateTime createdDate;
}

// DTO (클라이언트와 통신)
public class UserResponseDto {
    private Long id;
    private String username;
    private String email;
    // password는 포함하지 않음!
    
    public UserResponseDto(User user) {
        this.id = user.getId();
        this.username = user.getUsername();
        this.email = user.getEmail();
    }
}

// Controller에서 사용
@GetMapping("/{id}")
public ResponseEntity<UserResponseDto> getUser(@PathVariable Long id) {
    User user = userService.getUser(id);
    UserResponseDto dto = new UserResponseDto(user);
    return ResponseEntity.ok(dto);
}

3. 예외 처리 전략

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException e) {
        ErrorResponse error = ErrorResponse.builder()
            .code("USER_NOT_FOUND")
            .message(e.getMessage())
            .timestamp(LocalDateTime.now())
            .build();
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
    }
    
    @ExceptionHandler(DuplicateUserException.class)
    public ResponseEntity<ErrorResponse> handleDuplicateUser(DuplicateUserException e) {
        ErrorResponse error = ErrorResponse.builder()
            .code("DUPLICATE_USER")
            .message(e.getMessage())
            .timestamp(LocalDateTime.now())
            .build();
        return ResponseEntity.status(HttpStatus.CONFLICT).body(error);
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationError(
            MethodArgumentNotValidException e) {
        List<String> errors = e.getBindingResult()
            .getFieldErrors()
            .stream()
            .map(error -> error.getField() + ": " + error.getDefaultMessage())
            .collect(Collectors.toList());
            
        ErrorResponse error = ErrorResponse.builder()
            .code("VALIDATION_ERROR")
            .message("입력값 검증 실패")
            .errors(errors)
            .timestamp(LocalDateTime.now())
            .build();
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneralError(Exception e) {
        ErrorResponse error = ErrorResponse.builder()
            .code("INTERNAL_ERROR")
            .message("서버 오류가 발생했습니다.")
            .timestamp(LocalDateTime.now())
            .build();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }
}

4. 유효성 검증 (Validation)

public class UserCreateDto {
    
    @NotBlank(message = "사용자명은 필수입니다.")
    @Size(min = 3, max = 20, message = "사용자명은 3~20자여야 합니다.")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", 
             message = "사용자명은 영문, 숫자, 언더스코어만 가능합니다.")
    private String username;
    
    @NotBlank(message = "비밀번호는 필수입니다.")
    @Size(min = 8, message = "비밀번호는 최소 8자 이상이어야 합니다.")
    private String password;
    
    @NotBlank(message = "이메일은 필수입니다.")
    @Email(message = "올바른 이메일 형식이 아닙니다.")
    private String email;
    
    @Min(value = 0, message = "나이는 0 이상이어야 합니다.")
    @Max(value = 150, message = "나이는 150 이하여야 합니다.")
    private Integer age;
}

// Controller에서 사용
@PostMapping
public ResponseEntity<User> createUser(@Valid @RequestBody UserCreateDto dto) {
    // @Valid 어노테이션이 자동으로 검증을 수행
    User user = userService.createUser(dto);
    return ResponseEntity.status(HttpStatus.CREATED).body(user);
}

5. 페이징과 정렬

// Repository
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Page<User> findByUsernameContaining(String keyword, Pageable pageable);
}

// Service
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public Page<User> searchUsers(String keyword, int page, int size, String sortBy) {
        Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy).descending());
        return userRepository.findByUsernameContaining(keyword, pageable);
    }
}

// Controller
@GetMapping("/search")
public ResponseEntity<Page<UserResponseDto>> searchUsers(
        @RequestParam String keyword,
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "10") int size,
        @RequestParam(defaultValue = "createdDate") String sortBy) {
    
    Page<User> users = userService.searchUsers(keyword, page, size, sortBy);
    Page<UserResponseDto> dtos = users.map(UserResponseDto::new);
    return ResponseEntity.ok(dtos);
}

6. 보안 (Spring Security)

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .addFilterBefore(jwtAuthenticationFilter(), 
                           UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

7. 테스트 작성

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @MockBean
    private UserService userService;
    
    @Test
    @DisplayName("사용자 생성 테스트")
    void createUser() throws Exception {
        // Given
        UserCreateDto dto = new UserCreateDto();
        dto.setUsername("testuser");
        dto.setPassword("password123");
        dto.setEmail("test@example.com");
        
        User user = new User();
        user.setId(1L);
        user.setUsername(dto.getUsername());
        user.setEmail(dto.getEmail());
        
        when(userService.createUser(any())).thenReturn(user);
        
        // When & Then
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(dto)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.username").value("testuser"))
            .andExpect(jsonPath("$.email").value("test@example.com"));
    }
    
    @Test
    @DisplayName("사용자 조회 테스트")
    void getUser() throws Exception {
        // Given
        User user = new User();
        user.setId(1L);
        user.setUsername("testuser");
        user.setEmail("test@example.com");
        
        when(userService.getUser(1L)).thenReturn(user);
        
        // When & Then
        mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.username").value("testuser"));
    }
}

🎓 학습 로드맵과 추천 자료

추천 학습 자료

🚀 실무에서의 활용

현대적인 웹 애플리케이션 아키텍처

프론트엔드 (React, Vue, Angular)
        ↓ REST API
백엔드 (Spring Boot)
        ↓
서비스 계층 (비즈니스 로직)
        ↓
데이터 접근 계층 (JPA, MyBatis)
        ↓
데이터베이스 (MySQL, PostgreSQL)

성능 최적화 팁

보안 체크리스트

🎯 마무리하며