잡다한기술블로그

Servlet Filter: 개념과 활용

Servlet Filter는 웹 애플리케이션에서 HTTP 요청 및 응답을 가로채 특정 작업을 수행할 수 있는 기능을 제공합니다. 주로 요청 데이터 검증, 응답 수정, 로깅, 인증 및 권한 검사 등에 사용됩니다.

Servlet Filter란?

주요 특징:

1. 요청 및 응답 처리: 클라이언트 요청 전/후, 서블릿 호출 전/후에 작업 수행.
2. 재사용 가능: 여러 서블릿에 동일한 필터를 적용 가능.
3. 체이닝: 여러 필터를 순서대로 연결하여 처리 가능.

동작 흐름:

1. 클라이언트가 요청을 보냄.
2. 필터가 요청을 가로채고 처리.
3. 필터 체인이 끝나면 서블릿으로 요청 전달.
4. 서블릿에서 응답을 생성하여 필터 체인으로 반환.
5. 필터가 응답을 처리하고 클라이언트로 반환.

자바에서 Servlet Filter 구현

1. 필터 인터페이스 구현

Servlet Filter를 구현하려면 javax.servlet.Filter 인터페이스를 구현해야 합니다.

예시: 로그인 인증 필터

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class AuthenticationFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    // 초기화 작업 (필요 시 구현)
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        // 세션에서 로그인 정보 확인
        if (httpRequest.getSession().getAttribute("user") == null) {
        	// 로그인되지 않은 경우 로그인 페이지로 리다이렉트
	        httpResponse.sendRedirect("/login.jsp");
        } else {
        	// 로그인된 경우 요청을 다음 필터나 서블릿으로 전달
    	    chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {
    // 자원 정리 작업 (필요 시 구현)
    }
}

2. web.xml에 필터 등록

필터를 서블릿 컨테이너에 등록하고 URL 패턴을 매핑합니다.

<filter>
	<filter-name>AuthenticationFilter</filter-name>
	<filter-class>com.example.AuthenticationFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>AuthenticationFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

3. 애너테이션 기반 등록 (대체 방식)

Servlet 3.0 이상에서는 @WebFilter 애너테이션을 사용하여 필터를 등록할 수 있습니다.

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter(filterName = "AuthenticationFilter", urlPatterns = {"/protected/*", "/admin/*"})
public class AuthenticationFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        if (httpRequest.getSession().getAttribute("user") == null) {
	        httpResponse.sendRedirect("/login.jsp");
        } else {
    	    chain.doFilter(request, response);
        }
    }
}

이름 및 URL 패턴 지정 이유

필터 이름 지정:

• 필터 이름(filterName)은 필터를 식별하는 데 사용됩니다. 프로젝트가 커지고 여러 필터를 사용할 때 유지보수성과 가독성을 높이기 위해 필수적입니다.

URL 패턴 지정:

• urlPatterns는 필터를 적용할 경로를 지정합니다. 특정 요청에만 필터를 적용하여 불필요한 작업을 줄이고 성능을 최적화할 수 있습니다.
  • 예: /protected/*는 protected 디렉토리 아래의 모든 요청에 필터를 적용합니다.
  • 예: /admin/*는 관리자 전용 URL에만 필터를 적용하여 권한 관리를 강화합니다.

로그인 필터의 활용 시나리오

1. 로그인 검증:
   • 사용자 요청이 들어올 때 세션을 확인하여 로그인 여부를 검증.
   • 로그인되지 않은 사용자를 로그인 페이지로 리다이렉트.
2. 로깅:
   • 요청 및 응답의 메타데이터를 기록하여 디버깅 및 감사용 로그 생성.
3. 권한 확인:
   • 사용자의 역할(Role)을 확인하여 권한 없는 요청 차단.

권한 확인 필터 예시:

if (httpRequest.getSession().getAttribute("role") == null ||
!httpRequest.getSession().getAttribute("role").equals("ADMIN")) {
    httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "Access Denied");
    return;
}

결론

Servlet Filter는 요청과 응답을 가로채서 처리할 수 있는 강력한 도구입니다. 이를 활용하면 인증, 권한 검사, 로깅 등 다양한 작업을 중앙화하여 효율적인 웹 애플리케이션 관리가 가능합니다. 자바에서 Servlet Filter를 구현하여 깔끔하고 확장 가능한 코드를 작성해 보세요!

JSON: 개념과 활용, 그리고 자바와 자바스크립트에서의 사용법

JSON(JavaScript Object Notation)은 가볍고, 인간과 기계가 모두 읽기 쉬운 데이터 교환 형식입니다. 데이터를 키-값 쌍으로 표현하며, 주로 서버와 클라이언트 간 데이터 교환에 사용됩니다. 이번 글에서는 JSON의 개념, 구조, 자바스크립트와 자바에서 JSON을 다루는 방법을 살펴보겠습니다.

JSON이란 무엇인가?

JSON의 주요 특징:

1. 간결성: 데이터를 표현하는 간단한 형식.
2. 가독성: 사람과 기계가 쉽게 읽을 수 있음.
3. 언어 독립적: 모든 프로그래밍 언어에서 사용 가능.

JSON 예제:

{
    "name": "John Doe",
    "age": 30,
    "isMarried": false,
    "children": ["Anna", "Billy"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

자바스크립트에서 JSON 다루기

1. JSON 문자열 생성

const jsonData = {
    name: "John Doe",
    age: 30,
    isMarried: false,
    children: ["Anna", "Billy"],
    address: {
        street: "123 Main St",
        city: "New York"
    }
};

// 객체를 JSON 문자열로 변환
const jsonString = JSON.stringify(jsonData);
console.log(jsonString);

2. JSON 문자열을 객체로 변환

const jsonString = '{"name":"John Doe","age":30}';

// JSON 문자열을 객체로 변환
const jsonObject = JSON.parse(jsonString);
console.log(jsonObject.name); // "John Doe"

3. JSON 데이터 보내고 받기 (AJAX 사용)

// 데이터 전송
fetch("https://example.com/api", {
    method: "POST",
    headers: {
	    "Content-Type": "application/json"
    },
    body: JSON.stringify({ name: "John Doe", age: 30 })
})
.then(response => response.json())
.then(data => console.log(data));

자바에서 JSON 다루기

자바에서는 Jackson Databind 라이브러리를 주로 사용하여 JSON 데이터를 처리합니다.

1. 의존성 추가 (Maven):

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.0</version>
</dependency>

2. JSON을 자바 객체로 변환

JSON 문자열:

{
    "name": "John Doe",
    "age": 30,
    "isMarried": false
}

자바 클래스:

public class Person {
    private String name;
    private int age;
    private boolean isMarried;

    // Getters and Setters
    public String getName() {
	    return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public int getAge() {
    	return age;
    }
    public void setAge(int age) {
    	this.age = age;
    }
    public boolean isMarried() {
    	return isMarried;
    }
    public void setMarried(boolean married) {
    	isMarried = married;
    }
}

JSON을 객체로 변환:

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonToObjectExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"John Doe\",\"age\":30,\"isMarried\":false}";

        ObjectMapper objectMapper = new ObjectMapper();

        try {
            Person person = objectMapper.readValue(jsonString, Person.class);
            System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
            System.out.println("Is Married: " + person.isMarried());
        } catch (Exception e) {
	        e.printStackTrace();
        }
    }
}

3. 자바 객체를 JSON으로 변환

import com.fasterxml.jackson.databind.ObjectMapper;

public class ObjectToJsonExample {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John Doe");
        person.setAge(30);
        person.setMarried(false);

        ObjectMapper objectMapper = new ObjectMapper();

        try {
            String jsonString = objectMapper.writeValueAsString(person);
            System.out.println("JSON String: " + jsonString);
        } catch (Exception e) {
	        e.printStackTrace();
        }
    }
}

JSON 데이터와 자바 클래스 매핑

복잡한 JSON 구조 예:

{
    "name": "John Doe",
    "age": 30,
    "children": ["Anna", "Billy"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

자바 클래스:

import java.util.List;

public class Person {
    private String name;
    private int age;
    private List<String> children;
    private Address address;

    // Getters and Setters
    // ...
}

class Address {
private String street;
private String city;

// Getters and Setters
// ...
}

결론

JSON은 간결하고 효율적인 데이터 교환 형식으로, 자바스크립트와 자바에서 쉽게 사용할 수 있습니다. Jackson 라이브러리를 활용하면 JSON 데이터를 객체로 변환하거나 객체를 JSON으로 변환하는 작업을 간단히 처리할 수 있습니다. 이를 통해 서버-클라이언트 간 데이터 교환을 더욱 효율적으로 관리해 보세요!

SQL Injection: 개념과 방어 방법

SQL Injection은 사용자가 입력한 데이터를 통해 데이터베이스에 비정상적인 SQL 쿼리를 주입하는 보안 취약점 공격입니다. 이를 통해 공격자는 데이터베이스의 민감한 데이터를 조회, 수정, 삭제하거나 시스템에 대한 제어권을 얻을 수 있습니다.

이 글에서는 SQL Injection의 개념과 바이패스 방법, 그리고 이를 방어하는 다양한 기법을 자바 예제와 함께 설명하겠습니다.

SQL Injection이란?

SQL Injection은 주로 다음과 같은 방식으로 발생합니다:

• 입력값을 SQL 쿼리 문자열에 그대로 삽입하여 실행.
• 쿼리의 논리를 변조하여 의도하지 않은 결과를 유도.

예시: 취약한 코드

String query = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "';";

공격자가 username에 admin' --를 입력하면 쿼리는 다음과 같이 변조됩니다:

SELECT * FROM users WHERE username = 'admin' -- ' AND password = '';

--는 SQL에서 주석 처리를 의미하므로 비밀번호 조건이 무시됩니다.

SQL Injection 바이패스 방법

SQL Injection 바이패스는 데이터베이스의 입력 검증과 로직을 우회하여 공격하는 기법입니다.

바이패스 방법 예시:

1. 논리 우회:
   • 입력값에 논리 연산자(OR 1=1)를 삽입하여 조건을 항상 참으로 만듦.
   • 예: username=admin' OR 1=1 --
2. 유효성 검사 우회:
   • 특수문자, 인코딩 기법을 활용하여 필터링 로직을 우회.
   • 예: admin' OR '1'='1 (문자열 비교 이용).
3. 스키마 정보 노출:
   • UNION 쿼리를 사용하여 추가적인 데이터베이스 정보를 조회.
   • 예: admin' UNION SELECT null, username, password FROM users --

SQL Injection 방어 방법

SQL Injection을 방지하기 위해 다음 기법을 사용할 수 있습니다.

1. 입력값 검증

입력값을 철저히 검증하여 예상치 못한 입력을 필터링합니다.

예제:

String username = request.getParameter("username");
String sanitizedUsername = username.replaceAll("[^a-zA-Z0-9]", "");

2. SQL 로직 검증

SQL 쿼리 작성 시 논리적 오류가 발생하지 않도록 구조를 점검합니다.

예제:

if (username.contains("'") || password.contains("'")) {
	throw new IllegalArgumentException("Invalid characters in input");
}

3. Prepared Statement 사용

Prepared Statement는 파라미터화된 쿼리를 사용하여 SQL Injection 공격을 원천적으로 차단합니다.

Statement와의 차이점:

• Statement: 쿼리와 데이터를 결합하여 실행.
• Prepared Statement: 쿼리와 데이터를 분리하여 처리.

취약한 Statement 예제:

Statement stmt = connection.createStatement();
String query = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "';";
ResultSet rs = stmt.executeQuery(query);

안전한 Prepared Statement 예제:

String query = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement pstmt = connection.prepareStatement(query);
pstmt.setString(1, username);
pstmt.setString(2, password);
ResultSet rs = pstmt.executeQuery();

4. ORM (Object-Relational Mapping) 사용

JPA, Hibernate 같은 ORM 프레임워크를 사용하여 SQL 쿼리를 직접 작성하지 않고 객체 지향적으로 데이터베이스와 상호작용.

예제:

@Entity
public class User {
    @Id
    private Long id;
    private String username;
    private String password;
}

public User findByUsernameAndPassword(String username, String password) {
    return entityManager.createQuery(
    "SELECT u FROM User u WHERE u.username = :username AND u.password = :password", User.class)
    .setParameter("username", username)
    .setParameter("password", password)
    .getSingleResult();
}

마무리: SQL Injection 방어의 중요성

SQL Injection은 잘못된 입력값 처리를 통해 발생하는 심각한 보안 취약점입니다. 이를 방지하려면 입력값 검증, 로직 점검, 그리고 Prepared Statement와 같은 안전한 프로그래밍 기법을 활용해야 합니다. 보안을 염두에 두고 코드를 작성하는 습관을 들여 안전한 애플리케이션을 개발하세요!

서블릿(Servlet)

**서블릿(Servlet)**은 자바 기반 웹 애플리케이션에서 클라이언트의 요청을 처리하고 동적 콘텐츠를 생성하는 서버 측 컴포넌트입니다. HTTP 프로토콜을 기반으로 하며, Java Servlet API를 통해 동작합니다. 주로 HTML, JSON, XML 등의 응답을 생성하여 클라이언트에 반환합니다.

이 글에서는 서블릿의 개념과 함께 클라이언트에서 데이터를 보내고 받는 방법, 그리고 서블릿에서 JSP를 통해 데이터를 반환하는 방법을 예제와 함께 설명합니다.

서블릿의 주요 기능

1. 클라이언트 요청 처리:
   • GET, POST, PUT 등의 HTTP 요청을 처리합니다.
2. 데이터 처리 및 로직 수행:
   • 서버에서 필요한 비즈니스 로직을 수행하고 데이터베이스와 상호작용합니다.
3. 응답 생성:
   • 클라이언트가 이해할 수 있는 형식(HTML, JSON 등)으로 데이터를 반환합니다.

클라이언트에서 서블릿에 데이터 보내는 방법

클라이언트는 GET 또는 POST 요청을 통해 데이터를 서블릿에 보낼 수 있습니다.

1. GET 요청을 통한 데이터 전송

GET 요청은 URL에 데이터를 쿼리 문자열(Query String)로 포함하여 전송합니다.

- URL뒤에 ?와 &이용하여 데이터를 포함

클라이언트 요청 예시:

<a href="http://localhost:8080/MyServlet?name=John&age=30">Send Data</a>

서블릿에서 GET 요청 처리:

request.getParameter()이용하여 클라이언트가 보낸 데이터를 받습니다.

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import java.io.IOException;

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
	    // 데이터 수신
        String name = request.getParameter("name");
        String age = request.getParameter("age");

        // 응답 작성
        response.setContentType("text/html");
        response.getWriter().println("<h1>Name: " + name + ", Age: " + age + "</h1>");
    }
}

2. POST 요청을 통한 데이터 전송

POST 요청은 데이터를 요청 본문(Body)에 포함하여 전송합니다.

- form 태그 이용하여 action에 URL, method에 POST 입력

- input 태그 이용하여 입력 받은 데이터를 요청 본문(Body)에 포함 

클라이언트 요청 예시:

<form action="http://localhost:8080/MyServlet" method="POST">
    <input type="text" name="name" placeholder="Enter your name">
    <input type="number" name="age" placeholder="Enter your age">
    <button type="submit">Submit</button>
</form>

서블릿에서 POST 요청 처리:

request.getParameter()이용하여 클라이언트가 보낸 데이터를 받습니다.

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import java.io.IOException;

public class MyServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 데이터 수신
        String name = request.getParameter("name");
        String age = request.getParameter("age");

        // 응답 작성
        response.setContentType("text/html");
        response.getWriter().println("<h1>Name: " + name + ", Age: " + age + "</h1>");
    }
}

서블릿에서 클라이언트에 데이터 보내는 방법 (JSP 사용)

서블릿은 JSP와 연동하여 동적 웹 페이지를 생성할 수 있습니다.

- request.setAttribute("dataName", Data)를 이용하여 JSP에 데이터 전송

1. 서블릿에서 JSP로 데이터 전달:

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import java.io.IOException;

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 데이터 설정
        request.setAttribute("message", "Hello from Servlet!");

        // JSP로 포워딩
        RequestDispatcher dispatcher = request.getRequestDispatcher("/display.jsp");
        dispatcher.forward(request, response);
    }
}

2. JSP에서 데이터 출력:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
<title>Servlet to JSP</title>
</head>
<body>
<h1>Message from Servlet: ${message}</h1>
<h1>Message from Servlet: <%= message></h1>
</body>
</html>

서블릿과 JSP의 활용 예시

1. 로그인 시스템:
   • 클라이언트가 로그인 폼에서 입력한 데이터를 서블릿으로 보내 검증 후 JSP로 결과를 반환.
2. 데이터 조회 및 출력:
   • 데이터베이스에서 조회한 결과를 서블릿에서 처리하고 JSP에서 테이블 형식으로 출력.
3. RESTful API와 연동:
   • 클라이언트에서 서블릿으로 JSON 데이터를 보내고 처리한 결과를 JSP 또는 JSON 형식으로 응답.

마치며

서블릿은 자바 기반 웹 애플리케이션에서 중요한 역할을 합니다. GET과 POST 요청을 통해 클라이언트와 데이터를 주고받고, JSP를 활용해 동적 콘텐츠를 생성하는 방법을 이해하면 더욱 효율적인 웹 개발이 가능합니다. 이를 실습하며 능력을 키워보세요!

객체 지향 설계 원칙: SOLID

객체 지향 설계에서 SOLID 원칙은 유지보수성과 확장성이 높은 소프트웨어를 개발하기 위해 지켜야 할 다섯 가지 기본 원칙을 의미합니다. 이 글에서는 SOLID의 각 원칙을 자세히 설명하고, 이러한 원칙이 왜 중요한지 살펴보겠습니다.

SOLID란 무엇인가?

SOLID는 객체 지향 설계의 다섯 가지 원칙을 정의한 약어로, 다음과 같은 원칙들로 구성됩니다:

1. S: 단일 책임 원칙 (Single Responsibility Principle)
2. O: 개방-폐쇄 원칙 (Open/Closed Principle)
3. L: 리스코프 치환 원칙 (Liskov Substitution Principle)
4. I: 인터페이스 분리 원칙 (Interface Segregation Principle)
5. D: 의존성 역전 원칙 (Dependency Inversion Principle)

이 원칙들은 소프트웨어를 더 유연하고 유지보수 가능하게 만들어줍니다.

1. 단일 책임 원칙 (SRP)

클래스는 단 하나의 책임만 가져야 한다.

설명:

클래스는 하나의 역할만 가져야 하며, 변경의 이유가 하나여야 합니다. 여러 책임이 한 클래스에 섞이면 수정이 어려워지고, 코드 재사용성이 떨어집니다.

예제:

class ReportGenerator {
    public void generateReport() {
    // 보고서 생성 로직
    }

    public void printReport() {
    // 보고서 출력 로직
    }
}

위 클래스는 보고서 생성과 출력 두 가지 책임을 가지고 있습니다. 이를 분리하면:

class ReportGenerator {
    public void generateReport() {
    // 보고서 생성 로직
    }
}

class ReportPrinter {
    public void printReport() {
    // 보고서 출력 로직
    }
}

장점:

• 클래스가 더 간결해짐.
• 특정 책임의 변경이 다른 부분에 영향을 미치지 않음.

2. 개방-폐쇄 원칙 (OCP)

클래스는 확장에는 열려 있어야 하지만, 수정에는 닫혀 있어야 한다.

설명:

새로운 기능이 추가될 때 기존 코드를 수정하지 않고 확장할 수 있어야 합니다. 이를 통해 기존 코드의 안정성을 보장할 수 있습니다.

예제:

기존 코드:

class Notification {
    public void send(String type) {
        if (type.equals("Email")) {
	        System.out.println("Send Email");
        } else if (type.equals("SMS")) {
    	    System.out.println("Send SMS");
        }
    }
}

OCP를 적용:

interface Notification {
	void send();
}

class EmailNotification implements Notification {
    @Override
    public void send() {
	    System.out.println("Send Email");
    }
}

class SMSNotification implements Notification {
    @Override
    public void send() {
	    System.out.println("Send SMS");
    }
}

장점:

• 새로운 알림 타입 추가 시 기존 코드를 수정할 필요 없음.

3. 리스코프 치환 원칙 (LSP)

하위 클래스는 상위 클래스에서 기대하는 동작을 모두 수행할 수 있어야 한다.

설명:

상위 클래스의 객체를 하위 클래스 객체로 대체해도 프로그램의 동작에 문제가 없어야 합니다.

예제:

위반 사례:

class Rectangle {
    private int width;
    private int height;

    public void setWidth(int width) {
	    this.width = width;
    }

    public void setHeight(int height) {
    	this.height = height;
    }

    public int getArea() {
    	return width * height;
    }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
	    super.setWidth(width);
    	super.setHeight(width);
    }

    @Override
    public void setHeight(int height) {
    	super.setWidth(height);
    	super.setHeight(height);
	}
}

위 코드에서는 사각형(Rectangle) 객체를 기대하는 코드가 정사각형(Square) 객체에서 의도치 않은 동작을 경험할 수 있습니다.

해결:

직사각형과 정사각형을 별도 클래스로 설계.

4. 인터페이스 분리 원칙 (ISP)

클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 한다.

설명:

하나의 거대한 인터페이스 대신, 더 작고 구체적인 인터페이스로 분리해야 합니다.

예제:

위반 사례:

interface Worker {
    void work();
    void eat();
}

class Robot implements Worker {
    @Override
    public void work() {
	    System.out.println("Robot working");
    }

    @Override
    public void eat() {
    	// 로봇은 먹지 않음
    }
}

ISP 적용:

interface Workable {
	void work();
}

interface Eatable {
	void eat();
}

class Robot implements Workable {
    @Override
    public void work() {
	    System.out.println("Robot working");
    }
}

장점:

• 불필요한 메서드 의존 제거.

5. 의존성 역전 원칙 (DIP)

고수준 모듈은 저수준 모듈에 의존해서는 안 된다. 둘 다 추상화에 의존해야 한다.

설명:

구체적인 구현보다 인터페이스와 같은 추상화에 의존하도록 설계해야 합니다.

예제:

위반 사례:

class Keyboard {}
class Monitor {}

class Computer {
    private Keyboard keyboard;
    private Monitor monitor;

    public Computer() {
        this.keyboard = new Keyboard();
        this.monitor = new Monitor();
    }
}

DIP 적용:

interface InputDevice {}
class Keyboard implements InputDevice {}

interface OutputDevice {}
class Monitor implements OutputDevice {}

class Computer {
    private InputDevice inputDevice;
    private OutputDevice outputDevice;

    public Computer(InputDevice inputDevice, OutputDevice outputDevice) {
    	this.inputDevice = inputDevice;
    	this.outputDevice = outputDevice;
    }
}

장점:

• 의존성 주입을 통해 유연성 증가.

SOLID 원칙이 필요한 이유

1. 유지보수성: 코드를 더 쉽게 수정하고 확장할 수 있습니다.
2. 재사용성: 모듈화된 설계를 통해 코드 재사용이 가능.
3. 확장성: 요구사항 변경에 유연하게 대응.
4. 가독성: 명확하고 직관적인 코드 작성.

SOLID 원칙을 준수하면, 변화에 강하고 확장 가능한 소프트웨어를 설계할 수 있습니다. 이를 실천함으로써 소프트웨어 개발의 품질을 한 단계 높여보세요!