인간 코딩(오류판)

JSP는 HTML 내에 자바 코드를 삽입하여 동적인 웹 콘텐츠를 생성한다.

JSP 파일은 일반적으로 .jsp 확장자를 가지며, 웹 서버에서 실행될 때 서블릿으로 변환된다.

이 변환 과정에서 HTML과 자바 코드가 결합되어 최종적으로 클라이언트에게 전달되는 HTML 페이지를 생성한다.

지시어(Directives)

지시어는 JSP 파일의 상단에 위치하며, JSP 페이지의 전반적인 설정을 정의한다.

페이지의 내용 타입, 캐릭터 인코딩 등을 설정한다.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

스크립틀릿(Scriptlets)

스크립틀릿은 JSP 페이지 내에서 자바 코드를 직접 작성할 수 있는 부분이다.

스크립틀릿은 <% %> 태그로 감싸며, 일반적으로 동적인 데이터 처리나 계산을 수행한다.

<%
    String message = "Hello, World!";
    out.println(message);
%>

표현식(Expressions)

표현식은 자바 코드를 실행하고 그 결과를 HTML 콘텐츠로 삽입한다.

표현식은 <%= %> 태그로 감싸며, 주로 페이지의 동적 데이터를 출력하는 데 사용다.

<p>Current time: <%= new java.util.Date() %></p>

선언(Declarations)

선언은 JSP 페이지 내에서 변수나 메서드를 정의한다.

선언은 <%! %> 태그로 감싸며, 페이지의 여러 부분에서 사용할 수 있는 클래스를 정의한다.

<%! 
    private int add(int a, int b) {
        return a + b;
    }
%>

태그 라이브러리(Tag Libraries)

JSP에서 반복적이고 복잡한 작업을 간단하게 처리하기 위해 JSTL(JavaServer Pages Standard Tag Library)와 같은 태그 라이브러리를 사용할 수 있다. JSTL은 조건문, 반복문, 데이터 포맷팅 등 여러 유용한 태그를 제공한다.

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:if test="${user != null}">
    <p>Welcome, ${user.name}!</p>
</c:if>

JSP는 서블릿 기술의 확장으로 볼 수 있다. 서블릿은 자바로 작성된 서버측 애플리케이션 컴포넌트로, 클라이언트의 요청을 처리하고 응답을 생성한다. JSP는 HTML과 자바 코드를 혼합할 수 있는 방법을 제공하며, JSP 파일은 실행 시 서블릿으로 변환되어 서블릿과 동일한 방식으로 동작한다.

JSTL은 EL(Expression Language)를 사용하여 표현한다.

Core Library (코어 라이브러리)

기본적인 조건문, 반복문, 변수 설정 등을 제공한다.

접두어: c

<c:out>: 데이터를 화면에 출력다. 기본적으로 XSS 공격을 방지하기 위해 HTML 이스케이프 처리가 된다.

<c:out value="${data}" />
<c:out value="${data}" default="값 없음" />

<c:set>: 변수를 설정한다. 변수의 범위(scope)는 page, request, session, application 중 하나로 설정할 수 있다.

<c:set scope="request" var="data" value="my_testValue" />

<c:forEach>: 컬렉션을 반복하여 처리한. 반복 인덱스나 상태 정보를 제공한다.

<c:forEach var="item" items="${itemList}" varStatus="status">
    <c:out value="${item}" />
</c:forEach>

<c:if>: 조건문을 처리한다.

<c:if test="${empty data}">
    data 값이 비어있으면 실행
</c:if>

<c:choose>, <c:when>, <c:otherwise>: if문 안의 복잡한 조건을 처리할 때 사용한다.

<c:choose>
    <c:when test="${data == 'A'}">data 값이 A이면 실행</c:when>
    <c:when test="${data == 'B'}">data 값이 B이면 실행</c:when>
    <c:otherwise>data 값이 A, B가 아닐 경우 실행</c:otherwise>
</c:choose>

<c:import>: 다른 JSP 페이지의 내용을 현재 페이지에 삽입한다.

<c:import url="header.jsp" />

<c:redirect>: 클라이언트를 다른 URL로 리다이렉트한다.

<c:redirect url="http://example.com" />

Formatting Library (포맷팅 라이브러리)

날짜, 시간, 숫자를 포맷팅하고 국제화 및 다국어 지원 기능을 제공한다.

접두어: fmt

<fmt:formatDate>: 날짜를 형식화한다.

<fmt:formatDate value="${currentDate}" pattern="yyyy-MM-dd" />

<fmt:formatNumber>: 숫자를 형식화한다.

<fmt:formatNumber value="${price}" type="currency" />

Functions Library (함수 라이브러리)

문자열 처리와 관련된 함수를 제공한다.

접두어: fn

fn:contains: 문자열이 다른 문자열을 포함하는지 확인한다.

fn:substring: 문자열의 부분 문자열을 추출한다.

SQL Library (SQL 라이브러리)

데이터베이스와의 기본적인 CRUD 작업을 지원한다.

기능은 제공하지만 보안 및 성능 문제로 인해 데이터베이스 작업은 서블릿이나 DAO를 통해 처리하는 것이 좋다.

접두어: sql

<sql:query>: SQL 쿼리를 실행하고 결과를 반환한다.

<sql:query var="result" dataSource="${dataSource}">
    SELECT * FROM users
</sql:query>

<sql:update>: 데이터베이스의 데이터를 업데이트한다.

<sql:update dataSource="${dataSource}">
    UPDATE users SET name='John Doe' WHERE id=1
</sql:update>

XML Library (XML 처리 라이브러리)

XML 문서를 처리하고 쿼리한다.

접두어: x

<x:parse>: XML 문서를 파싱하여 DOM 객체를 생성한다.

<x:parse xml="${xmlData}" var="parsedXml" />

<x:out>: XML 데이터를 출력한다.

<x:out select="/root/node" />

연산자

연산자는 조건문에서 사용하는 비교 및 논리 연산자를 제공한다.

== (eq): 두 값이 같은지 비교

${1 == 1}  <!-- true -->
${1 eq 1}  <!-- true -->

!= (ne): 두 값이 다른지 비교

${1 != 1}  <!-- false -->
${1 ne 1}  <!-- false -->

< (lt), > (gt), <= (le), >= (ge): 값의 비교

${1 < 10}  <!-- true -->
${1 gt 10} <!-- false -->

&& (and), || (or), ! (not): 논리 연산

${true && false} <!-- false -->
${true or false} <!-- true -->

empty 및 not empty: 변수의 유효성 검사

${empty name}  <!-- name이 null이거나 빈 문자열이면 true -->
${not empty name} <!-- name이 null도 아니고 빈 문자열도 아니면 true -->

Status 속성 제어

<c:forEach> 태그의 varStatus 속성을 사용하여 반복문의 상태 정보를 얻을 수 있다.

<c:forEach items="${RESULT}" var="result" varStatus="status">
    ${status.current}<br/>   <!-- 현재 아이템 -->
    ${status.index}<br/>     <!-- 0부터의 순서 -->
    ${status.count}<br/>     <!-- 1부터의 순서 -->
    ${status.first}<br/>     <!-- 현재 루프가 처음인지 반환 -->
    ${status.last}<br/>      <!-- 현재 루프가 마지막인지 반환 -->
</c:forEach>

JSTL for 문

<c:forEach>를 사용하여 다양한 방식으로 반복문을 제어할 수 있다.

인덱스로 접근

<c:forEach var="i" begin="1" end="5" step="1" varStatus="status">
    번호 : ${status.count}
    이름 : ${item[i].name}
    직업 : ${item[i].job}
    급여 : ${item[i].salary}
</c:forEach>

begin과 end로 접근

<c:forEach var="item" items="${list}" begin="0" end="5" step="1" varStatus="status">
    번호 : ${status.count}
    이름 : ${item.name}
    직업 : ${item.job}
    급여 : ${item.salary}
</c:forEach>

일반적인 접근

<c:forEach var="item" items="${list}" varStatus="status">
    번호 : ${status.count}
    이름 : ${item.name}
    직업 : ${item.job}
    급여 : ${item.salary}
</c:forEach>

JSTL break문 구현

JSTL은 기본적으로 break문을 지원하지 않지만, 조건문과 변수를 이용해 비슷한 효과를 낼 수 있다.

<c:set var="doneLoop" value="false" />
<c:forEach var="entity" items="${_STORE}" varStatus="status">
    <c:if test="${status.count % 6 eq 1}">
        <c:set var="doneLoop" value="false" />
    </c:if>
    <c:if test="${not doneLoop}"> 
        <span><input type="checkbox" id="store_id" name="store_id" value="<c:out value="${entity.STORE_ID}"/>" <c:out value="${entity.USE_YN}"/>><c:out value="${entity.STORE_NM}"/></span>
        <c:if test="${status.count % 6 eq 0}"> 
            <c:set var="doneLoop" value="true"/> 
        </c:if>
    </c:if>
</c:forEach>

상속

상속은 기존 클래스(부모 클래스 또는 상위 클래스)를 기반으로 새로운 클래스(자식 클래스 또는 하위 클래스)를 생성한다. 자식 클래스는 부모 클래스의 속성(필드)과 메서드(함수)를 상속받아 사용할 수 있으며, 필요에 따라 이들을 수정하거나 확장할 수 있다.

• 부모 클래스(Parent Class): 상속의 기반이 되는 클래스이다. 공통된 속성과 메서드를 정의한다.
• 자식 클래스(Child Class): 부모 클래스를 상속받아 새로운 기능을 추가하거나 기존 기능을 수정한 클래스이다. 부모 클래스의 모든 속성과 메서드를 물려받지만, 자신만의 속성과 메서드를 추가할 수 있다.

다형성 (Polymorphism)

상속을 통해 다형성을 구현할 수 있다. 자식 클래스의 객체를 부모 클래스의 타입으로 참조할 수 있는 것...

단일 상속 (Single Inheritance)

하나의 부모 클래스를 상속받아 자식 클래스를 생성하는 방식이다. 

// 부모 클래스
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

다중 상속 (Multiple Inheritance)

하나의 자식 클래스가 여러 부모 클래스를 상속받는 형태이다. 다중 상속은 코드의 복잡성을 증가시키고, 다이아몬드 문제(Diamond Problem)를 유발할 수 있기 때문에 일부 언어에서는 지원하지 않는다. 

다이아몬드 문제

class A {
    void doSomething() {
        System.out.println("A's doSomething");
    }
}

class B extends A {
    @Override
    void doSomething() {
        System.out.println("B's doSomething");
    }
}

class C extends A {
    @Override
    void doSomething() {
        System.out.println("C's doSomething");
    }
}

class D extends B, C {
    // 어떤 doSomething()을 상속받아야 할지 모름
}

클래스 D는 B와 C를 상속받는다. 클래스 B와 C는 모두 A를 상속받았으며, 각 클래스에서 doSomething() 메서드를 오버라이드했다. 이제 클래스 D에서 doSomething() 메서드를 호출하면, B와 C 두 클래스에서 상속받은 메서드 중 어떤 것이 호출될지 모른다.

계층적 상속 (Hierarchical Inheritance)

계층적 상속은 하나의 부모 클래스로부터 여러 자식 클래스를 생성하는 방식이다.

이 방식은 상속받은 클래스들이 공통된 기능을 공유하면서도 각기 다른 특성으로 확장될 수 있다.

// 부모 클래스
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 자식 클래스 1
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

// 자식 클래스 2
class Cat extends Animal {
    void meow() {
        System.out.println("Cat is meowing");
    }
}

상속을 사용하면 기존 클래스를 재사용하여 새로운 클래스를 만들 수 있다.

이를 통해 중복된 코드를 작성할 필요가 없으며, 공통된 기능을 하나의 부모 클래스에 정의하고,

자식 클래스에서 이를 재사용할 수 있다. 기존의 클래스에서 공통된 기능을 수정하면, 이를 상속받은 모든 자식 클래스에서 자동으로 변경사항이 반영된다. 이는 코드의 일관성을 유지하며, 버그를 수정할 때 일관된 변경을 쉽게 적용할 수 있다.

하지만 상속 계층이 깊어질수록 클래스 간의 관계가 복잡해지고

높은 의존성으로 부모 클래스의 메서드가 변경되면, 이를 오버라이드한 자식 클래스의 동작이 영향을 받을 수 있다.

이런 경우, 자식 클래스에서 의도한 대로 동작하지 않게 될 수 있다.

메서드 오버라이딩 (Method Overriding)

자식 클래스는 부모 클래스에서 상속받은 메서드를 수정하여 새로운 기능을 구현할 수 있다.

이를 메서드 오버라이딩이라고 한다. 오버라이딩을 통해 부모 클래스의 메서드를 자식 클래스에서 자신에 맞게 수정할 수 있다.

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("Dog is eating dog food");
    }
}

클래스 (Class)

클래스는 객체의 상태와 행동을 정의한다. 객체는 클래스의 인스턴스이며, 클래스는 이 객체들이 가지는 데이터와 메서드를 정의한다. 클래스는 OOP의 기본 구성 요소로, 객체를 생성하기 위한 구조와 기능을 제공한다.

인스턴스 (Instance)

인스턴스는 클래스의 구체적인 객체이다. 클래스가 정의한 구조와 메서드를 실제로 메모리 상에 구현한 개체로, 프로그램이 실행되는 동안 존재한다. 인스턴스는 클래스의 생성자를 호출함으로써 생성된다. 생성자는 클래스를 기반으로 새로운 객체를 메모리에 할당하고, 객체의 초기 상태를 설정한다.

// 클래스 정의
public class Car {
    // 속성
    private String color;
    private String model;

    // 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    // 메서드
    public void displayInfo() {
        System.out.println("Model: " + model + ", Color: " + color);
    }
}

// 인스턴스 생성 및 사용
public class Main {
    public static void main(String[] args) {
        // Car 클래스의 인스턴스 생성
        Car myCar = new Car("Red", "Toyota Corolla");
        
        // 인스턴스 메서드 호출
        myCar.displayInfo(); // 출력: Model: Toyota Corolla, Color: Red
    }
}

인스턴스는 클래스에서 정의한 속성과 메서드를 가지고 있으며, 각 인스턴스는 고유한 속성 값을 가진다.

이는 인스턴스가 서로 독립적이게 만들며, 각각의 인스턴스가 서로 다른 상태를 유지할 수 있도록 다.

속성 (Attributes)

클래스는 속성을 통해 데이터를 저장한다. 이러한 속성은 클래스의 멤버 변수(필드)로, 객체의 상태를 나타낸다.

예를 들어, Person 클래스는 name, age, address 등의 속성을 가진다.

동작 (Methods)

클래스는 메서드를 통해 동작을 정의한다. 메서드는 클래스의 속성에 대해 작업을 수행하며, 객체의 행동을 구현한다. 예를 들어, Person 클래스는 speak() 메서드를 가질 수 있으며, 이는 객체가 대화하는 동작을 구현한다.

생성자 (Constructor)

생성자는 객체가 생성될 때 호출되는 특별한 메서드로, 객체의 초기 상태를 설정한다.

생성자는 클래스 이름과 동일하며, 객체가 생성될 때 필수적인 초기화를 수행한다.

상속 (Inheritance)

클래스는 다른 클래스를 상속받을 수 있다. 이를 통해 코드의 재사용성을 높이고, 클래스 간의 계층 구조를 만든다.

상속받은 클래스는 부모 클래스의 속성과 메서드를 재사용하거나, 새로운 속성과 메서드를 추가한다.

public class Car {
    // 속성
    private String color;
    private String model;
    
    // 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }
    
    // 메서드
    public void start() {
        System.out.println("The car is starting.");
    }
    
    public String getModel() {
        return model;
    }
}

인터페이스 (Interface)

인터페이스는 클래스가 구현해야 하는 메서드의 집합을 정의하는 설계이다.

인터페이스는 메서드의 시그니처(메서드 이름, 매개변수)만을 정의하며, 실제 메서드의 구현은 해당 인터페이스를 구현하는 클래스에서 제공한다. 인터페이스는 클래스 간의 공통된 동작을 정의하고, 이를 강제하기 위해 사용된다.

메서드 시그니처

메서드 이름: 메서드의 이름은 메서드를 호출할 때 사용하는 식별자이다

매개변수 목록: 메서드가 받는 매개변수의 타입과 순서

public class Example {
    // 메서드 시그니처: "add(int, int)"
    public int add(int a, int b) {
        return a + b;
    }

    // 메서드 시그니처: "add(double, double)"
    public double add(double a, double b) {
        return a + b;
    }
}

클래스가 인터페이스를 구현하면, 그 클래스는 인터페이스에서 정의한 모든 메서드를 실제로 구현해야 한다.

즉, 인터페이스의 계약을 준수해야 한다.

//클래스
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}

//인터페이스
public interface Animal {
    void eat();
    void sleep();
}

다중 상속 (Multiple Inheritance)

클래스는 단일 상속만 지원하지만, 인터페이스는 다중 상속을 지원한다. 인터페이스는 메서드의 구현을 제공하지 않기 때문에 하나의 클래스는 여러 개의 인터페이스를 구현할 수 있으며, 인터페이스에서는 구현을 제공하는 클래스가 중복될 수 없다.

인터페이스: List 인터페이스는 리스트의 기본적인 동작을 정의하지만, 실제 구현은 ArrayList, LinkedList 등에서 제공

프레임워크: 애플리케이션을 위한 프레임워크 Spring, Django(Python 진영)

서블릿은 Java EE로 이루어진 웹 서버의 확장 모듈로 클라이언트(웹 브라우저)로 부터

HTTP 요청을 받아 응답을 생성하여 반환한다.

동적인 웹 페이를 생성하거나 데이터베이스와 상호작용하는 데 사용된다.

서블릿의 주요 기능

• 요청 처리: 클라이언트의 HTTP 요청을 처리하고, 요청에 대한 응답을 생성한다.
• 세션 관리: 사용자 세션을 관리하여 상태를 유지한다.
• 비즈니스 로직: 서버 측에서 비즈니스 로직을 구현하여 클라이언트의 요청에 대해 처리한다.
• 데이터베이스 상호작용: 데이터베이스와 상호작용하여 데이터를 조회하거나 업데이트한다.
• 응답 생성: HTML, XML, JSON 등 다양한 형식의 콘텐츠를 생성하여 클라이언트에 응답한다.

서블릿의 생명 주기

init()

서블릿이 최초로 생성될 때 호출된다. 초기화 작업을 수행하며, 서블릿이 요청을 처리하기 전에 한 번만 호출된다.

@Override
public void init() throws ServletException {
    // 초기화 코드
}

service(HttpServletRequest req, HttpServletResponse res)

클라이언트의 요청이 있을 때마다 호출된다. 요청을 처리하고 응답을 생성하는 메소드이다.

@Override
protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    // 요청 처리 코드
}

destroy()

서블릿이 종료될 때 호출된다. 서블릿이 더 이상 사용되지 않거나 서버가 종료될 때 호출된다.

@Override
public void destroy() {
    // 정리 코드
}

서블릿의 구성 및 설정

web.xml 파일은 웹 애플리케이션의 배포 디스크립터로, 서블릿의 매핑과 초기화 매개변수를 정의한다.

<web-app>
    <servlet>
        <servlet-name>exampleServlet</servlet-name>
        <servlet-class>com.example.ExampleServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>exampleServlet</servlet-name>
        <url-pattern>/example</url-pattern>
    </servlet-mapping>
</web-app>

서블릿에서 클라이언트 요청과 응답을 처리하는 방법

HttpServletRequest

클라이언트의 요청 정보를 담고 있는 객체로, 요청 파라미터, 세션, 요청 헤더 등을 읽어온다.

String param = req.getParameter("paramName");

HttpServletResponse

서버가 클라이언트에게 응답을 보내는 객체로, 응답의 콘텐츠 타입, 응답 데이터 등을 설정할 수 있다.

res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<h1>Hello, World!</h1>");

서블릿에서 세션을 관리하는 방법

세션 생성: HttpServletRequest 객체를 통해 세션을 생성

HttpSession session = req.getSession();

세션에 데이터 저장: 세션 객체에 데이터를 저장

session.setAttribute("key", "value");

세션에서 데이터 조회: 저장된 데이터를 세션에서 조회합니다

String value = (String) session.getAttribute("key");

세션 삭제: 세션을 무효화하여 삭제

session.invalidate();

값 저장하기

• 컨트롤러에서 HttpSession 객체를 인자로 받아온다.
• session.setAttribute("key", value)를 호출해 값을 저장한다.

@Controller
public class MyController {
    @RequestMapping("/save")
    public String saveToSession(HttpSession session) {
        session.setAttribute("username", "JohnDoe");
        return "success";
    }
}

값 꺼내기

• HttpSession 객체를 통해 저장된 값을 가져온다.
• session.getAttribute("key")를 사용해 값을 읽어온다.

@Controller
public class MyController {
    @RequestMapping("/get")
    public String getFromSession(HttpSession session, Model model) {
        String username = (String) session.getAttribute("username");
        model.addAttribute("username", username);
        return "welcome";
    }
}

추상 클래스 (Abstract Class)

추상 클래스는 인스턴스를 생성할 수 없는 클래스이다. 다른 클래스들이 이 클래스를 상속받아 그 기능을 구현해야 한다.

추상 클래스는 공통적인 상태와 동작을 공유하는데 쓰인다.

부분 구현: 추상 클래스는 메서드의 구현을 제공한다. 일부 메서드는 구현이 되어 있고, 일부는 추상 메서드로 선언된다.

생성자: 추상 클래스는 생성자를 가질 수 있다. 이를 통해 서브클래스에서 공통된 초기화를 수행할 수 있다.

상속: 클래스는 하나의 추상 클래스를 상속받을 수 있다.

상태 보유: 필드(속성)를 가질 수 있다.

abstract class Animal {
    // 추상 메서드 (하위 클래스에서 구현해야 함)
    abstract void makeSound();
    
    // 구현된 메서드
    void sleep() {
        System.out.println("Zzz...");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

인터페이스 (Interface)

인터페이스는 클래스가 구현해야 하는 메서드의 계약(메서드 시그니처)을 정의한다.

인터페이스는 메서드의 구현을 제공하지 않고, 메서드의 이름과 시그니처만 정의한다.

인터페이스에 정의된 메서드는 추상적이며, 메서드의 구현은 인터페이스를 구현하는 클래스에서 제공해야 한다.

클래스는 여러 인터페이스를 구현할 수 있다. 자바는 다중 상속을 허용하지 않지만,

인터페이스를 통해 이 문제를 해결한다.

인터페이스는 상수를 정의할 수 있다. 이 상수는 자동으로 public static final로 간주된다.

인터페이스는 다중 구현을 지원하여 클래스가 여러 인터페이스를 구현할 수 있다.

interface Animal {
    // 추상 메서드 (구현 없음)
    void makeSound();
    
    // 인터페이스 내에서 기본 메서드 (Java 8+)
    default void sleep() {
        System.out.println("Zzz...");
    }
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

추상 클래스와 인터페이스의 차이점