1. JDBC (Java Database Connectivity)

• 정의: 자바에서 데이터베이스에 연결하고 SQL 쿼리를 실행하기 위한 저수준 API입니다.
• 특징: 데이터베이스와의 연결, 쿼리 실행, 결과 처리 등을 수동으로 관리해야 합니다. SQL을 직접 작성해야 하며, 코드가 길어질 수 있습니다. 성능은 좋지만, 유지보수가 어렵고 코드가 복잡해질 수 있습니다.

2. ORM (Object-Relational Mapping)

• 정의: 객체 지향 프로그래밍 언어의 객체와 관계형 데이터베이스의 데이터 간의 매핑을 자동으로 처리하는 기술입니다.
• 특징: SQL 쿼리 없이 객체를 데이터베이스에 저장하거나 조회할 수 있도록 해줍니다. 코드의 가독성과 유지보수성을 높입니다. ORM 구현체를 사용하면 객체와 데이터베이스 간의 변환을 자동으로 처리합니다.

3. JPA (Java Persistence API)

• 정의: 자바 EE의 스펙으로, ORM을 구현하기 위한 표준 API입니다.
• 특징: 데이터베이스와의 상호작용을 추상화하여, 객체를 영속화하는 방법을 정의합니다. JPA를 사용하면 다양한 ORM 구현체(Hibernate, EclipseLink 등)를 교체할 수 있습니다. JPA는 데이터베이스 작업을 객체 지향적으로 처리할 수 있도록 돕습니다.

4. Hibernate

• 정의: JPA의 대표적인 구현체로, 가장 널리 사용되는 ORM 프레임워크입니다.
• 특징: JPA의 모든 기능을 제공하며, 추가적인 기능(예: 세션 관리, 캐싱 등)을 갖추고 있습니다. 복잡한 쿼리, 관계 매핑, 트랜잭션 관리 등 다양한 기능을 지원합니다. Hibernate는 JPA의 표준을 따르기 때문에 JPA로 작성된 코드를 사용할 수 있습니다.

5. Spring Data JPA

• 정의: 스프링 프레임워크의 일부로, JPA를 쉽게 사용할 수 있도록 돕는 프로젝트입니다.
• 특징: 리포지토리 패턴을 사용하여 데이터 액세스를 단순화합니다. 기본 CRUD 메서드 및 쿼리를 자동으로 생성하여 개발자의 작업을 줄여줍니다. JPA와 Hibernate를 쉽게 통합하여 사용할 수 있으며, 스프링의 다양한 기능(예: 트랜잭션 관리, AOP 등)을 활용할 수 있습니다. 관계 및 차이점 JDBC는 가장 기본적인 데이터베이스 연결 방식으로, ORM이나 JPA와는 독립적인 기술입니다. ORM은 JDBC와 같은 저수준 API 대신 객체와 데이터베이스의 매핑을 자동으로 처리하는 개념입니다. JPA는 ORM의 표준 API입니다. JPA는 ORM의 표준을 정의하는 것이고, Hibernate는 JPA의 구체적인 구현체입니다. 따라서 Hibernate는 JPA의 규칙을 따르면서 추가 기능을 제공합니다. Spring Data JPA는 JPA를 쉽게 사용하기 위한 도구로, JPA/Hibernate와 함께 사용되며 데이터 액세스를 단순화합니다.

1. IoC (Inversion of Control, 제어의 역전)

• 개념: IoC는 객체의 생성, 생명주기 관리, 의존성 주입 등과 같은 작업을 개발자가 아니라 프레임워크나 컨테이너가 대신 담당하는 것을 의미합니다. 즉, 프로그램의 제어 흐름이 사용자가 아닌 외부 프레임워크에 의해 제어된다는 의미입니다.
• 스프링에서의 역할: 스프링 프레임워크는 IoC 컨테이너를 사용하여 객체의 생성과 관리를 책임집니다. 개발자는 객체 생성이나 의존성 관리에 신경 쓰지 않고 비즈니스 로직 구현에 집중할 수 있습니다.

2. DI (Dependency Injection, 의존성 주입)

• 개념: DI는 객체 간의 의존성을 외부에서 주입하는 방식입니다. 즉, 객체가 스스로 의존 객체를 생성하거나 찾는 것이 아니라, 외부에서 필요한 객체를 주입받아 사용하는 방식입니다. 이는 의존성 관리의 한 방식으로, IoC의 한 구현 방법입니다.
• 스프링에서의 역할: 스프링은 DI를 통해 객체 간의 의존성을 설정합니다. 이를 통해 코드의 결합도를 낮추고, 유지보수와 테스트가 쉬워집니다. DI 방식에는 크게 생성자 주입과 Setter 주입 두 가지가 있습니다.

3. DIP (Dependency Inversion Principle, 의존성 역전 원칙)

• 개념: DIP는 객체지향 설계의 원칙 중 하나로, 고수준 모듈이 저수준 모듈에 의존해서는 안 된다는 원칙입니다. 대신, 두 모듈 모두 추상화(인터페이스나 추상 클래스)에 의존해야 한다고 제안합니다. 이를 통해 고수준 모듈과 저수준 모듈 간의 의존성을 역전시키고, 유연성과 확장성을 높일 수 있습니다.
• 차이점: DIP는 객체 지향 설계 원칙에 해당하며, DI는 이를 구현할 수 있는 하나의 방법론으로 볼 수 있습니다. DIP를 따르는 설계를 구현하기 위해 DI가 자주 사용됩니다.

정리

• IoC는 제어권을 개발자가 아닌 프레임워크에 넘기는 개념.
• DI는 IoC의 한 구현 방식으로, 객체의 의존성을 외부에서 주입하는 방법.
• DIP는 객체 지향 설계 원칙으로, 고수준 모듈이 저수준 모듈에 의존하지 않도록 설계하는 것.

스프링은 IoC 컨테이너를 통해 DI를 구현하고, 이를 통해 DIP와 같은 객체 지향 원칙을 따르는 설계를 유도합니다.

Q. 스프링에서 데이터 엑세스는 어떻게 이루어지는가?

A. 스프링에서의 데이터 액세스는 주로 JDBC, JPA, 그리고 MyBatis를 사용하여 이루어진다.

Q. JDBC는 무엇인가?

A. JDBC는 자바에서 데이터베이스와의 연결과 쿼리 실행을 위한 API이다. 이를 사용하면 데이터베이스와 직접적인 연결을 설정하고 SQL 쿼리를 실행할 수 있다.

JDBC를 사용하면 데이터베이스에 대한 세부적인 제어가 가능하며, 직접 SQL 쿼리를 작성하여 실행할 수 있다. 그러나 JDBC를 사용할 경우에는 보다 많은 코드 작성과 반복적인 작업이 필요할 수 있다.

Q. JDBC는 무엇인가?

A. JDBC(ava Database Connectivity)는 자바에서 데이터베이스와의 연결과 쿼리 실행을 위한 API이다. 이를 사용하면 데이터베이스와 직접적인 연결을 설정하고 SQL 쿼리를 실행할 수 있다.

JDBC를 사용하면 데이터베이스에 대한 세부적인 제어가 가능하며, 직접 SQL 쿼리를 작성하여 실행할 수 있다. 그러나 JDBC를 사용할 경우에는 보다 많은 코드 작성과 반복적인 작업이 필요할 수 있다.

JDBC를 사용한 데이터베이스 연동

import java.sql.*;

public class JdbcExample {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection con = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/mydatabase", "username", "password");

            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM mytable");

            while (rs.next())
                System.out.println(rs.getInt(1) + "  " + rs.getString(2) + "  " + rs.getString(3));

            con.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

Q. JPA란 무엇인가?

A. JPA(Java Persistence API)는 자바에서 객체와 관계형 데이터베이스 간의 매핑을 지원하는 API이다. 객체지향 프로그래밍에서는 객체를 데이터베이스에 저장하고 검색하는 과정에서 객체와 테이블 간의 매핑이 필요한데, JPA는 이러한 작업을 간편하게 처리할 수 있도록 도와준다.

JPA를 사용하면 객체와 테이블 간의 매핑을 어노테이션을 통해 설정할 수 있으며, 개발자는 객체를 중심으로 코드를 작성할 수 있다.

JPA를 사용한 데이터베이스 연동

import javax.persistence.*;
import java.util.List;

@Entity
@Table(name = "mytable")
public class JpaExample {
    @Id
    private int id;
    private String name;
    private String email;

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistence-unit-name");
        EntityManager em = emf.createEntityManager();

        Query query = em.createQuery("SELECT e FROM JpaExample e");
        List<JpaExample> results = query.getResultList();

        for (JpaExample e : results)
            System.out.println(e.getId() + "  " + e.getName() + "  " + e.getEmail());

        em.close();
        emf.close();
    }

    // Getter and Setter methods
}

Q. MyBatis는 무엇인가?

A. MyBatis는 SQL 매핑 프레임워크로, SQL 쿼리와 자바 객체 사이의 매핑을 XML 또는 어노테이션을 통해 설정할 수 있다.

MyBatis를 사용하면 SQL 쿼리를 직접 작성하고 실행할 수 있으며, 동적 쿼리를 쉽게 처리할 수 있는 장점이 있다. 또한 MyBatis는 JDBC를 사용하고 있기 때문에 JDBC에 비해 더 빠르고 유연한 데이터 액세스가 가능하다.

MyBatis를 사용한 데이터베이스 연동

<!-- mybatis-config.xml -->
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
        <property name="username" value="username"/>
        <property name="password" value="password"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="com/example/MyMapper.xml"/>
  </mappers>
</configuration>

// MyMapper.xml
<mapper namespace="com.example.MyMapper">
  <select id="selectUsers" resultType="User">
    SELECT * FROM mytable
  </select>
</mapper>

// MyMapper.java
package com.example;

import java.util.List;

public interface MyMapper {
    List<User> selectUsers();
}

// MyBatisExample.java
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.*;

import java.io.IOException;
import java.io.Reader;
import java.util.List;

public class MyBatisExample {
    public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        Reader reader = Resources.getResourceAsReader(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().

Q. 콜백 함수란 무엇인가?

A. 자바스크립트의 콜백 함수(callback function)는 다른 함수에 인수로 전달되는 함수. 콜백 함수는 보통 이벤트 핸들러, 비동기 작업의 완료 처리, 타이머 설정 등과 같은 상황에서 사용. 콜백 함수를 사용하면 비동기적으로 실행되는 코드를 효과적으로 처리할 수 있다.

콜백 함수의 주요 특징

• 함수로서의 전달: 콜백 함수는 다른 함수의 인수로 전달될 수 있다.
• 비동기적 처리: 콜백 함수는 주로 비동기적으로 실행되는 작업을 처리하는 데 사용. 예를 들어, 파일을 읽거나 저장할 때, 서버와 통신할 때, 타이머를 설정할 때 등 비동기적인 작업이 완료될 때까지 대기할 수 있다.
• 이벤트 처리: 웹 애플리케이션에서는 이벤트 핸들러로서의 역할을 하는 콜백 함수가 매우 흔함. 사용자의 클릭, 키보드 입력, 마우스 움직임 등의 이벤트가 발생할 때마다 콜백 함수가 호출된다.

// 콜백 함수 예시 1: setTimeout 함수를 사용한 비동기 작업
console.log("첫 번째");
setTimeout(function() {
    console.log("두 번째");
}, 1000);
console.log("세 번째");

// 콜백 함수 예시 2: 배열의 forEach 메서드를 사용하여 각 요소에 대해 콜백 함수 호출
const numbers = [1, 2, 3, 4, 5];
numbers.forEach(function(number) {
    console.log(number);
});

// 콜백 함수 예시 3: 이벤트 핸들러로서의 콜백 함수
const button = document.getElementById("myButton");
button.addEventListener("click", function() {
    console.log("버튼이 클릭되었습니다.");
});

Q. 콜백 함수가 왜 필요한가?

A. 비동기프로그래밍을 위해 사용된다. 자바스크립트는 코드를 위에서 아래로 순차적으로 실행한다. 그러나 순차적 실행이 아닌 콜백을 사용하면 비동기 자바스크립트 코드를 작성할 수 있다. 자바스크립트에서 콜백 함수를 만드는 방법은 어떤 함수의 파라미터로써 함수를 넘기고 어떤 행위나 태스크가 완료된 직후에 콜백 함수를 호출하는 것이다.

콜백 함수를 지양하는 이유

• 가독성과 유지보수성의 저하: 콜백 함수를 중첩하게 되면 코드의 가독성이 떨어지고, 이해하기 어려워진다. 또한 콜백 함수 간의 의존성이 높아지기 때문에 코드를 수정하거나 유지보수하기 어려워진다.

• 에러 처리의 어려움: 콜백 함수를 중첩하게 되면 에러 처리가 번거로워진다. 각 콜백 함수마다 에러 처리를 해주어야 하며, 에러가 발생했을 때 콜백 체인 전체를 중단시키고 처리하기 어렵다.

• 콜백 지옥: 콜백 함수를 중첩하여 사용하다 보면 콜백 지옥(callback hell)이 발생할 수 있다. 콜백 지옥은 콜백 함수가 중첩되어 가독성이 매우 나쁘고 코드의 복잡성이 높아지는 상황을 말한다.

콜백 함수를 대체하는 방법

1. 프로미스
2. async/await

이미지 출처 : https://blog.denilgabani.com/callback-function-event-loop-in-javascript-reactjs-web-development

Q. 제어의 역전이란 무엇인가?

A. Inversion of Control(IoC)이란 제어의 역전으로 프로그램의 제어 흐름을 프레임워크나 컨테이너에게 위임하는 개념. 일반적으로 객체의 생성과 생명주기를 개발자가 관리하는 것이 아니라 프레임워크가 관리하며, 프레임워크가 애플리케이션의 흐름을 제어.

스프링에서는 객체를 Bean이라고 함. 프로젝트가 실행될때 사용자가 Bean으로 관리하는 객체들의 생성과 소멸에 관련된 작업을 스프링에서 자동적으로 수행해주는데 객체가 생성되는 곳을 Bean 컨테이너라고 부른다.

Q. 의존성 주입이란 무엇인가?

A. 의존성 주입은 객체 간의 의존 관계를 외부에서 설정하고 관리하는 디자인 패턴.

일반적으로 클래스가 다른 클래스에 의존하는 경우, 이러한 의존성을 클래스 내부에서 생성하거나 관리하면 결합도가 높아져 유연성이 감소한다. 의존성 주입은 이러한 문제를 해결하기 위해 객체의 의존성을 외부에서 주입한다.

출처: https://velog.io/@gillog/Spring-DIDependency-Injection

의존성 주입 구현 방법

1. new 생성자를 활용하여 직접 객체 생성
2. 외부에서 생성된 객체를 setter를 통해 접근

의존성 주입과 제어의 역전의 장점

• 유연성: 의존성이 외부에서 주입되기 때문에 클래스 간의 결합도가 낮아져 유연한 구조를 만들 수 있다.
• 재사용성: 의존성 주입을 통해 독립적인 객체를 만들고 재사용할 수 있다.
• 테스트 용이성: 의존성을 외부에서 주입하므로 테스트 시에 모의 객체(Mock Object)를 주입하여 테스트하기 쉽다.

// 서비스 인터페이스
public interface MessageService {
    String getMessage();
}

// 서비스 구현체
public class EmailService implements MessageService {
    @Override
    public String getMessage() {
        return "Email message";
    }
}

// 클라이언트 클래스
public class MyApplication {
    private MessageService service;

    // 의존성 주입을 통해 MessageService를 주입받음
    public MyApplication(MessageService service) {
        this.service = service;
    }

    public void processMessages() {
        String message = service.getMessage();
        System.out.println("Message: " + message);
    }
}

// 메인 클래스
public class Main {
    public static void main(String[] args) {
        // 의존성 주입을 통해 EmailService를 MyApplication에 주입
        MessageService service = new EmailService();
        MyApplication app = new MyApplication(service);
        app.processMessages();
    }
}

Q. 데이터베이스 정규화란 무엇인가?

A. 데이터베이스 설계에서 중복을 최소화하고 데이터의 무결성을 보장하기 위한 과정

데이터베이스의 유연성, 성능, 안정성을 향상시킬 수 있다. 주로 테이블을 적절한 형태로 분해하여 중복을 제거하고, 관계를 명확하게 정의하는 작업을 포함한다.

정규화의 단계

• 제 1 정규형 (1NF):

각 컬럼이 원자값(Atomic value)을 가지도록 테이블을 구조화. 즉, 테이블의 각 셀에는 하나의 값만 있어야 한다. 이를 위해 중복을 제거하고 별도의 테이블을 생성하거나 관계를 조정한다.

기존 데이터) 제 1 정규화 이후 데이터)

• 제 2 정규형 (2NF):

부분 함수 종속을 제거. 기본키가 아닌 속성들이 기본키 전체에 종속되도록 테이블을 재구성. 이를 위해 테이블을 쪼개거나 필요한 경우 외래키를 추가하여 관계를 재정의.

기존 데이터)

제 2 정규화 이후 데이터)

• 제 3 정규형 (3NF):

이행적 함수 종속을 제거. 기본키가 아닌 속성 간에 직접적인 종속 관계가 없도록 테이블을 재구성. 이를 위해 중복을 최소화하고 중복된 속성을 별도의 테이블로 이동하여 관계를 재정의.

제 3 정규화 이후 데이터)

• 보이스-코드 정규형 (BCNF):

모든 결정자가 후보키이어야 함. 이를 통해 다중 후보키를 가지는 테이블에서 발생할 수 있는 이상현상(Anomaly)을 방지.

이러한 정규화 과정은 데이터베이스의 설계를 개선하고 데이터의 일관성과 무결성을 유지하는 데 중요한 역할을 한다. 그러나 지나치게 정규화된 데이터베이스는 성능 저하와 관리의 어려움을 야기할 수 있으므로 적절한 수준의 정규화가 필요.

Q. Apache kafka란 무엇인가?

A. Apache kafka란 웹사이트, 어플리케이션, 센서 등에서 취합한 데이터를 스트림 파이프라인을 통해 실시간으로 관리하고 보내기 위한 분산 스트리밍 플랫폼이다.

데이터 생성 어플리케이션과 소비 어플리케이션 간의 중재자 역할로 데이터의 전송 제어, 처리, 관리 역할을 담당한다. 어플리케이션과 서비스간의 비동기 데이터 교환을 용이하게 하고 하루 수 조개의 이벤트 처리를 가능하게 한다.

kafka의 특징

1. 여러 전달자가 동시에 메시지 전송 가능. 반대로 여러 소비자가 동시에 메세지 읽기 가능.
2. 전송된 메세지는 일정기간 파일 형태로 저장되어 처리 속도, 장애 복구 가능. 한 노드가 메세지 전송하면 전달자와 소비자를 중재하는 브로커에서 전달자가 전달한 메세지를 브로커의 동작에 영향을 주지 않고 처리 속도 및 장애 복구를 유지하도록 해 일정 기간 동안 파일 형태로 저장.
3. 시스템 트래픽이 높아지면 브로커를 추가해 처리량을 늘릴 수 있음.
4. 처리 속도 저하의 경우 소비자나 생산자를 추가해 처리량을 느릴 수 있음.
5. 컨슈머를 그룹으로 묶어 프로듀서에서 보내는 속도와 읽는 속도의 균형을 맞출 수 있음.

활용 기업 및 방안

트위터 - 사용자에게 트윗 보내고 받는 방법에 사용 링크드인 - 이용자의 사이트 활동 데이터 분석 넷플릭스 - 실시간 모니터링 및 이벤트 처리

💡요약💡 장점: 빠른 속도로 대용량의 데이터 처리 용이. 낮은 지연 시간으로 메세지 빠르게 처리. 시스템 확장 용이. 전달할 메세지를 파일로 저장해 안정성과 신뢰성이 높음. 단점: 모니터링 및 관리 도구가 불편하여 메세지 조정이 필요한 경우 성능이 크게 저하될 수 있음. 클러스터의 대기열 수가 증가하면 상태적으로 느리게 동작하는 경우가 있음.

Q. Redis란 무엇인가?

A. Redis란 remote dictionary server의 약자로 인메모리 데이터 저장소. 주로 데이터베이스, 캐싱 및 메세지 브로커의 역할을 수행하는 오픈소스 소프트웨어.

Redis의 특징

1. 인메모리 데이터 저장: 매우 빠른 읽기 및 쓰기 속도. 캐싱에 유리
2. 다양한 데이터 구조 지원: 문자열, 해시맵, 리스트, 셋, 정렬된 집합과 같은 다양한 구조 지원하여 용도에 맞게 사용 가능
3. 영속성 지원: 메모리에 데이터를 저장하여 시스템 재시작 후에도 데이터 유지 가능.
4. pub/sub 메시징 시스템: publish/subscribe 매커니즘을 지원하여 메시지 브로커로 사용 가능. 다수의 클라이언트가 메세지를 발행하고 수신 가능.

💡요약💡 장점: 빠른 속도, 단순하고 간결한 인터페이스, 다양한 데이터 구조 지원, 높은 가용성 및 확장성, 오픈소스 단점: 데이터 크기 제한, 영속성 저장하는 부분이 제한적, 단일 스레드 모델, 복잡한 쿼리 지원 부족, 오프라인 백업 어려움, 설정 및 튜닝이 필요

Q. kafka와 Redis는 어떤 차이가 있는가?

A. redis는 데이터를 실시간으로 저장하고 읽기 위한 인메모리 데이터베이스이며, kafka는 대규모 데이터를 분산 스트리밍 처리를 위한 플랫폼으로 각기 다른 목적과 사용 사례를 가진다.

Redis는 주로 인메모리 데이터베이스로 사용. 데이터를 메모리에 저장하고, 다양한 데이터 구조를 지원하여 빠른 읽기 및 쓰기 작업에 특화. 주로 캐싱, 세션 저장, 메시지 브로커 등 다양한 용도로 사용. Redis는 데이터를 영속적으로 저장하는 기능도 제공하지만, 주로 인메모리 데이터를 활용한 빠른 데이터 액세스에 중점. 반면, Apache Kafka는 데이터의 실시간 스트리밍을 처리하기 위한 플랫폼. 주로 대량의 데이터를 신속하게 처리하고 여러 시스템 간에 데이터를 실시간으로 전송하는 데 사용. Kafka는 대용량의 데이터를 안정적으로 분산 및 스트리밍 처리할 수 있는 기능을 제공하며, 이벤트 소싱, 로그 집계, 데이터 허브 등 다양한 사용 사례에서 활용. 하지만 Kafka 자체는 데이터를 영속적으로 저장하는 데이터베이스로 사용되는 것이 아니라, 데이터를 안정적으로 전달하고 스트리밍 처리하는 역할.

1. 데이터 저장 방식의 차이: redis는 인메모리 방식이므로 메모리에 저장하고 영속적인 데이터 저장 지원. kafka는 대용량 데이터를 디스크에 영속적 저장하고 분산 로그로 활용.
2. 활용 목적과 범위: redis가 캐싱, 세션 저장, 실시간 분석과 같은 인메모리 데이터 스토어인 반면 kafkasms 대규모 데이터 스트리밍 및 이벤트 처리에 사용.
3. 메시징 모델: redis는 pub/sub모델 지원. kafka는 고성능 메시지 큐 및 메시지 브로커로 사용.
4. 저장구조: redis는 주로 키-값 형태로 저장하나 다양한 구조를 지원. kafka는 토픽과 파티션으로 이루어진 로그 기반의 저장 구조.

Q. Hexagonal architecture란 무엇인가?

A. Hexagonal architecture란 유연하고 확장 가능한 소프트웨어 디자인을 일컫는다.

Hexagonal architecture의 특징

주요 목표는 응용 프로그램의 비즈니스 로직을 외부로부터 격리시켜 유연하고 테스트하기 쉬운 구조로 만드는 것이다. 핵심 비즈니스 로직은 중앙의 도메인에 위치하며 입출력 포트와 어뎁터를 통해 외부와 소통한다.

가장 대중적인 아키텍처는 3계층으로 비즈니스 로직, 데이터 엑세스, 프레젠테이션 계층으로 구성. 비즈니스 로직이 서비스 클래스에 있고 리포지토리 인터페이스를 통해서 데이터 엑세스 계층과 소통.

3계층 아키텍처 구현 예시)

// UserService.java
public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
    }
}

// UserRepository.java
public interface UserRepository {
    void save(User user);
}

// UserRepositoryImpl.java
public class UserRepositoryImpl implements UserRepository {
    public void save(User user) {
        // 데이터베이스에 사용자 저장
    }
}

3계층 아키텍처 Kafka 적용 예시)

// KafkaProducer.java
public class KafkaProducer {
    public void send(User user) {
        // 카프카에 사용자 정보 전송
    }
}

// UserService.java
public class UserService {
    private UserRepository userRepository;
    private KafkaProducer kafkaProducer;

    public UserService(UserRepository userRepository, KafkaProducer kafkaProducer) {
        this.userRepository = userRepository;
        this.kafkaProducer = kafkaProducer;
    }

    public void createUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
        kafkaProducer.send(user);
    }
}

반면, 헥사고날 아키텍쳐에서는 별도의 usecase 인터페이스를 통해서 비즈니스 로직 정의 후 impl클래스로 구현. 레포지토리 어뎁터가 레포지토리 인터페이스를 구현해서 외부와 소통. 따라서 비즈니스 로직과 외부 요소를 격리시켜 유연성과 테스트 용이성을 지원. kafka와 같은 외부 시스템을 연결하면 장점이 돋보이게 됨. 기존 3 tier architecture에서는 service가 kafka에 의존성을 가지지만 hexagonal architecture의 경우 외부 시스템과의 의존성 분리를 통해 시스템 변경 시에도 비즈니스 로직 영향이 최소화 된다.

헥사고날 아키텍쳐 구현 예시)

// CreateUserUseCase.java
public interface CreateUserUseCase {
    void createUser(String name, String email);
}

// CreateUserUseCaseImpl.java
public class CreateUserUseCaseImpl implements CreateUserUseCase {
    private UserRepository userRepository;

    public CreateUserUseCaseImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
    }
}

// UserRepository.java
public interface UserRepository {
    void save(User user);
}

// UserRepositoryAdapter.java
public class UserRepositoryAdapter implements UserRepository {
    public void save(User user) {
        // 데이터베이스에 사용자 저장
    }
}

헥사고날 아키텍쳐 Kafka 적용 예시)

// OutputPort.java
public interface OutputPort {
    void sendMessage(User user);
}

// KafkaAdapter.java
public class KafkaAdapter implements OutputPort {
    private KafkaProducer kafkaProducer;

    public KafkaAdapter(KafkaProducer kafkaProducer) {
        this.kafkaProducer = kafkaProducer;
    }

    public void sendMessage(User user) {
        kafkaProducer.send(user);
    }
}

// CreateUserUseCaseImpl.java
public class CreateUserUseCaseImpl implements CreateUserUseCase {
    private UserRepository userRepository;
    private OutputPort outputPort;

    public CreateUserUseCaseImpl(UserRepository userRepository, OutputPort outputPort) {
        this.userRepository = userRepository;
        this.outputPort = outputPort;
    }

    public void createUser(String name, String email) {
        User user = new User(name, email);
        userRepository.save(user);
        outputPort.sendMessage(user);
    }

}

💡요약💡 장점: 유연성, 테스트 용이성(비즈니스 로직 독립적 테스트 가능), 유지보수성

단점: 구현 복잡성(포트와 어뎁터를 구성하고 관리), 초반 개발 시간 증가(처음 구축시)

출처: https://tech.osci.kr/hexagonal-architecture/

Spring과 Spring Boot은 Java 기반의 웹 애플리케이션 개발을 위한 프레임워크로 널리 사용되고 있다. 두 프레임워크는 공통적으로 Java 기반으로 개발되었지만 몇 가지 중요한 차이점이 존재한다.

1. 프로젝트 설정의 간편성:

• Spring: Spring은 XML 기반의 설정이 주를 이루며, 개발자가 많은 부분을 수동으로 설정해야 합니다. 이는 초기 설정에 시간이 많이 소요되고 복잡성이 증가할 수 있습니다.
• Spring Boot: Spring Boot는 설정의 기본값을 제공하며, 자동 설정(Auto-Configuration)을 통해 개발자가 불필요한 설정을 최소화합니다. 이로써 초기 설정이 간편해지고 더 빠르게 프로젝트를 시작할 수 있습니다.

2. 의존성 관리:

• Spring: 개발자는 프로젝트에 필요한 라이브러리와 의존성을 직접 관리해야 합니다.
• Spring Boot: Spring Boot는 내장된 의존성 관리 도구를 제공하여, 프로젝트에 필요한 의존성들을 자동으로 관리합니다. 이로써 버전 충돌 및 의존성 해결이 간편해집니다.

3. 내장 서버:

• Spring: Spring은 서블릿 컨테이너(Tomcat, Jetty 등)를 내장하지 않고, 별도의 설정이 필요합니다.
• Spring Boot: Spring Boot는 내장된 서블릿 컨테이너를 제공합니다. 별도의 설정 없이도 내장 서버를 통해 애플리케이션을 실행할 수 있습니다.

4. 어노테이션 기반의 설정:

• Spring: Spring은 XML 설정 파일을 사용하는 것이 일반적이며, 어노테이션을 적용하기 위해 추가적인 설정이 필요합니다.
• Spring Boot: Spring Boot는 어노테이션 기반의 설정을 강조하며, 자주 사용되는 설정들을 어노테이션으로 제공합니다. 이는 더 간결하고 가독성이 좋은 코드를 작성할 수 있도록 도와줍니다.

5. 프로젝트 구조:

• Spring: 프로젝트 구조는 개발자가 직접 정의해야 하며, 복잡한 구조가 될 수 있습니다.
• Spring Boot: Spring Boot는 기본적인 프로젝트 구조를 제공하며, 개발자가 추가적인 설정 없이도 쉽게 프로젝트를 구성할 수 있습니다.

🤓요약: Spring과 Spring Boot은 각각의 특징을 가지고 있으며, 프로젝트의 규모와 요구사항에 따라 선택되어야 합니다. Spring은 더 많은 설정과 커스터마이징이 필요한 대규모 프로젝트에 적합하며, Spring Boot는 간단한 설정과 빠른 프로젝트 시작이 가능한 소규모 프로젝트나 마이크로서비스 아키텍처에 적합합니다.

Q. 프로미스란 무엇인가?

A. 프로미스는 자바스크립트 비동기 처리에 사용되는 객체. 프로미스는 주로 서버에서 받아온 데이터를 화면에 표시할 때 사용

• new Promise에 전달되는 함수는 executor(실행자, 실행 함수)라고 부른다. executor는 new Promise가 만들어질 때 자동으로 실행되는데 결과를 최종적으로 만들어내는 제작 코드를 포함한다. executor의 인수 resolve와 reject는 자바스크립트에서 자체 제공하는 콜백으로 개발자는 resolve와 reject를 신경쓰지 않고 executor 안 코드만 작성하면 된다. 단, executor에선 결과를 얻는 즉시 상황에 따라 인수로 넘겨준 콜백 중 하나를 반드시 호출해야 한다.

    let promise = new Promise(function resolve, reject) {
            // executor(제작 코드, '가수')
    });

• new Promise 생성자가 반환하는 promise 객체는 아래와 같은 내부 프로퍼티를 갖는다.

  • state - “pending(대기)” → resolve가 호출되면 “fulfilled”, reject가 호출되면 “rejected”로 변한다.

  • result - undefined → resolve(value)가 호출되면 value로, reject(error)가 호출되면 error로 변한다.

    

Q. 프로미스의 3가지 상태(States)란 무엇인가?

A. 상태란 프로미스의 처리 과정을 의미하며 new Promise()로 프로미스를 생성하고 종료될 때까지 3가지 상태를 갖는다.

• Pending(대기): 비동기 처리 로직이 아직 완료되지 않은 상태

  new Promise() 메서드를 호출하면 대기(Pending)상태가 된다.

  new Promise()메서드를 호출할 때 콜백 함수를 선언할 수 있고, 콜백 함수의 인자는 resolve, reject이다.

    new Promise(function resolve, reject) {
            // ...
    }

• Fulfilled(이행) : 비동기 처리가 완료되어 프로미스 결과 값을 반환해준 상태

  콜백 함수의 인자 resolve를 실행하면 이행(Fulfilled)상태가 되며 이행 상태가 되면 then()을 이용하여 처리 결과 값을 받을 수 있다.

    function getData() {
            return new Promise(function(resolve, reject) {
                    var data = 100;
                    resolve(data);
            }
    }
  
    // resolve()의 결과 값 data를 resolvedData로 받음
    getData().then(function(resolvedData) {
            console.log(resolvedData);
    });

• Rejected(실패) : 비동기 처리가 실패하거나 오류가 발생한 상태

  reject를 호출하면 실패(Rejected)상태가 되며, 실패 상태가 되면 실패한 이유를 catch()로 받을 수 있다.

    function getData() {
            reject(new Error("Request is failed"));
    }
  
    getData().then().catch(function(err) {
            console.log(err);
    });

프로미스 처리 흐름

Q. 메소드 - then, catch, finally란 무엇인가?

• then

  • 프로미스에서 가장 중요하고 기본이 되는 메소드

    promise.then(
          function(result) {},   // 첫번째 인수 : 프로미스가 이행되었을 때 실행되는 함수
          function(error) {}  // 두번째 인수 : 프로미스가 거부되었을 때 실행되는 함수
    );
    // 작업이 성공적으로 처리된 경우만 다루고 싶다면 .then에 인수를 하나만 전달

• catch

  • 에러가 발생한 경우만 다루고 싶을 때 사용

    let promise = new Promise((resolve, reject) => {
          setTimeout(()=>reject(new Error("에러 발생")), 1000);
    });
    
    // .catch(f)는 promise.then(null,f)와 동일하게 작동
    promose.catch(alert);  // promise.then(null, alert); 동일

• finally

  • 프로미스가 처리되면 항상 실행된다. (.finally(f)호출은 .then(f,f)와 유사)

  • 결과가 어떻든 마무리가 필요하면 finally가 유용하다.

  • .then(f, f)와 차이점

    • finally 핸들러에는 인수가 없으며, finally에서는 프로미스가 이행되었는지 거부되었는지 알 수 없다.

    • finally 핸들러는 자동으로 다음 핸들러에 결과와 에러를 전달한다.

      new Promise((resolve), reject) => {
            setTimeout(() => resolve("결과"), 2000);
      })
            .finally(() => alert("프로미스가 준비되었습니다.")
            .then(result => alert(result));

Q. 프로미스 체이닝 (Promise Chaining)이란 무엇인가?

A. 순차적으로 처리해야하는 비동기 작업을 여러개 사용하는 경우 활용

new Promise(function(resolve, reject) {

  setTimeout(() => resolve(1), 1000); // (*)

}).then(function(result) { // (**)

  alert(result); // 1
  return result * 2;

}).then(function(result) { // (***)

  alert(result); // 2
  return result * 2;

}).then(function(result) {

  alert(result); // 4
  return result * 2;

});

1. 1초후 최초의 프로미스 이행
2. 이후 첫번째 .then 핸들러 호출
3. 2에서 반환한 값은 다음 .then 핸들러에 전달

출처 :

• https://ko.javascript.info/promise-basics
• https://joshua1988.github.io/web-development/javascript/promise-for-beginners/
• https://elvanov.com/2597
• https://sangminem.tistory.com/284

@Transactional 어노테이션을 추가해서 save 메서드를 직접 호출하지 않고 변경감지로 update해주는 api를 만들었는데 update쿼리가 날아가지 않는 이슈가 발생했다.

문제 코드 )

// controller
@PostMapping("/{id}/object")
public void addOrUpdateObject(@PathVariable long id, @ModelAttribute ObjectRequest request){
    objectService.checkObject(request);
}

//service
public void addOrUpdateObject(ObjectRequest request){
    if(request.getId() == null)
        addObject(request);
    else
        modifyObject(request.getId(),request);
}

@Transactional
public void modifyObject(long objectId, ObjectRequest request){
    Object obj = objectRepositsory.findById(objectId).orElseThrow(() -> new NoSuchElementException("존재하지 않는 오브젝트입니다.");
    obj.updateObject(request);
}

🤓문제 해결 과정

step1. 디버깅을 통해 어느 함수에서 문제가 발생하는지 확인했다. (컨트롤러로 잘 들어와서 addOrUpdateObject함수를 호출하는것을 확인함)

step2. 프론트에서 request를 잘못 보낸게 아닌지 확인했다.(addOrUpdateObject함수의 request를 확인하니 변경이 필요한 값들이 잘 들어와 있었음)

step3. modifyObject함수에서 호출한 updateObject함수의 문제가 아닌지 확인했다.(Object타입의 엔티티에서 update함수가 정상적으로 작성되어 있고 변경될 값도 잘 들어오는걸 확인함)

🧐문제의 원인 파악

문제의 원인은 service클래스의 어노테이션에 있었다. DB에 직접 접근하는 함수들을 제외한 나머지 함수들에서는 읽기만 허용하기 위해 어노테이션을 걸어두었는데 해당 어노테이션 때문에 addOrUpdateObject 함수도 읽기 권한만 적용이 된 것이었다.

@Transactional(readOnly = true)

그렇다면 왜 modifyObject함수에는 @Transactional 어노테이션을 붙였는데도 위와 같은 오류가 난 것일까?

@Transactional의 전파 속성 @Transactional 어노테이션에는 여러 옵션들이 있습니다. 그 중에서도 propagation 옵션은 트랜잭션 전파 속성을 설정하는데 사용됩니다. 이 속성은 메서드가 이미 실행 중인 트랜잭션과 어떻게 상호작용하는지를 결정합니다. @Transactional 어노테이션의 propagation 속성 기본값은 Propagation.REQUIRED입니다. 이것은 "현재 실행 중인 트랜잭션이 있으면 해당 트랜잭션을 사용하고, 없다면 새로운 트랜잭션을 시작한다"는 것을 의미합니다. 따라서 @Transactional 어노테이션을 사용하고 아무런 설정을 하지 않으면, 메서드가 이미 다른 트랜잭션 내에서 호출되는 경우에는 해당 트랜잭션을 사용하게 됩니다.

즉, @Transactional(readOnly = true)를 서비스 클래스나 메서드에 설정하면 해당 트랜잭션은 읽기 전용으로 설정되어 데이터베이스의 변경 작업을 수행하지 않는 것을 나타낸다. 따라서 읽기 작업만 허용되고, 쓰기 작업(데이터 변경)은 허용되지 않는다.

나는 클래스레벨에서 선언을 했기 때문에 _서비스 클래스의 모든 메서드에 해당 속성이 전파_된 것이다. 따라서 데이터를 수정하려는 시도가 있더라도 해당 트랜잭션은 읽기 전용으로 설정되었기 때문에 데이터 변경 작업이 허용되지 않았던 것이다. 이로 인해 modifyObject 메서드에서의 데이터 변경 작업도 허용되지 않게 되었던 것이다.

🤗해결 방법

@Transactional(readOnly = true)를 사용하고 있는 상황에서 modifyObject 메서드가 수정 작업이 필요하다면, @Transactional(readOnly = true) 옵션을 제거하거나, 해당 메서드 내에서 새로운 트랜잭션을 시작하도록 설정하여 쓰기 작업을 수행하도록 변경해야 한다. 나는 클래스 레벨의 어노테이션은 유지한채로 modifyObject의 경우에만 쓰기 작업을 허용하고 싶었기 때문에 새로운 어노테이션을 추가하기로 했다.

서비스 클래스에 있는 @Transactional(readOnly = true)는 클래스 내의 모든 메서드에 해당 트랜잭션 속성을 적용하는 것이지만, 메서드에 별도의 @Transactional 어노테이션을 추가하면 그 메서드에 대해서는 해당 @Transactional 어노테이션의 설정이 우선시 된다. 따라서 checkObject 메서드에 별도의 @Transactional 어노테이션을 추가하면 해당 메서드에 대한 트랜잭션 속성이 @Transactional(readOnly = true)를 덮어씌우게 된다. 그렇기 때문에 checkObject 메서드 내에서는 새로운 트랜잭션이 생성되고, 그 트랜잭션의 전파 속성은 @Transactional 어노테이션에 설정한대로 동작하게 된다.

해결된 코드)

//service
@Transactional
public void addOrUpdateObject(ObjectRequest request){
    if(request.getId() == null)
        addObject(request);
    else
        modifyObject(request.getId(),request);
}

@Transactional
public void modifyObject(long objectId, ObjectRequest request){
    Object obj = objectRepositsory.findById(objectId).orElseThrow(() -> new NoSuchElementException("존재하지 않는 오브젝트입니다.");
    obj.updateObject(request);
}

람다식이란?

메서드를 하나의 식으로 표현한 것.

→ 메서드의 이름과 반환값이 없어짐 = 익명함수

→ 클래스나 객체 생성 없이 메서드의 역할 수행 가능.

→ 메서드의 매개변수 및 결과로 반환 가능 = 메서드를 변수처럼 다루는 것

→ 매개변수의 반환 타입이 추론 가능한 경우 생략

→ 선언된 매개변수가 한개인 경우 괄호 생략

(단, 매개변수 타입이 있으면 괄호 생략 불가)

→ {중괄호} 안의 문장이 하나인 경우 생략 가능. (이때 문장의 끝에 ‘;’ 붙이지 않음)

(단, {괄호}안의 문장이 return 문일 경우 생략 불가)

int max(int a, int b){
return a>b ? a:b;}

(int a, int b) -> {return a>b ? a:b;}
(int a, int b) -> a>b? a:b
(a,b) -> a>b? a:b

2. 함수형 인터페이스

람다식을 다루기 위한 인터페이스를 함수형 인터페이스라고 함.

@FunctionalInterface
interface Myfunction{
    public abstract int max(int a, int b);
}

→ 오직 하나의 추상 메서드만 정의되어야 함 (그래야 람다식과 인터페이스가의 메서드가 1:1로 연결)

→ 반면, static과 default 메서드의 개수에는 제약이 없음

 @FunctionalInterface
interface MyFunction {
    void run();  // public abstract void run();
}

class LambdaEx1 {
    static void execute(MyFunction f) { // 매개변수의 타입이 MyFunction인 메서드
        f.run();
    }

    static MyFunction getMyFunction() { // 반환 타입이 MyFunction인 메서드 
        MyFunction f = () -> System.out.println("f3.run()");
        return f;
    }

    public static void main(String[] args) {
        // 람다식으로 MyFunction의 run()을 구현
        MyFunction f1 = ()-> System.out.println("f1.run()");

        MyFunction f2 = new MyFunction() {  // 익명클래스로 run()을 구현
            public void run() {   // public을 반드시 붙여야 함
                System.out.println("f2.run()");
            }
        };

        MyFunction f3 = getMyFunction();

        f1.run();
        f2.run();
        f3.run();

        execute(f1);
        execute( ()-> System.out.println("run()") );
    }
}

-함수형 인터페이스로 람다식을 참조하는 것이지 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아님. (람다식은 익명 객체이고 익명 객체는 컴파일러가 임의로 이름을 정하기 때문에 타입을 알 수 없음.)

→ 대입 연산자의 양변의 타입을 일치시키기 위해 형변환이 필요

→ 람다식은 Object 타입으로 형변환 불가. 오직 함수형 인터페이스로만 형변환 가능.

java.util.function패키지의 주요 함수형 인터페이스

3. Variable Capture

람다식의 실행 블록 내에서 람다식을 감싸고 있는 클래스의 인스턴스 변수, 스태틱 변수, 지역 변수에 접근하는 것이 가능

→ 그러나 지역 변수에 접근할 때는 Variable Capture라는 특별한 작업이 수행되기 때문에 한 가지 제약이 생김

= Variable Capture란 객체 외부에서 선언된 변수를 객체 내부로 복사하는 행위. ****지역 변수 뿐만 아니라 파라미터로 전달된 변수 또한 외부에서 선언된 변수이므로 같은 규칙이 적용

public class CaseOne {

    static int staticVariable = 10;

    int instanceVariable;

    @FunctionalInterface
    interface MyFunction {

        void myMethod();
    }

    public static void main(String[] args) {

        CaseOne caseOne = new CaseOne();
        caseOne.instanceVariable = 20;

        int localVariable = 30;

        MyFunction myFunction = () -> {
            System.out.println("static variable = " + CaseOne.staticVariable);
            System.out.println("instance variable = " + caseOne.instanceVariable);
            System.out.println("local variable = " + localVariable);
        };

        myFunction.myMethod();
    }

}

실행결과
static variable = 10
instance variable = 20
local variable = 30

스태틱 변수나 인스턴스 변수를 변경하는 것은 문제가 없으나, 지역변수를 변경하는 순간 오류가 발생

⇒ 오류가 발생하는 이유는 클래스 내부에 선언된 로컬 클래스(여기선 람다식)가 지역 변수를 참조할 때는 그 값을 복사해서 사용하기 때문(=Variable Capture)

public class CaseOne {

    static int staticVariable = 10;

    int instanceVariable;

    @FunctionalInterface
    interface MyFunction {

        void myMethod();
    }

    public static void main(String[] args) {

        CaseOne caseOne = new CaseOne();
        caseOne.instanceVariable = 20;

        int localVariable = 30;

        // 값 변경
        CaseOne.staticVariable += 5;
        caseOne.instanceVariable += 5;
        localVariable += 5;

        MyFunction myFunction = () -> {
            System.out.println("static variable = " + CaseOne.staticVariable);
            System.out.println("instance variable = " + caseOne.instanceVariable);
            System.out.println("local variable = " + localVariable);    // 컴파일 오류 발생!
        };

        myFunction.myMethod();
    }
}

4. 메소드, 생성자 레퍼런스

1) 메서드 참조

람다식이 하나의 메서드만 호출하는 경우에는 메서드 참조를 통해 간략히 할 수 있음

Function<String , Integer> f = (String s) -> Integer.parseInt(s);

Function<String , Integer> f = Integer::parseInt;

“클래스이름::메서드이름” 혹은 ”참조변수:메서드이름”으로 바꿀 수 있음

2)생성자의 메서드 참조

제네릭이란?

다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시의 타입체크를 해주는 기능.

→ 객체 타입을 컴파일 시에 체크하기 때문에 타입 안정성을 높이고 형변환 생략을 통해 간결한 코드 가능

class Box<T>             //제네릭 타입 T를 선언
{
    T item;
    void setItem(T item){ this. item = item;}
    T getItem(){ return item;}
}

Box<String> b = new Box<String>(); //타입 T대신 실제 타입을 지정

→ T를 type variable 이라고 하며 다른 글자로 대체 가능.

(e.g. ArrayList의 경우 element의 약자 E 사용.

Map<K,V> - Key, Value)

제네릭 클래스의 객체 생성

참조변수와 생성자에 대입된 타입(매개변수화된 타입)이 일치해야 함

e.g. Box appleBox = new Box();

Box appleBox = new Box<>(); // 추정 가능한 경우 타입 생략 가능

Box appleBox = new FruitBox(); // 상속관계

import java.util.ArrayList;

class Fruit                  { public String toString() { return "Fruit";}}
class Apple extends Fruit { public String toString() { return "Apple";}}
class Grape extends Fruit { public String toString() { return "Grape";}}
class Toy                  { public String toString() { return "Toy"  ;}}

class FruitBoxEx1 {
    public static void main(String[] args) {
        Box<Fruit> fruitBox = new Box<Fruit>();
        Box<Apple> appleBox = new Box<Apple>();
        Box<Toy>   toyBox   = new Box<Toy>();
//        Box<Grape> grapeBox = new Box<Apple>(); // 에러. 타입 불일치

        fruitBox.add(new Fruit());
        fruitBox.add(new Apple()); // OK. void add(Fruit item)

        appleBox.add(new Apple());
        appleBox.add(new Apple());
//        appleBox.add(new Toy()); // 에러. Box<Apple>에는 Apple만 담을 수 있음

        toyBox.add(new Toy());
//        toyBox.add(new Apple()); // 에러. Box<Toy>에는 Apple을 담을 수 없음

        System.out.println(fruitBox);
        System.out.println(appleBox);
        System.out.println(toyBox);
    }  // main의 끝
}

class Box<T> {
    ArrayList<T> list = new ArrayList<T>();
    void add(T item)  { list.add(item); }
    T get(int i)      { return list.get(i); }
    int size() { return list.size(); }
    public String toString() { return list.toString();}
}

2. 제네릭 주요 개념 (바운디드 타입, 와일드 카드)

제네릭스 용어

1) 제네릭스의 제한

제네릭 클래스 Box의 객체를 생성할 때, 객체별로 다른 타입을 지정하는 것은 가능

(= 인스턴스 별로 다르게 동작하도록 만든 기능이므로)

Box<Apple> appleBox = new Box<Apple>(); // apple객체만 저장 가능
Box<Grape> grapeBox = new Box<Grape>(); // grape객체만 저장 가능

→ 그러나, static멤버에 타입 변수 T 사용 불가

(T는 인스턴스변수로 간주되기 때문에 모든 객체에 대해 동일하게 동작해야하는 static 멤버는 인스턴스 변수를 참조할 수 없음.

⇒ static 멤버는 타입 변수에 지정도니 타입, 즉 대입된 타입의 종류에 관계없이 동일한 것이어야 함)

→ 제네릭 배열 타입의 참조변수 선언은 가능하나, 제네릭 타입의 배열을 생성하는 것은 불가.

class Box<T>{
T[] itemArr; // (o) T타입의 배열을 위한 참조변수 

T[] toArray(){
    T[] tmpArr = new T[itemArr.length]; // (x) 제네릭 배열 생성 불가

→ new 연산자는 컴파일 시점에 타입 T가 뭔지 알아야함. 그러나 위의 코드에서는 컴파일 시점에 T가 어떤 타입이 될지 알 수 없음. (instance of 역시 마찬가지)

→ 따라서, new 연산자 대신 Reflection API의 newInstance()메서드 혹은 Object 배열을 생성 후 형변환 하는 방법 사용

제네릭 타입에 extends 활용하면 특정 타입의 자손들만 대입하도록 제한 가능

import java.util.ArrayList;

class Fruit implements Eatable {
    public String toString() { return "Fruit";}
}
class Apple extends Fruit { public String toString() { return "Apple";}}
class Grape extends Fruit { public String toString() { return "Grape";}}
class Toy                  { public String toString() { return "Toy"  ;}}

interface Eatable {}

class FruitBoxEx2 {
    public static void main(String[] args) {
        FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
        FruitBox<Apple> appleBox = new FruitBox<Apple>();
        FruitBox<Grape> grapeBox = new FruitBox<Grape>();
//        FruitBox<Grape> grapeBox = new FruitBox<Apple>(); // 에러. 타입 불일치
//        FruitBox<Toy>   toyBox    = new FruitBox<Toy>();   // 에러.

        fruitBox.add(new Fruit());
        fruitBox.add(new Apple());
        fruitBox.add(new Grape());
        appleBox.add(new Apple());
//        appleBox.add(new Grape());  // 에러. Grape는 Apple의 자손이 아님
        grapeBox.add(new Grape());

        System.out.println("fruitBox-"+fruitBox);
        System.out.println("appleBox-"+appleBox);
        System.out.println("grapeBox-"+grapeBox);
    }  // main
}

class FruitBox<T extends Fruit & Eatable> extends Box<T> {}

class Box<T> {
    ArrayList<T> list = new ArrayList<T>();
    void add(T item)  { list.add(item);      }
    T get(int i)      { return list.get(i); }
    int size()        { return list.size();  }
    public String toString() { return list.toString();}
}

2) 와일드 카드

여러가지 타입의 매개변수를 갖는 제네릭 타입을 만들때 제네릭 타입이 다른 것만으로는 오버로딩이 성립하지 않기때문에 고안된 방법

?로 표시하며 어떤 타입도 될 수 있음

import java.util.ArrayList;

class Fruit                  { public String toString() { return "Fruit";}}
class Apple extends Fruit { public String toString() { return "Apple";}}
class Grape extends Fruit { public String toString() { return "Grape";}}

class Juice {
    String name;

    Juice(String name)         { this.name = name + "Juice"; }
    public String toString() { return name;         }
}

class Juicer {
    static Juice makeJuice(FruitBox<? extends Fruit> box) {
        String tmp = "";

        for(Fruit f : box.getList()) 
            tmp += f + " ";
        return new Juice(tmp);
    }
}

class FruitBoxEx3 {
    public static void main(String[] args) {
        FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
        FruitBox<Apple> appleBox = new FruitBox<Apple>();

        fruitBox.add(new Apple());
        fruitBox.add(new Grape());
        appleBox.add(new Apple());
        appleBox.add(new Apple());

        System.out.println(Juicer.makeJuice(fruitBox));
        System.out.println(Juicer.makeJuice(appleBox));
    }  // main
}

class FruitBox<T extends Fruit> extends Box<T> {}

class Box<T> {
//class FruitBox<T extends Fruit> {
    ArrayList<T> list = new ArrayList<T>();
    void add(T item) { list.add(item);      }
    T get(int i)     { return list.get(i); }
    ArrayList<T> getList() { return list;  }
    int size()       { return list.size(); }
    public String toString() { return list.toString();}
}

3. 제네릭 메소드 만들기

메서드의 선언부에 제네릭 타입이 선언된 메서드

→ 제네릭 메서드 호출 시 대입된 타입을 생략할 수 없는 경우에는 참조변수나 클래스 이름을 생략 할 수 없음.

static <T extends Fruit> Juice makeJuice(FruitBox <T> box)
{
    String tmp ="";
    for(Fruit F : box.getList())
        tmp += f + "";
    return new Juice(tmp);
}

    FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
    FruitBox<Apple> appleBox = new FruitBox<Apple>();

    System.out.println(Juicer.<Fruit>makeJuice(fruitBox));//메서드 호출시 타입변수에 타입 대입
    System.out.println(Juicer.<Apple>makeJuice(appleBox));

    System.out.println(Juicer.makeJuice(fruitBox));// 대입된 타입 생략 가능
    System.out.println(Juicer.makeJuice(appleBox));

    System.out.println(makeJuice(fruitBox));//에러. 클래스 이름 생략 불가

4. Erasure

1. 제네릭 타입의 경계를 제거한다.

class Box<T extends Fruit> 
{
    void add(T t)
        {...}
}

👇

class Box {
    void add (Fruit t) 
        { ... }
}

1. 제네릭 타입을 제거한 후에 타입이 일치하지 않으면, 형변환을 추가한다.

입출력이란?

IO = Input과 Output의 약자

컴퓨터 내부 또는 외부의 장치와 프로그램간의 데이터를 주고받는것

1) 스트림

데이터를 운반하는데 사용되는 연결통로

단방향 통신만 가능. = 하나의 스트림으로 입력과 출력을 동시에 처리할 수 없음.

큐와 같은 구조(선입선출)

2)버퍼

보조스트림은 실제 데이터를 주고받는 스트림이 아니기 때문에 데이터를 입출력할 수 있는 기능은 없으나 스트림의 기능을 향상시키거나 새로운 기능 추가 가능.

→ 따라서 스트림을 먼저 생성한 다음에 보조스트림 생성해야함

→모든 보조 스트림 역시 InputStream 과 OutputStream의 자손임

3)채널

데이터가 통과하는 쌍방향 통로

→ 채널에서 데이터를 주고 받을 때 사용 되는 것이 버퍼

→ 채널에는 소켓과 연결된 SocketChannel, 파일과 연결된 FileChannel, 파이프와 연결된 Pipe.SinkChannel 과 Pipe.SourceChannel 등이 존재하며, 서버소켓과 연결된 ServerSocketChannel 도 존재

2. InputStream과 OutputStream

스트림은 바이트단위로 데이터를 전송

java.io패키지를 통해 입출력 관련 클래스 제공

메서드를 통해서 데이터를 읽고 쓸 수 있음

e.g. int read(byte[]b, int off, int len) , void write(byte[]b, int off, int len)

= 입력스트림으로부터 len개의 byte를 읽어서 byte배열 b의 off위치부터 저장

( 추상클래스를(abstract class InputStream) 상속받아서 추상메서드를(abstract int read) 구현한 클래스의 인스턴스에 대해서 추상메서드가 호출되는 것이기 때문에 read()는 반드시 구현되어야하는 핵심적인 메서드임. 따라서 read()없이 int read(byte[]b, int off, int len)는 사용 불가.)

1)InputStream

• 바이트 기반 입력 스트림의 최상위 추상 클래스
• 모든 바이트 기반 입력 스트림은 이 클래스를 상속 받아서 만들어 짐
• 버퍼, 파일, 네트워크 단에서 입력되는 데이터를 읽어오는 기능을 수행

1)OutputStream

• 바이트 기반 출력 스트림의 최상위 추상 클래스
• 모든 바이트 기반 출력 스트림은 이 클래스를 상속 받아서 만들어 짐
• 버퍼, 파일, 네트워크 단으로 데이터를 내보내는 기능을 수행

3. Byte와 Character 스트림

Byte기반 스트림: 입출력의 단위가 1byte임.

(자바에서는 한 문자를 의미하는 char형이 1 byte가 아니라 2 byte이기 때문에 바이트기반의 스트림으로 2byte인 문자를 처리하는 데는 어려움이 있음. 이를 보완하기 위해 문자 기반의 스트림이 제공됨.)

InputStream → Reader

OutputStream → Writer

1) Byte Stream

• binary 데이터를 입출력하는 스트림

• 데이터는 1바이트 단위로 처리

• 이미지, 동영상 등을 송수신 할 때 주로 사용

  

2) Character Stream

• text 데이터를 입출력하는 스트림

• 데이터는 2바이트 단위로 처리

• 일반적인 텍스트 및 JSON, HTML 등을 송수신할 때 주로 사용

  

4. 표준 스트림 (System.in, System.out, System.err)

애너테이션에 대한 기본 정보가 javadoc으로 작성한 문서에 포함되도록함.

표준 입출력 스트림의 종류는 java.lang 패키지의 System 클래스 내부에 static 으로 선언되어 있음

public final class System {
  public static final InputStream in;
  public static final PrintStream out;
  public static final PrintStream err;
  ....
}

→ System.out 은 콘솔 화면에 문자열을 출력하기 위한 용도로 사용되는 출력 스트림이다.

→ System.in 은 키보드의 입력을 받아들이기 위해서 사용되는 입력 스트림이다.

cf. System.out 과 System.err

둘다 출력 스트림

→ err 은 버퍼링을 지원하지 않음. (err 이 보다 정확하고 빠르게 출력되어야 하기 때문) 버퍼링을 하던 도중 프로그램이 멈추면 버퍼링된 내용은 출력되지 않기 때문

5. 파일 읽고 쓰기

애노테이션 프로세서는 소스코드 레벨에서 소스코드에 붙어있음.

→ 텍스트 파일인 경우 문자 스트림 클래스들을 사용하면 되고, 바이너리 파일인 경우 바이트 스트림을 기본적으로 사용한다.

→ 입출력 효율을 위해 Buffered 계열의 보조 스트림을 함께 사용하는 것이 좋음.

• 텍스트 파일인 경우

    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    String s;
    while ((s = br.readLine()) != null) {
      bw.write(s + "\n");
    }

• 이진 파일인 경우

    BufferedInputStream is = new BufferedInputStream(new FileInputStream("a.jpg"));
    BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream("b.jpg"));
    byte[] buffer = new byte[16384];
    while (is.read(buffer) != -1) {
      os.write(buffer);
    }

애노테이션이란?

프로그램의 소스코드 안에 다른 프로그램을 위한 정보를 미리 약속된 형식으로 포함시킨것.

자바는 소스코드와 문서를 하나의 파일로 관리. 따라서 주석에 소스코드에 대한 정보를 저장하고 소스코드의 주석으로부터 HTML문서를 생성해내는 javadoc.exe를 사용.

(=미리 정의된 태그들을 이용해서 주석안에 정보를 저장하고 javadoc.exe 프로그램이 이 정보를 읽어서 문서를 작성)

<애너테이션 요소의 규칙>

• 요소의 타입은 기본형, String, enum, 어노테이션, Class만 허용됨.

• ()안에 매개변수는 선언할 수 없음.

• 예외를 선언할 수는 없음.

• 요소를 타입 매개변수로 정의 할 수 없음.

<표준 애노테이션>

메타 애너테이션

-애너테이션을 위한 애너테이션 = 애너테이션에 붙이는 애너테이션으로 애너테이션을 정의할 때 적용대상이나 유지기간등을 지정하는데 사용.

-java.lang.annotation 패키지에 포함되어 있음

2. @retention

애너테이션이 유지되는 기간을 지정하는데 사용

<애너테이션 유지정책의 종류>

@Override, @SuppressWarnings (컴파일러가 사용하는 애너테이션) ⇒ SOURCE

@FunctionalInterface(컴파일러 확인, 실행시 유지) ⇒ RUNTIME

3. @target

애너테이션이 적용가능한 대상을 지정하는데 사용.

→ 여러개의 값을 지정할 경우 배열을 사용.

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})

<@Target 애너테이션 적용대상의 종류>

4. @documented

애너테이션에 대한 기본 정보가 javadoc으로 작성한 문서에 포함되도록함.

@Override, @SuppressWarnings 제외한 나머지는 모두 해당 메타 애너테이션이 붙어있음.

5. 애노테이션 프로세서

(참고 강의 : www.inflearn.com/course/the-java-code-manipulation/dashboard 인프런 - 더 자바, 코드를 조작하는 다양한 방법)

https://www.notion.so/37d183f38389426d9700453f00253532

애노테이션 프로세서

애노테이션 프로세서는 소스코드 레벨에서 소스코드에 붙어있음.

애노테이션을 읽어서 컴파일러가 컴파일 하는 중에 새로은 소스코드를 생성하거나 기존 소스코드를 바꿀 수 있음.

또는, 클래스(바이트코드) 도 생성할 수 있고 별개의 리소스파일을 생성할 수 있는 강력한 기능.

애노테이션 프로세서 사용 예

• 롬복 (기존코드를 변경한다)
• AutoService (리소스 파일을 생성해준다.)
  • java.util.ServiceLoader 용 파일 생성 유틸리티
• @Override

애노테이션 프로세서 장점

• 바이트코드에 대한 조작은 런타임에 발생되는 조작임으로 런타임에 대한 비용이 발생
• but. 애노테이션 프로세서는 애플리케이션을 구동하는 런타임 시점이 아니라,
• 컴파일 시점에 조작하여 사용함으로 런타임에 대한 비용이 제로가 됨

단점은 기존의 코드를 고치는 방법은 현재로써는 public 한 API 가 없음.

• 롬복 같은 경우 기존 코드를 변경하는 방법이지만 public 한 api를 이용한 것이 아님으로 해킹이라고 할 수 도 있음.

롬복(Lombok)의 동작원리

Lombok

• @Getter @Setter, @Builder 등의 애노테이션과
• 애노테이션 프로세서를 제공하여 표준적으로 작성해야 할 코드를 개발자 대신 생성해주는 라이브러리이다.

사용하기

• 의존성 추가
• IntelliJ Lombok 플로그인 설치
• Intellij Annotation Processing 옵션 활성화

동작원리

• 컴파일 시점에 "애노테이션 프로세서"를 사용하여 (자바가 제공하는 애노테이션 프로세서)
• 소스코드의 AST(Abstract Syntax Tree) 를 조작한다.

열거형이란?

-JDK1.5부터 추가

-타입에 안전한 열거형: 실제 값과 타입이 일치해야 같다고 인식.(서로 다른 개념이나 동일 이름을 가진 값의 충돌을 막을 수 있음)

<정의방법>

enum 열거형이름 {상수명1, 상수명2 ...}

enum Direction {EAST, SOUTH, WEST, NORTH}

class Unit{
int x, y;
Direction dir;
void init(){
    dir = Direction.EAST;
    }
}

if (dir == Direction.EAST){
    x++;
}else if(dir.compareTo(Direction.WEST) > 0) {
...

//첫줄에 열거할 상수의 이름을 선언
//이름은 대문자로 선언하는 것이 관례
//각 상수는 콤마로 구분(제일 마지막 상수의 끝에는 세미콜론을 붙여야 하나,
//간단히 상수의 이름만 선언할 때는 세미콜론을 붙이지 않아도 됨)

-열거형의 상수간의 비교에는 ==와 compareTo 사용 가능.(단, <,>비교 연산자 사용 불가능)

자바 enum의 특징

1. enum에 정의된 상수들은 해당 enum type의 객체임.
2. 생성자와 메서드를 추가할 수 있음.(enum이 클래스이기 때문)

→ enum 생성자의 접근제어자는 private이기 때문에 외부에서 상수 추가 불가능.

→ 상수 하나당 각각의 인스턴스가 만들어지며 모두 public static final 임.

enum Currency {

    PENNY(1), NICKLE(5), DIME(10), QUARTER(25);

    private int value;

    Currency(int value) {
        this.value = value;
    }

    public int value() {
        return value;
    }
}

public class EnumDemo {

    public static void main(String[] args) {
        System.out.println(Currency.DIME.value());    // 10
    }
}

2. enum이 제공하는 메소드 (values()와 valueOf())

-values() : 열거형의 모든 상수를 배열에 담아 반환. (모든 열거형이 가지고 있는 메서드로 컴파일러가 자동으로 추가해 줌)

Direction []dArr = Direction.values();
for(DIrection d: dArr)
    System.out.printf("%s =%d%n", d.name, d.ordinal());

enum Transport {
    BUS, TAXI, SUBWAY;
}

public class EnumDemo {

    public static void main(String[] args) {
        for (var e : Transport.values()) {
            System.out.println(e.name()); // BUS, TAXI, SUBWAY반환
        }
                Transport taxi = Enum.valueOf(Transport.class, "Taxi");
            Transport bus = Transport.valueOf("BUS");
    }
}

-valueOf(enumType, String name) : 지정된 열거형에서 name과 일치하는 열거형을 반환.

3. java.lang.Enum

-모든 열거형의 조상

→모든 열거형은 Enum 클래스를 상속받기 때문에 enum type은 별도의 상속을 받을 수 없음.

<Enum 클래스에 정의된 메서드>

4. EnumSet

출처: https://www.geeksforgeeks.org/enumset-class-java/

-EnumSet은 AbstractSet 클래스를 상속하고 Set 인터페이스를 구현함.

-오직 열거형 상수만을 값으로 가질 수 있고 모든 값은 같은 enum type이어야 함.

-null value를 추가하는 것을 허용하지 않음. NullPointerException을 던지는 것도 허용하지 않음.

-ordinal 값의 순서대로 요소가 저장됨.

-tread-safe하지 않음. 동기식으로 사용하려면 Collections.synchronizedMap을 사용하거나, 외부에서 동기화를 구현해야함.

-모든 메서드는 arithmetic bitwise operation을 사용하기 때문에 모든 기본 연산의 시간 복잡도가 O(1)임.

프로세스란

-실행 중인 프로그램

-사용자가 작성한 프로그램이 운영체제에 의해 메모리 공간을 할당 받아 실행 중인 것으로 프로그램에 사용되는 데이터와 메모리 등의 자원 그리고 쓰레드로 구성.

쓰레드란?

-프로세스 내에서 실제로 작업을 수행하는 주체

-모든 프로세스에는 1개 이상의 쓰레드가 존재

-두 개 이상의 쓰레드를 가지는 프로세스를 멀티 쓰레드 프로세스

-경량 프로세스라고 불리며 가장 작은 실행 단위

쓰레드 구현의 2가지 방법(Thread 클래스 vs Runnable 인터페이스)

public class ThreadDemo {

    public static void main(String[] args) {
        // 상속으로 구현
        ThreadByInheritance thread1 = new ThreadByInheritance();

        //인터페이스로 구현
        Runnable r = new ThreadByImplement();
        Thread thread2 = new Thread(r);    //생성자: Thread(Runnable target)
        // 아래 코드로 축약 가능
        // Thread thread2 = new Thread(new ThreadByImplement());

        thread1.start();
        thread2.start();
    }
}

class ThreadByInheritance extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print(0);
        }
    }
}

class ThreadByImplement implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print(1);
        }
    }
}

⇒ Thread 클래스가 다른 클래스를 확장할 필요가 있을 경우에는 Runnable 인터페이스를 구현하면 되며, 그렇지 않은 경우는 Thread 클래스를 사용하는 것이 좋음.

⇒ 쓰레드를 생성했다고 자동을 실행되지 않음. start()를 호출해야만 쓰레드가 실행됨.

⇒ start()가 호출되어도 바로 실행되는 것이 아니라, 실행대기 상태에 있다가 자신의 차례가 되어야 실행됨.

⇒ 쓰레드의 실행 순서는 OS의 스케쥴러가 작성한 스케쥴에 의해 결정됨.

⇒ 한 번 실행이 종료된 쓰레드는 다시 실행할 수 없음 (하나의 쓰레드에 start()가 한 번만 호출될 수 있음.)

⇒ 쓰레드를 start로 호출 시 자신만의 스택을 만들어서 사용.

2. 쓰레드의 상태

sleep(long millis)

:지정된 시간 동안 쓰레드를 멈춤.

→ static 메서드임. (자기 자신만 재울 수 있음. )

→반드시 try-catch 블록으로 예외처리를 해줘야함.

public class ThreadDemo {

    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadEx_1());
        Thread t2 = new Thread(new ThreadEx_2());

        t1.start();
        t2.start();

        try {
            Thread.sleep(2000);          // t1이 아닌 실행중인 자기자신 Thread여야함
        } catch (InterruptedException e) { }

        System.out.print("<메인 쓰레드 종료>");
    }

}

class ThreadEx_1 implements Runnable {

    @Override
    public void run() {
        System.out.print("<t1 시작>");
        for (int i = 0; i < 100; i++) {
            System.out.print("-");
        }
        System.out.print("<t1 종료>");
    }
}

class ThreadEx_2 implements Runnable {

    @Override
    public void run() {
        System.out.print("<t2 시작>");
        for (int i = 0; i < 100; i++) {
            System.out.print("|");
        }
        System.out.print("<t2 종료>");

    }
}

interrupt()

:쓰레드에게 작업을 멈추라고 요청. (강제 종료는 아님.)

→interrupted()는 쓰레드에 대해 interrupt()가 호출되었는지 알려줌.

(호출되지 않았다면 false, 호출 되었다면 true 반환)

→쓰레드가 sleep(), wait(), join()에 의해 일시정지(waiting) 상태에 있을 때, 해당 쓰레드에 대해 interrupt()를 호출하면sleep(), wait(), join()에서 Interrupted Exception이 발생하고 쓰레드는 실행대기(Runnable) 상태로 바뀜.즉, 멈춰있던 쓰레드를 깨워서 실행가능한 상태로 만드는 것.

void interrupt()                //  쓰레드의 interrupted 상태를 false에서 true로 바꾼다
boolean isInterrupted()         //  쓰레드의 interrupted 상태를 반환한다
static boolean interrupted()    //  쓰레드의 interrupted 상태를 반환하고, false로 초기화한다

public class ThreadDemo {

    public static void main(String[] args) {
        ThreadEx_1 t1 = new ThreadEx_1();

        t1.start();

        String input = JOptionPane.showInputDialog("게임을 다시 진행하시겠습니까? [Y/N]");
        System.out.println(input);
        t1.interrupt();
    }

}

class ThreadEx_1 extends Thread {

    @Override
    public void run() {
        int i = 10;

        while (i != 0 && !isInterrupted()) {
                    try {
                        System.out.println(i--);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        interrupt();
                    }
}
}

suspend(), resume(), stop()

: stop은 쓰레드를 완전히 종료시키는 메서드

suspend는 쓰레드를 일시정지 상태로 만드는 메서드

resume은 정지상태의 쓰레드를 다시 실행 대기 상태로 만드는 메서드

→이 세 개의 메서드는 교착상태(deadlock)를 일으킬 가능성이 있어서 deprecated되었음. 따라서 사용하지 않는 것이 권장됨.

join()

:join 메서드는 일정 시간 동안 특정 쓰레드가 작업하는 것을 기다리게 만드는 메서드.

→sleep과 마찬가지로 try-catch 블록으로 예외처리를 해야 함.

ublic class ThreadDemo {

    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadEx_1());
        Thread t2 = new Thread(new ThreadEx_2());

        long startTime = System.currentTimeMillis();

        t1.start();
        t2.start();

        try {
            t1.join();    // t1의 작업이 끝날 때까지 기다린다.
            t2.join();    // t2의 작업이 끝날 때까지 기다린다.

        } catch (InterruptedException e) {}

        System.out.println("소요시간 : " + (System.currentTimeMillis() - startTime));
        // 메인쓰레드가 종료된다.
    }

}

class ThreadEx_1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print("-");
        }

    }
}

class ThreadEx_2 implements Runnable {

    boolean suspended = false;
    boolean stopped = false;

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.print("|");
        }
    }
}

yield()

: 자신에게 할당된 시간이 남았더라도 다음 쓰레드에게 작업을 넘기도록 하는 메서드

→static 메서드이므로 자기 자신에게만 사용할 수 있음.

→ 쓰레드가 busy-waiting 상태(작업할 내용이 없는데 작업 시간이 할당되어 쓰레드가 돌아가는 상태) 일 때 yield를 호출하도록 설계하면 프로그램의 응답성과 효율을 높일 수 있음.

3. 쓰레드의 우선순위

각 쓰레드는 우선순위(priority)에 관한 자신만의 필드를 가지고 있으며 이러한 우선순위에 따라 특정 쓰레드가 더 많은 시간 동안 작업을 할 수 있도록 설정

!https://blog.kakaocdn.net/dn/MFHjS/btqTPzhtqy7/bqJqzVIKyMB1XUGf0xZvZ1/img.png

-getPriority()와 setPrioritiy()메소드를 통해 쓰레드의 우선순위를 반환하거나 변경 가능.

-쓰레드의 우선순위가 가질 수 있는 범위는 1부터 10까지이며, 숫자가 높을수록 우선순위 또한 높아짐

-BUT, 쓰레드의 우선순위는 비례적인 절댓값이 아닌 어디까지나 상대적인 값

(=우선순위가 10인 쓰레드가 우선순위가 1인 쓰레드보다 10배 더 빨리 수행되는 것이 아님. 단지 우선순위가 10인 쓰레드는 우선순위가 1인 쓰레드 보다 좀 더 많이 실행 큐에 포함되어, 좀 더 많은 작업 시간을 할당받는 것.)

4. Main 쓰레드

-main 메서드도 하나의 쓰레드 = 메인 쓰레드(Main Thread)

-메인 쓰레드는 프로그램이 시작하면 가장 먼저 실행되는 쓰레드이며, 모든 쓰레드는 메인 쓰레드로부터 생성됨.

-다른 쓰레드를 생성해서 실행하지 않으면, 메인 메서드, 즉 메인 쓰레드가 종료되는 순간 프로그램도 종료됨. (여러 쓰레드를 실행하면, 메인 쓰레드가 종료되어도 다른 쓰레드가 작업을 마칠 때까지 프로그램이 종료되지 않음.)

-쓰레드는 '사용자 쓰레드(user thread)'와 '데몬 쓰레드(daemon thread)'로 구분되는데,실행 중인 사용자 쓰레드가 하나도 없을 때 프로그램이 종료됨.

cf. Daemon Thread

-Main 쓰레드의 작업을 돕는 보조적인 역할을 하는 쓰레드

-Main 쓰레드가 종료되면 데몬 쓰레드는 강제적으로 자동 종료.(어디까지나 Main 쓰레드의 보조 역할을 수행하기 때문에 , Main 쓰레드가 없어지면 의미가 없어지기 때문)

-Main 쓰레드가 Daemon 이 될 쓰레드의 setDaemon(true)를 호출해주면 Daemon 쓰레드가 됨.

public class DaemonThread extends Thread{
    public void run() {
        try {
            Thread.sleep(Long.MAX_VALUE);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
public void runCommonThread() {
    DaemonThread thread = new DaemonThread();
    thread.start();
}
--------------------------------------------------------------------
public void runDaemonThread() {
    DaemonThread thread = new DaemonThread();
    thread.setDaemon(true);
    thread.start();
}

5. 동기화

동기화란?

어떤 쓰레드가 진행 중인 작업을 다른 쓰레드가 간섭하지 못하도록 하는 작업.

멀티 쓰레드 프로세스에서는 여러 프로세스가 메모리를 공유하기 때문에, 한 쓰레드가 작업하던 부분을 다른 쓰레드가 간섭하는 문제가 생길 수 있음.

따라서 다른 쓰레드가 간섭해서는 안 되는 부분을 임계 영역(critical section)으로 설정해야함.

→임계 영역 설정은 synchronized 키워드를 사용

1) 메서드 전체를 임계영역으로 설정

public synchronized void method1 () { ...... }

→ 쓰레드는 synchronized 키워드가 붙은 메서드가 호출된 시점부터 해당 메서드가 포함된 객체의 lock을 얻어 작업을 수행하다가 메서드가 종료되면 lock을 반환

2) 특정한 영역을 임계영역으로 설정

synchronized(객체의 참조변수) {......}

→이 영역으로 들어가면서부터 쓰레드는 지정된 객체의 lock을 얻게 되고 블록을 벗어나면 lock을 반납.(단, 이때 참조 변수는 락을 걸고자 하는 객체를 참조하는 것이어야 함)

lock이란?

일종의 자물쇠 개념으로 모든 객체는 lock을 하나씩 가지고 있음.

해당 객체의 lock을 가지고 있는 쓰레드만 임계 영역의 코드를 수행할 수 있으며 한 객체의 lock은 하나밖에 없기 때문에 다른 쓰레드들은 lock을 얻을 때까지 기다리게 됨.

public class ThreadDemo {

    public static void main(String[] args) {
        Runnable r = new ThreadEx_1();
        new Thread(r).start();
        new Thread(r).start();
    }
}

class Account {
    private int balance = 1000; //잔고

    public int getBalance() {
        return balance;
    }

    public void withdraw(int money) {
        synchronized (this) {
            if (balance >= money) {
                try {
                    // 문제 상황을 만들기 위해 고의로 쓰레드를 일시정지
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }

                balance -= money;
            }
        }
    }
}

class ThreadEx_1 implements Runnable {

    Account account = new Account();

    @Override
    public void run() {
        while (account.getBalance() > 0) {
            // 100, 200, 300 중 임의의 값을 선택해서 출금
            int money = (int) (Math.random() * 3 + 1) * 100;
            account.withdraw(money);
            System.out.println("balance: " + account.getBalance());
        }
    }
}

wait() & notify()

class Account {
    private int balance = 1000;

    public synchronized void withdraw(int money) {
        //잔고가 출금액보다 적어 인출을 할 수 없다.
        while (balance < money) {
            try {
                // 해당 객체의 락을 풀고 waiting pool에서 대기
                wait();
            } catch (InterruptedException e) {}
        }
        balance -= money;
    }

    public synchronized void deposit(int money) {
        // 돈을 입금하고 waiting pool의 쓰레드에 통보 
        balance += money;
        notify();
    }
}

6. 데드락

데드락이란?

한 자원을 여러 시스템이 사용하려고 할 때 발생할 수 있는 교착상태

서로 원하는 리소스가 상대방에게 할당되어 있기 때문에 두 프로세스는 무한히 대기 상태에 있게됨.

<데드락 발생 조건>

1. 상호 배제(Mutual exclusion)

   • 자원은 한 번에 한 프로세스만이 사용할 수 있어야 한다.

2. 점유 대기(Hold and wait)

   • 최소한 하나의 자원을 점유하고 있으면서 다른 프로세스에 할당되어 사용하고 있는 자원을 추가로 점유하기 위해 대기하는 프로세스가 있어야 한다.

3. 비선점(No preemption)

   • 다른 프로세스에 할당된 자원은 사용이 끝날 때까지 강제로 빼앗을 수 없어야 한다.

4. 순환 대기(Circular wait)

   • 프로세스의 집합{P0, P1, ,…Pn}에서P0는P1이 점유한 자원을 대기하고P1은P2가 점유한 자원을 대기하고P2…Pn-1은Pn이 점유한 자원을 대기하며Pn은P0가 점유한 자원을 요구해야 한다.

     ⇒ 4가지 조건이 모두 성립할때만 데드락 발생. 하나라도 성립하지 않으면 교착 상태 해결 가능.

     (출처:https://jwprogramming.tistory.com/12[개발자를 꿈꾸는 프로그래머])

에러의 종류

-컴파일 에러: 컴파일 시에 발생하는 에러

-런타임 에러: 실행 시에 발생하는 에러

-논리적 에러: 실행은 되지만 의도와 다르게 동작

1. try-catch문

try {
//예외 발생 가능성 있는 문장들
} catch (Exception e1)
{
// Exception e1이 발생했을 경우 처리할 문장
} catch (Exception2 e2)
{
// Exception e1이 발생했을 경우 처리할 문장
} catch (ExceptionN eN)
{
// Exception e1이 발생했을 경우 처리할 문장
}

// try 블럭이나 catch 블럭에서는 문장이 한줄이어도 괄호 생략 불가.

//try 블럭이나 catch 블럭 내에 또다른 try-catch 구문 사용 가능.

// 발생한 예외와 일치하는 catch 블럭으로 이동해서 문장 수행하고 try-catch구문 빠져나가서
//그 다음 문장 수행. 일치하는 catch 가 없다면 예외 처리 이루어지지 않음.

// try-catch 마지막에 exception클래스 타입의 참조변수를 선언한 catch 블럭 만들면
// 어떤 종류의 예외가 발생하더라도 해당 catch 문으로 처리가능

cf. printStackTrace(): 예외 발생 당시의 호출스택에 있던 메서드의 정보와 예외 메세지를 화면에 출력.

getMessage: 발생한 예외 클래스의 인스턴스에 저장된 메세지를 얻을 수 있음.

1. throw/ throws문

메서드에 예외 선언하려면 메서드 선언부에 키워드 throws 사용해서 발생 가능한 예외를 , 기준으로 나열.

void method() throws Exception1, Exception2, Exception3{
//메서드 내용
} 

보통 반드시 처리해야하는 예외의 경우 나열(RuntimeException클래스들은 보통 적지 않음)

자신을 호출한 메서드에게 예외를 전달하여 떠맡기는 형식으로 전달받은 메서드가 또다시 넘길 수 있음

이런식으로 계속 호출스택에 있는 메서드들 따라서 전달되다가 마지막에는 main에서 try-catch 문으로 예외처리해주어야 정상적으로 종료 가능.

1. finally 블럭

try-catch 문과 함께 예외의 발생 여부에 상관없이 실행되어야할 코드를 포함시킬 목적으로 사용.

try {
//예외 발생 가능성 있는 문장들
} catch (Exception e1)
{
// Exception e1이 발생했을 경우 처리할 문장
} finally{
//예외 밟생 여부에 관계없이 수행되어야하는 문장
}

try블럭 혹은 catch블럭에서 예외가 발생하거나 return하는 경우에도 finally 블럭에 있는 문장들을 시행시키고 프로그램 종료됨.

2. 자바가 제공하는 예외 계층 구조

출처: 자바의 정석 3판 415p

→ 모든 예외의 최고 조상은 exception클래스

출처: 자바의 정석 3판 415p

→ Exception 클래스들: 사용자의 실수와 같은 외적 요인에 의해 발생하는 예외

e.g. FileNotFoundException : 존재하지 않는 파일의 이름 입력

ClassNotFoundException: 클래스 이름 잘못 입력

DataFormatException: 입력한 데이터 형식의 오류

→Runtime Exception클래스들: 프로그래머의 실수

e.g. IndexOutOfBoundException: 배열의 범위를 멋어남

NullPointerException: 값이 null인 참조변수의 멤버를 호출

ClassCastException: 클래스간의 형변환 오류

ArthimeticException: 정수를 0으로 나누려함

3. Exception과 Error의 차이는?

에러(error) vs 예외(exception)

-에러: 메모리 부족이나 스택오버플로우와 같은 코드로 수습 불가능한 심각한 오류

-예외: 프로그램 코드로 수습될 수 있는 다소 미약한 오류

4. RuntimeException과 RE가 아닌 것의 차이는?

RE란?

말 그대로 실행 중에 발생하며 시스템 환경적으로나 인풋 값이 잘못된 경우, 혹은 의도적으로 프로그래머가 잡아내기 위한 조건등에 부합할 때 발생

→RuntimeException을 상속받지 않고 Exception을 상속받는 모든 Exception은 Checked Exception

unchecked예외: 컴파일러가 예외처리를 확인하지 않는 RuntimeException클래스들

checked예외: 예외처리를 확인하는 클래스들

5. 커스텀한 예외 만드는 방법

class MyException extends Exception{
        MyException(String msg) {
            super(msg); // 조상인 Exception 클래스의 생성자 호출
        }
}

→ 보통 예외 처리 강제하지 않는 uncheked를 선호함.

인터페이스란?

일종의 추상클래스이나 추상클래스보다 추상화 정도가 높아서 오직 추상메서드와 상수만을 멤버로 가질 수 있음. (일반 메서드나 멤버변수 등 어떠한 요소도 허용되지 않음)

interface 인터페이스이름{
    public static final 타입 상수이름 = 값;
    public abstract 메서드이름(매개변수목록);
}

→ 모든 멤버변수는 public static final 이어야하며 생략 가능.

→모든 메서드는 public abstract 이어야하며 생략 가능.

(단, JDK1.8부터 static 메서드와 디폴트 메서드는 예외)

cf. 인터페이스의 이름

: 주로 able로 끝나는 경우가 많음

= 어떠한 기능 또는 행위를 하는데 필요한 메서드를 제공한다는 의미를 강조하기 위해. 또한 해당 인터페이스를 구현한 클래스는 ~를 할 수 있는 능력을 갖추었다는 의미.

2. 인터페이스 구현하는 방법

인터페이스 자체로는 인스턴스 생성 불가.

추상클래스와 마찬가지로 정의된 추상메서드의 몸통을 만들어주는 클래스 작성.

extends가 아닌 implements 사용(구현한다는 의미)

class 클래스이름 implements 인터페이스이름{}

class Fighter implements Fightable{
    public void move(int x, int y){ .....}
    public void attack(Unit u) {.....}
}

→ 인터페이스 메서드 중 일부만 구현한다면 abstract 붙여서 추상클래스로 선언.

→ 상속과 구현 동시에 가능

e.g. class Fighter extends Unit implements Fightable{}

3. 인터페이스 레퍼런스를 통해 구현체를 사용하는 방법

⇒ 인터페이스를 이용한 다형성

인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조 가능.

인터페이스 타입으로 형변환도 가능

Fightable f = (Fightable) new Fighter();
// fightable 타입의 참조변수로는 인터페이스 fightable에 정의된 멤버들만 호출 가능.

→ 인터페이스 타입의 매개변수는 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공.

class Fighter extends Unit implements Fightable {
    public void move(int x, int y)
    public void attack(Fightable f)
}
//attack 메서드 호출 시 매개변수로 fightable 인터페이스를 구현한 클래스의 인스턴스를 넘겨주어야함
//fightable을 구현한 fighter 클래스가 있을때 attack메서드의 매개변수로 fighter인스턴스 넘김
= attack(new Fighter())

Fightable method()
{
        Fighter f = new Fighter();
        return f;
}
// 메서드의 리턴타입으로 인터페이스의 타입 지정 가능.
// 리턴타입이 인터페이스 = 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스 반환

4. 인터페이스 상속

인터페이스는 인터페이스로부터만 상속 가능.

→ 클래스와 달리 다중 상속 가능. Object클래스처럼 최고 조상 없음.

interface Movable{
    void move(int x, int y);
}

interface Attackable{
    void attack(Unit u);
}

interface Fightable extends Movable, Attackable{}

5.인터페이스의 기본 메소드 (Default Method), 자바 8

디폴트 메서드란?

추상 메서드의 기본적인 구현을 제공하는 메서드로, 추상 메서드가 아니기 때문에 디폴트 메서드가 추가되어도 해당 인터페이스를 구현한 클래스 변경하지 않아도 됨.

→JDK1.8부터 인터페이스에 디폴트메서드와 static 메서드 추가 가능.

→ 추상메서드와 달리 일반 메서드처럼 몸통이 있어야함.

→ public 접근제어자

interface MyInterface{
    void method();
    public void newMethod(){}
}

** 새로 추가된 디폴트 메서드와 기존 메서드의 이름 중복 충돌 해결 규칙

1. 여러 인터페이스의 디폴트 메서드간 충돌

   → 인터페이스를 구현한 클래스에서 디폴트 메서드를 오버라이딩

2. 디폴트 메서드와 조상 클래스의 메서드 간의 충돌

   → 조상 클래스의 메서드가 상속되고 디폴트 메서드는 무시.

6.인터페이스의 static 메소드, 자바 8

인스턴스 생성하지 않고 사용가능한 메서드

https://www.notion.so/4b0cf3f6ff7549adb2951e27519fc0e6

7. 인터페이스의 private 메소드, 자바 9

특정 기능을 처리하는 내부 메서드의 경우 다른 인터페이스 혹은 클래스가 해당 메서드에 엑세스 하지 않도록 하기 위해 사용. (캡슐화 개념)

<private 메서드 구현 규칙>

• private 메소드는 구현부를 가져야함
• 오직 인터페이스 내부에서만 사용 가능
• private static 메소드는 다른 static 또는 static이 아닌 메소드에서 사용할 수 있음
• static이 아닌 private 메소드는 다른 private static 메소드에서 사용할 수 없음

Q. 모놀리식 구조와 MSA의 차이는 무엇인가?

A. 모놀리식(Monolithic) 아키텍처와 마이크로서비스(Microservices) 아키텍처는 소프트웨어 시스템을 설계하고 구축하는 두 가지 주요 접근 방식

1. 아키텍처 구조:

• 모놀리식(Monolithic): 모놀리식 아키텍처는 하나의 큰 코드베이스로 이루어져 있습니다. 애플리케이션의 모든 구성 요소(데이터베이스, 사용자 인터페이스, 비즈니스 로직 등)가 단일한 코드베이스에 통합되어 있습니다.
• 마이크로서비스(Microservices): 마이크로서비스 아키텍처는 여러 작은 서비스로 구성되어 있습니다. 각 서비스는 자체의 독립적인 코드베이스와 데이터베이스를 가지며, 서로 통신하여 전체 애플리케이션을 형성합니다.

2. 커뮤니케이션과 통합:

• 모놀리식: 애플리케이션의 모든 부분이 같은 코드베이스에 있으므로, 컴포넌트 간의 통합이 비교적 간단합니다. 하지만 큰 규모의 애플리케이션에서는 모든 부분을 이해하고 유지보수하기 어려울 수 있습니다.
• 마이크로서비스: 각 마이크로서비스는 독립적으로 배포되고 업데이트될 수 있으므로, 서비스 간의 커뮤니케이션과 통합이 중요한 과제가 됩니다. API를 통한 외부 통신이 일반적이며, 이를 통해 각 서비스는 독립적으로 개발, 배포, 확장될 수 있습니다.

3.배포 및 확장성:

• 모놀리식: 전체 애플리케이션을 한 번에 배포해야 하며, 특정 부분만 확장하기가 어려울 수 있습니다. 확장성이 부족할 수 있습니다.
• 마이크로서비스: 각 서비스는 독립적으로 배포 가능하며, 필요한 서비스만 확장할 수 있습니다. 이로 인해 전체 시스템이 더 효율적으로 확장될 수 있습니다.

4. 유지보수 및 확장성:

• 모놀리식: 작은 프로젝트나 초기 단계에서는 유지보수가 쉬울 수 있지만, 시간이 지남에 따라 코드베이스가 커지면 유지보수가 어려워질 수 있습니다.
• 마이크로서비스: 각 서비스가 독립적으로 개발되고 관리되기 때문에 유지보수가 상대적으로 쉽습니다. 또한, 새로운 서비스를 추가하거나 기존 서비스를 변경하기가 용이합니다.

이러한 차이로 인해 모놀리식 아키텍처는 간단한 애플리케이션 및 초기 단계의 프로젝트에 적합할 수 있으며, 마이크로서비스 아키텍처는 대규모 및 복잡한 시스템을 구축하고 유지보수하는 데 더 적합할 수 있습니다. 선택은 프로젝트의 규모, 요구 사항, 팀의 기술적 선호도 등에 따라 다를 수 있습니다.

모놀리식 구조의 예시

/my-monolith-app
|-- /src
|   |-- /components
|   |-- /services
|   |-- /utils
|   |-- /...
|-- /public
|-- package.json
|-- webpack.config.js
|-- ...

MSA 구조의 예시

/msa-project
|-- /service1
|   |-- /src
|   |   |-- /components
|   |   |-- /models
|   |   |-- /routes
|   |   |-- /tests
|   |   |-- ...
|   |-- package.json
|   |-- Dockerfile
|   |-- ...
|-- /service2
|   |-- /src
|   |   |-- /components
|   |   |-- /models
|   |   |-- /routes
|   |   |-- /tests
|   |   |-- ...
|   |-- package.json
|   |-- Dockerfile
|   |-- ...
|-- /service3
|   |-- /src
|   |   |-- /components
|   |   |-- /models
|   |   |-- /routes
|   |   |-- /tests
|   |   |-- ...
|   |-- package.json
|   |-- Dockerfile
|   |-- ...
|-- /common
|   |-- /src
|   |   |-- /constants
|   |   |-- /helpers
|   |   |-- /utils
|   |   |-- ...
|   |-- package.json
|   |-- ...
|-- /gateway
|   |-- /src
|   |   |-- /routes
|   |   |-- /middlewares
|   |   |-- ...
|   |-- package.json
|   |-- Dockerfile
|   |-- ...
|-- docker-compose.yml
|-- ...

Q. 동기/비동기란 무엇인가?

A. 동기(Synchronous)와 비동기(Asynchronous)는 프로그램이 작업을 수행하는 방식에 관한 용어입니다. 프로미스(Promise)는 비동기 코드를 더 효과적으로 다루기 위한 자바스크립트의 패턴 중 하나입니다.

1. 동기(Synchronous):

동기적인 코드는 한 번에 하나의 작업만 수행하며, 다음 작업은 이전 작업이 완료될 때까지 기다립니다. 코드는 위에서 아래로 순차적으로 실행되며, 각 작업이 끝나기 전까지 다음 작업으로 진행하지 않습니다.

console.log("Start");

function synchronousTask() {
  console.log("Task 1");
  console.log("Task 2");
}

synchronousTask();

console.log("End");

//출력
Start
Task 1
Task 2
End

2. 비동기(Asynchronous):

비동기적인 코드는 작업을 기다리지 않고 다음 코드를 실행합니다. 이때, 비동기 작업은 별도의 실행 컨텍스트에서 백그라운드에서 수행됩니다. 주로 콜백 함수, 이벤트 핸들러, 프로미스 등을 사용하여 비동기 작업을 다룹니다.

console.log("Start");

function asynchronousTask() {
  setTimeout(function () {
    console.log("Async Task");
  }, 2000);
}

asynchronousTask();

console.log("End");

//출력
Start
End
Async Task  // 2초 후에 출력

3. 프로미스(Promise):

프로미스는 비동기 작업을 더 편리하게 다루기 위한 객체입니다. 성공 또는 실패와 같은 비동기 작업의 최종 완료 또는 실패를 나타내는 객체로, 비동기 작업이 완료되면 resolve 또는 reject 콜백 중 하나가 호출됩니다.

console.log("Start");

function promiseTask() {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve("Promise Task");
    }, 2000);
  });
}

promiseTask().then(function (result) {
  console.log(result);
});

console.log("End");

//출력
Start
End
Promise Task  // 2초 후에 출력