멀티프로젝트 01

스프링부트는 스프링프레임워크를 기반으로 스프링프레임워크를 편하게 사용하기 위해 만들어 졌다.

Spirng Framework는 이미 설계된 구조 안에 프로그램머가 이에 맞게 객체를 만들어 넣어주어야 한다.

Spirng Framework는 가벼운? 컨테이너로 프로그래머가 만들어 놓은 자바 객체를 직접 관리한다.

즉 객체의 생성 및 소멸 그리고 라이프 사이클을 관리하는데 이는 Spirng이 IOC 기반의 Framework임을 의미합니다.

IOC는 Inversion of Control의 약자로 말 그대로 제어의 역전입니다. 그럼 제어의 역전이란 무엇일까요?

일반적으로 지금까지 프로그램은 객체 생성 -> 의존성 객체 생성 -> 객채 내의 메소드 호출 하는 작업을 반복했습니다.

이는 각 객체들이 프로그램의 흐름을 결정하고 각 객체를 구성하는 작업에 프로그래머가 관여를 한다.

기존에는 모든 작업을 프로그래머가 제어하는 구조인 것입니다.

하지만 IOC에서는 제어권한을 프레임워크에 의해 관리되며 프레임워크의 특별한 객체에 의해 제어된다.

즉, IOC에서는 객체의 라이프 싸이클을 프로그래머가 컨트롤 하지 않고 프레임워크에 모든 것을 맡기는 것입니다.

3. DI (Dependency Injection)와 DL (Dependency Lookup) <- Spring의 의존성 관리 메커니즘

Spring Framework는 주로 DI 방식을 통해 IoC를 구현하고, DL은 제한적으로 사용됩니다.

컨테이너에서는 객체들을 관리하기 위해 별도의 저장소에 자바-빈을 저장하는데

개발자들이 컨테이너에서 제공하는 API 를 이용하여 사용하고자 하는 빈 을 검색하는 방법입니다.

의존성 주입이란 객체가 서로 의존하는 관계가 되게 의존성을 주입하는 것입니다. 객체지향 프로그램에서 의존성 이란 하나의 객체가

IOC에서 각 클래스 사이에 필요로 하는 의존관계를 bean-설정 정보를 바탕으로 컨테이너가 자동으로 연결해 주는 것입니다.

외부에서 필요한 의존성을 주입받아 컨테이너가 자동으로 연결하여 사용하도록 합니다.

POJO(Plain Old Java Object) 란 말 그대로 평범한 기존 자바 오브젝트입니다.

이전 EJB(Enterprise JavaBeans)는 확장 가능한 재사용이 가능한 로직을 개발하기 위해 자바-빈을 작성을 할 때

EJB(Enterprise JavaBeans)에서 제공하는 클래스를 확장하여 복잡한 객체를 만들어야 했다.

그러나 스프링 프레임워크는 gettet/setter를 가진 단순 자바 오브젝트(POJO)로 정의를 하여 사용합니다.

이러한 단순 오브젝트는 의존성이 없고 추후 테스트 및 유지보수가 편리한 유연성의 장점을 가집니다.

이러한 장점들로 인해 객체지향적인 다양한 설계와 구현이 가능해지고 POJO의 기반의 Framework가 조명을 받고 있습니다.

OOP는 객체지향 원칙에 따라 관심사가 같은 데이터를 한곳에 모아 분리하고 낮은 결합도를 갖게하여 독립적이고 유연한 모듈로 캡슐화를 하는 것을 일컫습니다.

하지만 이러한 과정 중 중복된 코드들이 많아지고 가독성, 확장성, 유지보수성을 떨어 뜨립니다. 이러한 문제를 보완하기 위해 나온 것이 AOP입니다.

관점 지향 프로그래밍입니다. 객체 지향 프로그래밍(OOP)의 단점을 보완하고자 나온 개념이다.

AOP에서는 핵심로직과 공통로직을 분리시켜 핵심 로직에 영향을 끼치지 않게 공통기능을 끼워 넣는 개발 형태이다.

이렇게 개발함에 따라 무분별하게 중복되는 코드를 한 곳에 모아 중복 되는 코드를 제거 할 수 있어지고 공통기능을 한 곳에 보관함으로써

공통 기능 하나의 수정으로 모든 핵심기능들의 공통기능을 수정 할 수 있어 효율적인 유지보수가 가능하며 재활용성이 극대화됩니다.

물론 AOP로 만들 수 있는 기능은 OOP로 구현 할 수 있는 기능이지만

    Spring에서는 AOP를 편리하게 사용 할 수 있도록 이를 지원하고 있습니다.

(1) 횡단 관심사 (Cross-cutting concerns): 로깅, 보안, 트랜잭션 관리 등 여러 모듈에 걸쳐 반복적으로 나타나는 기능을 말합니다.

이러한 기능은 비즈니스 로직과는 별도로 관리하는 것이 효율적입니다.

(2) 어드바이스 (Advice): 횡단 관심사를 실제로 구현하는 코드입니다. 언제 실행될지를 정의합니다.

Around advice: 메소드 실행 전후 또는 실행을 대체하여 실행됩니다.

(3) 조인포인트 (Join point): 어드바이스가 적용될 수 있는 지점(위치)을 말합니다. 메소드 호출이나 예외 발생 등이 조인포인트가 될 수 있습니다.

(4) 포인트컷 (Pointcut): 어드바이스(Advice)를 어떤 Join Point에 적용할지를 정의하는 표현식입니다. 즉, 어드바이스가 적용될 구체적인 위치를 지정하는 역할을 합니다.

(5) 애스펙트 (Aspect): 어드바이스와 포인트컷을 결합한 모듈로, 횡단 관심사를 구현한 것입니다.

(예) LoggingAspect라는 Aspect를 정의하고, 특정 패키지의 모든 메소드 실행 전에 로깅을 수행하도록 설정하고 있습니다.

AOP는 코드의 횡단 관심사를 효과적으로 관리하고, 프로그램의 모듈화를 촉진하는 강력한 도구로,

특히 복잡한 엔터프라이즈 애플리케이션 개발에서 큰 이점을 제공합니다.

@Aspect
public class LoggingAspect {

   @Before("execution(* com.example.service.*.*(..))")  //<--  @Before에 설정된 표현식은 Pointcut 표현식입니다.
                                             // com.example.service 패키지 아래의 모든 메서드 호출 전에 이 어드바이스가 실행됩니다. 
   public void logBefore(JoinPoint joinPoint) {
       System.out.println("Method Called: " + joinPoint.getSignature().getName());
   }
}

Spring MVC 요청 처리 흐름

@Controller
public class HomeController {

   
  @GetMapping("/home")
   public String home(Model model) {
     model.addAttribute("message", "Hello, Spring MVC!");
     return "home";  // 뷰 이름 반환 (home.jsp 또는 home.html)
   }
}

프론트엔드에 리액트를 사용하는 경우, 기존 스프링 프레임워크의 MVC 모델에 약간의 변화가 있을 수 있지만, 전체적인 아키텍처는 유지됩니다.

주요 변화는 주로 프론트엔드와 백엔드 간의 통신 방식 및 뷰 렌더링 방식에서 발생합니다.

전통적인 스프링 MVC에서는 서버 사이드 렌더링(SSR)을 사용하여 JSP, Thymeleaf 등의 템플릿 엔진을 통해 뷰를 생성합니다.

리액트를 사용하는 경우, 클라이언트 사이드 렌더링(CSR)을 통해 뷰를 생성합니다. 따라서, 스프링은 주로 REST API를 제공하는 역할을 하게 됩니다.

리액트 애플리케이션은 주로 AJAX 요청(axios)을 통해 백엔드와 통신합니다. 이를 위해 스프링에서는 RESTful 웹 서비스(API)를 제공합니다.

리액트 애플리케이션은 보통 Webpack, Babel 등의 도구를 사용하여 빌드됩니다.

스프링 부트와 통합할 때는 npm 스크립트를 사용하여 리액트 앱을 빌드하고,

빌드된 파일을 스프링 부트의 정적 리소스 디렉토리(src/main/resources/static)로 복사하는 방식으로 배포합니다.

웹 서비스는 인터넷 표준과 프로토콜을 사용하여 이기종 시스템 간의 상호 운용성을 제공합니다.

주로 HTTP 프로토콜을 사용하며, XML, JSON 등의 데이터 형식을 통해 데이터를 주고받습니다.

웹 서비스(Web Service)는 네트워크를 통해 서로 다른 시스템 간에 데이터를 교환하고 기능을 공유할 수 있도록 하는 소프트웨어 시스템입니다.

웹 서비스는 HTTP/HTTPS 프로토콜을 사용하여 인터넷이나 인트라넷을 통해 애플리케이션 간의 상호 운용성을 제공합니다.

[참고] RESTful 웹 서비스란? <-- HTTP 프로토콜을 따르는 통신방식임(이론적으로는 다른 프로토콜(TCP, FTP 등)에서도 적용 가능)

RESTful 웹 서비스는 Representational State Transfer(REST) 아키텍처 스타일을 따르는 웹 서비스입니다.

REST는 자원을 URI(Uniform Resource Identifier)로 식별하고, HTTP 메소드를 통해 자원에 대한 CRUD(Create, Read, Update, Delete) 작업을 수행합니다.

서버는 각 요청을 독립적으로 처리하며, 이전 요청의 상태를 유지하지 않습니다.

RESTful 웹 서비스는 HTTP 프로토콜을 기반으로 하며, 클라이언트와 서버 간의 상호작용을 단순하고 직관적으로 만듭니다.

Spring Core는 Spring Container을 의미합니다. core라는 말 그대로 Container는 Spring Framework의 핵심이며 그중 핵심은 Bean Factory Container입니다.

그 이유는 바로 Bean Factory는 IOC패턴을 적용하여 객체 구성 부터 의존성 처리까지 모든 일을 처리하는 역할을 하고 있기 때문입니다.

Spring context는 Spring Framework의 context 정보들을 제공하는 설정 파일입니다. Spring Context에는 JNDI, EJB, Validation, Scheduiling, Internaliztaion 등

Spring AOP module은 Spring Framework에서 관점지향 프로그래밍을 할 수 있고 AOP를 적용 할수 있게 도와주는 Module입니다.

해당 AOP에 대한 내용은 위에서 설명 했기 때문에 넘어 가도록 하겠습니다.

DAO란 Data Access Object의 약자로 Database Data에 접근하는 객체입니다. Spring JDBC DAO는 추상 레이어를 지원함으로써 코딩이나 예외처리 하는

부분을 간편화 시켜 일관된 방법으로 코드를 짤 수 있게 도와줍니다.

ORM이란 Object relational mapping의 약자로 간단하게 객체와의 관계 설정을 하는 것입니다. Spring에서는 Ibatis, Hibernate, JDO 등 인기있는

Spirng에서 Web context module은 Application module에 내장되어 있고 Web기반의 응용프로그램에 대한 Context를 제공하여 일반적인

Web Application 개발에 필요한 기본적인 기능을 지원합니다. 그로인해 Jakarta Structs 와의 통합을 지원하고 있습니다.

Spring에서는 MVC에서는 Model2 구조로 Apllication을 만들 수 있도록 지원합니다. MVC (Model-View-Controller) 프레임 워크는

웹 응용 프로그램을 작성하기위한 완전한 기능을 갖춘 MVC를 구현합니다. MVC 프레임 워크는 전략 인터페이스를 통해 고급 구성 가능하며

JSP, Velocity, Tiles, iText 및 POI를 포함한 수많은 뷰 기술을 지원하고 있습니다.

JDBC(Java Database Connectivity)은 자바에서 데이터베이스에 접근하고 조작하기 위한 표준 API입니다. (MySQL, Oracle등 무관하게 사용가능하다는 의미)

JDBC는 자바 프로그램이 다양한 데이터베이스 시스템에 일관된 방식으로 연결하고 쿼리를 실행할 수 있게 해줍니다.

이를 통해 데이터베이스 독립성을 유지하면서 데이터베이스와의 상호 작용을 효율적으로 수행할 수 있습니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
  public static void main(String[] args) {
   String jdbcUrl = "jdbc:mysql://localhost:3306/mydatabase";
   String username = "root";
   String password = "password";

   try {
      // 데이터베이스 연결
      Connection connection = DriverManager.getConnection(jdbcUrl, username, password);

      // Statement 생성
      Statement statement = connection.createStatement();

      // SQL 쿼리 실행
      String sql = "SELECT * FROM users";
      ResultSet resultSet = statement.executeQuery(sql);

      // 결과 처리
      while (resultSet.next()) {
         int id = resultSet.getInt("id");
          String name = resultSet.getString("name");
          System.out.println("ID: " + id + ", Name: " + name);
      }

      // 자원 해제
      resultSet.close();
      statement.close();
      connection.close();
    } catch (SQLException e) {
       e.printStackTrace();
   }
  }
}

10. JPA(Java Persistence API) JPA는 JDBC를 추상화한 상위 계층에 위치해 있습니다.

JPA(Java Persistence API)는 자바 애플리케이션에서 객체-관계 매핑(ORM)을 통해 관계형 데이터베이스를 사용하고 관리하기 위한 표준 API입니다.

JPA는 자바 객체를 데이터베이스 테이블에 매핑하고, 데이터베이스의 데이터를 자바 객체로 변환하는 작업을 단순화합니다.

JPA를 사용하면 SQL 문을 직접 작성하지 않고도 데이터베이스 작업을 수행할 수 있으며, 객체 지향적인 방식으로 데이터베이스와 상호작용할 수 있습니다.

엔터티(Entity), 엔터티 매니저(EntityManager), 퍼시스턴스 유닛(Persistence Unit), JPQL(Java Persistence Query Language) 등의 주요 개념을 사용하여

데이터베이스 작업을 수행합니다. JPA는 객체 지향적인 접근 방식을 제공하며, 생산성 향상과 유지보수성 향상, 데이터베이스 독립성 등의 장점을 제공합니다.

JPA는 인터페이스이므로 실제 구현체가 필요합니다. JPA의 대표적인 구현체는 다음과 같습니다.

가장 널리 사용되는 JPA 구현체로, ORM(Object-Relational Mapping) 프레임워크입니다.

Hibernate는 JPA 표준을 구현하며, 풍부한 기능과 커뮤니티 지원으로 JPA 구현체 중에서 가장 많이 사용됩니다.

Eclipse 재단에서 제공하는 JPA 구현체로, Java EE의 공식 JPA 참조 구현입니다. 빠르고 안정적인 성능을 제공하며, 다양한 상용 환경에서 사용될 수 있습니다.

Apache 소프트웨어 재단에서 개발한 JPA 구현체입니다. 다른 JPA 구현체와 비슷한 기능을 제공하며, 주로 Apache와 관련된 프로젝트에서 사용됩니다.

JPA와 JDO(Java Data Objects) 표준을 모두 지원하는 구현체입니다. 다양한 데이터 저장소,

예를 들어 관계형 데이터베이스, NoSQL, 파일 시스템 등과 호환되어 유연하게 사용할 수 있습니다.

Spring Data JPA는 JPA 위에서 동작하는 추상화 레이어이다. JPA 구현체는 아니다.

JPA 기반의 데이터 액세스 계층을 단순화하고 반복적인 코드를 줄여주도록 설계되어 있다.

Spring Data JPA(Spring Data Java Persistence API)는 JPA(Java Persistence API)를 더 쉽게 사용하고 데이터 액세스 계층을 단순화하는 데 목적을 둡니다.

Spring Data JPA는 데이터베이스와의 상호 작용을 추상화하여 개발자가 데이터베이스 작업을 보다 효율적으로 수행할 수 있게 해줍니다.

데이터베이스 테이블에 매핑되는 자바 클래스입니다. 각 엔터티 클래스는 데이터베이스 테이블의 행을 나타내며, 클래스의 각 필드는 테이블의 열에 해당합니다.

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity    //<==  어노테이션(Annotations)
public class User {
    @Id
    private int id;
    private String name;

    // 기본 생성자
    public User() {}

    // 매개변수가 있는 생성자
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // getters and setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

어노테이션(Annotations)을 사용하여 위 코드가 Entity로 사용됨을 알린다.

어노테이션(Annotations)은 프레임워크가 이를 분석하고 특정 동작을 수행할 수 있도록 합니다.

Spring Framework를 포함한 다양한 자바 프레임워크는 어노테이션을 통해 다양한 기능을 자동으로 설정하고 구성합니다.

@SpringBootApplication : Spring Boot 애플리케이션의 시작 클래스에 사용됩니다.

@Configuration : 애플리케이션 컨텍스트에 대한 설정을 지정합니다.

@EnableAutoConfiguration : 클래스패스 설정과 다른 빈 설정을 기반으로 스프링 부트가 애플리케이션을 자동으로 구성합니다.

@ComponentScan: 현재 패키지 및 하위 패키지를 스캔하여 스프링 빈을 자동으로 등록합니다.

@Repository: 데이터 액세스 계층의 빈으로 지정하고 예외를 스프링 예외로 변환.

Spring Framework는 계층화된 아키텍처를 지향하며, 각 계층은 애플리케이션 내에서 서로 다른 역할과 책임을 가지고 있습니다.

이러한 계층화는 관심사의 분리(Separation of Concerns) 원칙을 따르고, 코드의 유지보수성과 확장성을 높이는 데 도움을 줍니다.

리포지토리는 엔터티를 이용하여 데이터베이스 작업을 수행하는 데 사용되는 인터페이스입니다.

Spring Data JPA는 이러한 리포지토리 인터페이스를 자동으로 구현하여 CRUD(Create, Read, Update, Delete) 작업을 쉽게 수행할 수 있게 합니다.

리포지토리는 JpaRepository 또는 CrudRepository 인터페이스를 확장하여 정의됩니다.

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface UserRepository extends JpaRepository<User, Integer> {
    // 커스텀 쿼리 메서드를 추가할 수 있습니다.
    List<User> findByName(String name);
}

Service는 비즈니스 로직을 담당하는 계층으로, Spring 애플리케이션의 구조에서 컨트롤러와 리포지토리 사이에서 중간 역할을 합니다.

Service 계층은 리포지토리를 통해 데이터베이스와 상호작용하면서, 비즈니스 로직을 수행하거나 데이터를 가공하는 역할을 합니다.

@Service
public class UserService {

   private final UserRepository userRepository;

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

   // 모든 사용자 조회
   public List<User> findAllUsers() {
      return userRepository.findAll();
   }
}

컨트롤러 클래스는 HTTP 요청을 처리하며, 서비스 클래스를 통해 비즈니스 로직을 호출합니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{name}")
    public List<User> getUsersByName(@PathVariable String name) {
        return userService.getUsersByName(name);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.saveUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable int id) {
        userService.deleteUser(id);
    }
}

13. Hibernate Hibernate는 JPA(Java Persistence API)의 대표적인 구현체입니다. JPA 표준을 따르면서도 추가적인 기능을 제공

Hibernate는 오픈 소스 프로젝트로 Java 언어로 작성된 ORM(Object-Relational Mapping) 프레임워크로, 관계형 데이터베이스와 자바 객체 간의 매핑을 지원합니다.

이를 통해 데이터베이스와의 상호작용을 쉽게 하고, SQL 쿼리를 직접 작성하지 않고도 데이터베이스 작업을 수행할 수 있습니다.

Hibernate는 JPA(Java Persistence API)의 구현체 중 하나로, JPA 표준을 따르면서도 추가적인 기능을 제공합니다.

개발자는 SQL 쿼리를 직접 작성하지 않고도 데이터베이스 작업을 수행할 수 있으며, 다양한 데이터베이스에 대한 독립성과 확장성을 제공합니다.

1차 캐시(세션 캐시)와 2차 캐시를 지원하여 데이터베이스 조회 성능을 향상시킵니다.

package com.example;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateExample {
    public static void main(String[] args) {
        // Create SessionFactory
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        // Obtain a session and open a transaction
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        // Create a new user instance
        User user = new User();
        user.setName("John Doe");
        user.setEmail("john.doe@example.com");

        // Save the user
        session.save(user);

        // Commit the transaction
        transaction.commit();

        // Close the session
        session.close();
        sessionFactory.close();
    }
}

Hibernate 외에도 MyBatis, EclipseLink, OpenJPA, Spring Data JDBC, jOOQ 등 다양한 ORM 프레임워크들이 있습니다.

각 프레임워크는 고유한 특징과 장점을 가지고 있어, 애플리케이션의 요구 사항과 개발자의 선호도에 따라 선택할 수 있습니다.

ORM 프레임워크를 선택할 때는 데이터베이스와의 상호작용 방식, 성능, 학습 곡선 등을 고려하는 것이 중요합니다.