DB의 핵심 3가지

  • 무결성 : 정확, 일관성(누가 보더라도 동일)
  • 안전성 : 고장x
  • 확장성 : scale-up 코어, 메모리 등을 확장 / scale-out 기기를 여러개
    • 크기를 키울건지 : 한 사람만 조회, 모노리식
    • 기기를 늘릴건지 : 여러 사람이 조회, stateless면 분산도 가능, CDN

관계형 DB

  • 테이블 사이에 관계를 맺어서 중복데이터 줄임
  • ↔ laterncy가 많이 소모 & 예전에는 메모리가 비싸서 주로 사용했음- 중복된 데이터를 없애고 메모리 비용을 아낌
  • 데이터 수정 시 관련된 여러 테이블을 변경해야 하기 때문에 시간이 오래 걸릴 수 있음

 

row-oriented : 읽는 양이 적은 경우, 많은 데이터 삽입에 적합

  • row뒤에 바로 row가 붙어서 삽입이 쉬움

column-oriented : 읽는 것이 빨라서 데이터 분석에 사용

  • 각 칼럼끼리 모아두는 구조 ⇒ 삽입이 많으면 부적합

 

NOSQL

- 서로 다른 종류의 데이터를 저장할 수 있고, 유연한 스키마를 가지고 있어서 데이터 구조를 동적으로 변경

  • key-value : redis
  • graph : 촌 수 같은 관계 표현하기에 유리, 한국에서는 덜 사용함
  • Document : json 데이터 넣기 좋음

 

CAP 이론

- 분산 시스템에서 일관성, 분산 저장 가능성, 가용성(항상 데이터에 접근 가능성) 중 두 가지만 선택할 수 있다는 이론

선택지

- 높은 가용성을 제공하면서 일부 일관성을 희생하는 NoSQL 데이터베이스

- 높은 일관성을 제공하면서 가용성을 희생하는 관계형 데이터베이스

'Spring > DB' 카테고리의 다른 글

[DB] 트랙잭션과 인덱스  (0) 2023.08.28
[DB] PostgreSQL과 MySQL  (0) 2023.08.08
[멋사] DB 연동  (0) 2023.04.06
DB(MySQL) & Spring 오류  (0) 2023.03.08

통합 테스트

  • 운영 환경과 가장 유사하게 동작시키기 위해서 @SpringBootTest 이용
  • @SpringBootTest 는 정의된 모든 빈 생성 → 시간 소요됨
  • @WebMvcTest요청을 처리하기 위한 빈들로 제한하여 로딩 → 상대적으로 가벼움

 

단위 테스트

  • @RunWith(MockitoJUnitRunner.class) @Mock 객체를 실행하는 동안 사용할 수 있게
  • @Mock@MockBean Spring Boot에서 제공되며, Spring context에 올라가게 됨
  • 주로 @Mock가 단위 테스트로 사용이 됨

 

<수정 전>

@SpringBootTest
@Transactional
@Rollback
class UserServiceImplTest {
    @Autowired private UserRepository userRepository;

    @Test
    public void saveUser() {
        SignupDto signupDto = SignupDto.builder()
                .email("test")
                .password("test")
                .name("test")
                .nickname("test")
                .corp(true)
                .build();

        User user = signupDto.toUser();
        User findUser = userRepository.save(user);
        Assertions.assertThat(findUser.getNickname().equals("test"));

    }
}

 

<수정 후>

@RunWith(MockitoJUnitRunner.class) // Mock 사용할 수 있게
@TestPropertySource(locations = "/application-test.properties") // 다른 db와 연결
class UserServiceImplTest {

    @MockBean // 테스트 분리 -> 단위 테스트 : 실제 동작에 관여하지 않는 빈은 필요 없음
    private UserRepository userRepository;

    @MockBean // Spring context에 올라감
    private ProfileRepository profileRepository;

    @MockBean
    private PasswordEncoder passwordEncoder;

    @InjectMocks
    private UserServiceImpl userService = new UserServiceImpl(userRepository, profileRepository, passwordEncoder);

    @DisplayName("존재하는 유저는 프로필 조회가 가능하다.")
    @Test
    public void saveUser() {

        // given
        SignupDto signupDto = SignupDto.builder()
                .email("test")
                .password("test")
                .name("test")
                .nickname("test")
                .corp(true)
                .build();

        User user = signupDto.toUser();
        User saveUser = userService.save(user);

        // when
        User findUser = userService.findProfile(saveUser.getId());

        // then
        Assertions.assertThat(findUser.getNickname().equals("test"));

    }
}

 

변경 내용

  • 통합 테스트 → 단위 테스트 : @RunWith(MockitoJUnitRunner.class) 이용
  • dependencies 추가
    • org.mockito:mockito-core:3.12.4
    • org.mockito:mockito-junit-jupiter:3.12.4
  • 사용할 service의 의존성에 의해서 @Mock 레포지토리들을 @InjectMocks 의 인자 값으로 넘김

⇒ 이에 따라 상대적으로 가벼운 test를 진행할 수 있습니다!

 

 

위의 내용은 아래의 주소에서 확인할 수 있습니다.

https://github.com/12hyeon/ApplePie_Upgrade

정렬 / Page<?> / Slice<?> 기능

  • 반환 값을 Page로 설정하면, 알아서 total 쿼리를 자동으로 날리게 됨
  • slice는 전체 데이터의 개수를 가져오지는 않고, 추가로 더 1개가 있는지 확인하게 됨
  • spring data를 통해서 반환 값을 변경하는 것만으로 slice → page 형태로 바꿀 수 있음
PageRequest pageRequest = PageRequest.of(0, 3, Sort.by(Sort.Direction.DESC, "username"));

Page<Member> page = memberRepository.findByAge(10, pageRequest);

List<Member> content = page.getContent(); //조회된 데이터
assertThat(content.size()).isEqualTo(3); //조회된 데이터 수 
assertThat(page.getTotalElements()).isEqualTo(5); //전체 데이터 수 
assertThat(page.getNumber()).isEqualTo(0); //페이지 번호 
assertThat(page.getTotalPages()).isEqualTo(2); //전체 페이지 번호 
assertThat(page.isFirst()).isTrue(); //첫번째 항목인가? 
assertThat(page.hasNext()).isTrue(); //다음 페이지가 있는가?

// api로 전송시킬 수 있는 형태로 변환
Page<MemberDto> dtoPage = page.map(m -> new MemberDto());

 

페이징 쿼리

  • total count가 데이터가 많을수록 성능이 안 나오게 됨

→ 카운트 쿼리도 복잡할 필요가 없으면, 따로 countQuery를 분리해서 성능 개선

 

벌크성 수정 쿼리

@Modifying(clearAutomatically = true)
@Query("update Member m set m.age = m.age + 1 where m.age >= :age")
int bulkAgePlus(@Param("age") int age);
  • 영속성 컨텍스트를 무시하고 바로 DB에 적용하게 됨 → 아직 1차 캐시에 반영이 안된 상태
  • → 영속성 컨텍스트를 제거 = em.flush() → em.clear() or clearAutomatically = true로 설정

 

지연로딩 → N+1 문제

  • 실제 연관 관계의 속성에 접근하지 않으면, join 쿼리를 날리지 않음

↔ fetch join : 연관된 모든 것을 가져옴

@EntityGraph(attributePaths = {"team"})
List<Member> findAll();

 

 


성능 최적화 노력

  • 정렬에 Page 사용
  • countQuery를 분리
  • 이름 수정 -> 벌크성 쿼리
  • 지연 로딩 모든 연관관계에 적용

예외 처리

Spring에서의 예외 처리는 중요한 부분 중 하나입니다. 여기에서는 Spring의 기본 예외 처리 방식과 다양한 예외 처리 방법에 대해 알아보겠습니다.

 

Spring 기본 예외 처리

Spring에서는 기본적으로 BasicErrorController가 존재하여 예외가 발생하면 /error로 에러를 전달하도록 웹 애플리케이션 서버(WAS)에서 설정되어 있습니다.

 

스프링의 다양한 예외 처리 방법

1. ResponseStatusException

public ResponseEntity<Item> getItem(@PathVariable String id) {
    try {
        return ResponseEntity.ok(productService.getItem(id));
    } catch (NoSuchElementException e) { // 명시적인 에러 처리가 필요하지 않음
        throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Item Not Found");
    }
}
  • 이점: 기본 예외를 빠르게 처리하고, 예외 클래스와 결합도를 낮출 수 있습니다.
  • 한계: 일관된 예외 처리가 어려우며, 예외 요청이 WAS까지 전달됩니다.

 

2. @ExceptionHandler

public class ItemController {

  @ExceptionHandler(NoSuchElementException.class)
  public ResponseEntity<String> handleNoSuchElementException(NoSuchElementException exception) {
    return ResponseEntity.status(HttpStatus.NOT_FOUND).body(exception.getMessage());
  }
}
  • 이점: 에러 응답을 자유롭게 다룰 수 있으며 (상태 코드, 메세지, 에러 등), 예외 처리 코드가 중복될 가능성이 있습니다.
  • 사용 방식:
    • 내부적으로 정의한 값 대신 HTTP 표준 상태 값을 사용하는 것이 클라이언트와 유지보수 측면에서 좋습니다.
    • @ExceptionHandler에 등록된 예외 클래스와 메서드의 파라미터 클래스가 일치해야 합니다.
    • 구체적인 예외 핸들러를 찾고, 없으면 부모 예외 핸들러를 찾습니다.

 

3. @RestControllerAdvice (Spring 4.3 이상)

public abstract class ResponseEntityExceptionHandler {

    protected ResponseEntity<Object> handleExceptionInternal( // 에러 메시지 반환을 위해 오버 라이딩
        Exception ex, @Nullable Object body, HttpHeaders headers, HttpStatus status, WebRequest request){

    }
}

@RestControllerAdvice // 전역 예외 처리
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler { // 추상 클래스 상속

    @ExceptionHandler(NotFoundAccountException.class)
    public ResponseEntity<?> handleNotFoundEntity(NotFoundException e) {
        final ErrorResponse errorResponse = ErrorResponse.builder()
                .code("Item Not Found")
                .message(e.getMessage()).build();

        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
    }

        // throw new RestApiException(ErrorCode.BAD_REQUEST) 에 의해서 호출
        @ExceptionHandler(RestApiException.class)
    protected ResponseEntity<ErrorResponse> handleCustomException(RestApiException ex) {
        ErrorCode errorCode = ex.getErrorCode();
        return handleExceptionInternal(errorCode);
    };
}
  • RestControllerAdvice를 사용하면 전역 예외 처리로 에러 응답을 일관성 있게 처리할 수 있으며, 응답을 JSON 형식으로 반환합니다.
  • 여러 ControllerAdvice가 있는 경우 @Order 어노테이션으로 순서를 지정할 수 있습니다.

최종적으로 RestControllerAdvice를 사용하는 것이 가장 좋은 방식임을 확인할 수 있습니다.

 


참고 자료

Spring Framework: 개념과 핵심 기능

Spring 프레임워크는 자바 어플리케이션 개발을 위한 강력한 도구로, 애플리케이션의 구조를 제공해줍니다. 이 글에서는 Spring의 핵심 컨셉과 프로그래밍 모델에 대해 알아보겠습니다.

 

프레임워크 vs 라이브러리

프레임워크와 라이브러리는 제어 흐름의 권한이 어디에 있는지에 따라 다릅니다.

  • 프레임워크: 전체적인 흐름을 가지고 있으며 사용자가 정해진 방식으로 기능을 구현합니다. 프레임워크가 공통된 부분을 관리하고, 예를 들어 구동, 메모리 관리, 이벤트 루프 등을 처리합니다. Spring, Django, Flask, Angular, Vue.js 등이 이에 해당합니다.
  • 라이브러리: 사용자가 전체 흐름을 만들며, 라이브러리를 가져와서 필요한 곳에서 사용합니다. 라이브러리는 도구(비휘발성 자원)의 집합으로, Node.js에서 npm을 통해 설치하는 모듈, Python에서 pip로 설치하는 모듈 등이 있습니다.

 

스프링 컨테이너

Spring의 핵심 컴포넌트 중 하나는 스프링 컨테이너입니다. 이 컨테이너는 설정 정보를 참고하여 어플리케이션을 구성하는 객체를 생성하고 관리합니다. 이것은 오브젝트의 생성과 생명주기를 관리합니다.

 

스프링의 프로그래밍 모델

1. IoC / DI (Inversion of Control / Dependency Injection)

Inversion of Control (제어의 역전)

  • 사용자는 스프링 컨테이너가 생성한 객체를 제공받는 입장입니다. 스프링 컨테이너는 제어의 역전을 관리하며, Bean factory가 Bean을 관리하고, 이를 상속받아 확장한 Application Context를 사용합니다.

Dependency Injection (의존성 주입)

  • 객체의 has-a 관계의 강한 결합을 풀어주는 방법으로, 자바 객체의 의존 관계를 주입하는 방법입니다. 주로 생성자 주입이 사용되며, 이를 통해 객체는 싱글톤으로 관리되어 쓰레드가 빈을 공유하여 대규모 트래픽 처리가 가능합니다.

 

2. PSA (Portable Service Abstraction)

  • PSA는 특정한 환경과 기술에 종속되지 않고 유연한 어플리케이션을 생성할 수 있도록 도와줍니다.
  • PSA의 대표적인 예시는 트랜잭션 추상화입니다. 스프링은 JDBC/Connection과 Hibernate/Transaction과 같은 트랜잭션 추상화 기술을 제공합니다.
  • PSA를 통해 서비스 추상화로 책임을 적절하게 분리하여 코드 변경이 발생할 때 수정 대상이 명확해지는 장점을 얻을 수 있습니다.

 

3. AOP (Aspect-Oriented Programming)

  • AOP는 어플리케이션의 핵심 비즈니스 로직과 부가 기능 로직(로깅, 보안, 트랜잭션 등)을 분리하여 독립적인 실행과 코드 재사용을 위한 기술입니다.
  • AOP의 주요 개념으로는 Aspect(공통 관심 사항), Advice(주 업무 실행 전, 후, 전 후), Proxy(주 업무 객체와 동일한 모양의 가짜 객체), JointPoint(특정 지점에서 주 업무 호출) 등이 있습니다.
public class CalculatorAspect implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation method) throws Throwable {
        // 보조 업무 설정
        Log log = LogFactory.getLog(this.getClass());
        log.info("시~작! ------------------------- ");

        // 주 업무(core concern) 호출 부분~!!
        Object core = method.proceed();

        log.info("끄~읕! ------------------------- ");

        return core;    
    }
}

이렇게 Spring Framework는 IoC/DI, PSA, AOP 등의 기능을 제공하여 개발자가 어플리케이션의 핵심 비즈니스 로직에 집중할 수 있도록 도와줍니다.

 


참고 자료

3장. 공통 메서드

  • equals는 필요한 경우만 정의
  • toString 재정의 : 의미 있는 값을 출력할 수 있게
  • 값의 비교는 비교자 생성자 메서드 혹은 메서드 구현으로 이용

4장. 클래스와 인터페이스

  • 기본 개념 : 클래스 ↔ 인스턴스

    • 객체 : 고유한 속성을 가진 대상
    • 클래스 : 필드와 메서드를 가진 객체 생성을 위한 설계도
    • 인스턴스 : 클래스를 통해 생성된 객체 하나하나(힙 영역에 생성됨)
  • 클래스와 멤버에 대한 접근 권한을 최소화 (public 클래스의 필드는 private)

  • 꼭 필요한 경우가 아니면 불변으로 생성 → final

  • 멤버 클래스는 되도록 static으로

  • 상속 고려한 설계 및 문서화

  • 추상 클래스 < 인터페이스 & 인터페이스는 구현하는 쪽을 생각해서 타입 정의용으로 설계 (상수x)

  • 상속보다는 컴포지션을 이용 → 상위 클래스 의존(불안정) vs Decorator 패턴 이용

    • implements(interface 상속에 사용) : 반드시 자식이 부모를 오버라이딩(재정의)

      → 인터페이스는 구현을 강제해서 객체의 같은 동작을 보장 (↔ 상속은 기능 확장)

```java
public class BaseComponent implements Component {

    @Override
    public String add() {
        return "에스프레소";
    }
}

abstract public class Decorator implements Component {
    private Component coffeeComponent;

    public Decorator(Component coffeeComponent) {
        this.coffeeComponent = coffeeComponent;
    }

    public String add() {
        return coffeeComponent.add();
    }
}

// Decorator 패턴을 통해 확장성
public class WaterDecorator extends Decorator {
    public WaterDecorator(Component coffeeComponent) {
        super(coffeeComponent);
    }

    @Override
    public String add() {
        // TODO Auto-generated method stub
        return super.add() + " + 물";
    }
}
```
  • 한 파일에 하나만 = 소스파일 하나 당 클래스 하나

참조

'Spring' 카테고리의 다른 글

[Spring 성능] Spring Data JPA  (0) 2023.09.12
[Spring] Spring 예외 처리  (0) 2023.09.12
[Spring] Spring Framework 정의와 기본 개념  (1) 2023.09.11
[Spring] JPA & ORM  (0) 2023.03.11
[Summary] 실전! 스프링 부트와 JPA 활용1  (0) 2023.03.08

2장. 객체 생성과 파괴

  • 새로운 객체 생성

    • 생성자 대신 static method는 유연성을 줌 → 바깥 인스턴스에 접근할 일이 없다면 무조건 static을 붙여서 정적 멤버 클래스로

    • 생성자에 매개변수가 많다면 빌더 이용

    • 싱글턴 보장 & 재활용 : 최초 한 번만 메모리를 할당(static) → 생성자가 private으로 객체 1개 재사용

    • private 생성자로 인스턴스화 막을 수 있음

    • 의존 객체 주입 사용 → util 클래스(static으로만 구성) 구현을 여러 가지로 사용

      → 팩토리 메서드로 주는게 좋음

    • 완료된 객체 참조는 해체 (≠ null)

    • 예외가 발생하면 제대로 종료하기 위해 try-with-resources 사용 → 암묵적으로 자원 반납

      (자바의 객체 소멸자인 finalizer, cleaner : 예측x, 위험, 불필요)

      종료할 자원 담는 객체 클래스에서 AutoCloseable 구현 후, 다 쓰고 close 메서드 호출

        public class SampleResource implements AutoCloseable {
            @Override
            public void close() throws RuntimeException {
                System.out.println("close");
            }
      
            public void hello() {
                System.out.println("hello");
            }
        }
      
        public class SampleRunner {
            public static void main(String[] args) {
                try (SampleResource resource = new SampleResource()) {
                    resource.hello(); // 리소스 사용
                } // try 블록이 끝날 때, close를 호출
            }
        }
  • 추가
    • 인스턴스화 막는 이유 : 정적 필드와 정적 메소드만으로 구성된 클래스를 만드는 경우 → 객체마다 같은 속성값을 가짐
    • 함수형 인터페이스 : “1개” 추상 메소드 가짐 (@FunctionalInterface 검증용)

참조

'Spring > Java' 카테고리의 다른 글

[JAVA] 프로그램  (0) 2023.03.10
[JAVA] 프로그래밍 언어, java  (0) 2023.03.10

트랜잭션이란

  • 정의 : 데이터베이스의 상태를 변화시키기 해서 수행하는 작업의 단위 (작업 단위 ≠ 질의어 한 문장)
  • 예시 : 게시물 등록 = 저장 + 조회 → 하나의 트랜잭션

 

  • 특징 4가지 : 원자성(모두 반영 o / 아예 반영 x) / (결과) 일관성(중간에 업데이트 되더라도 처음 참조 기준 이용) / 독립성 / 지속성(성공 시, 영구적 반영)
    • 관련 정보
      • 질의어 = sql : DDL / DML로 나뉨
      • (데이터 정의 언어 : 스키마 조작 / 데이터 조작 언어 : 레코드 조작)
      • 테이블 : 행과 열의 데이터 집합 → @Table : 엔티티와 테이블 매핑
      • 스키마 : 제약 조건(@Column), 무결성 규칙, 데이터 유형, 테이블 등 정의한 것
        • PostgreSQL : mysql db가 스키마라서 db가 다르면 물리적으로 분리되었다고 봐서 다른 db 테이블 끼리 조인 불가능
        • 오라클, mysql : 오브젝트 집합 != db와 같은 의미처럼 많이 사용
      • 무결성 : 데이터의 일관성 유지 → 적용되는 연산에 제한을 둠
        • 개체 무결성 : 기본 키로 고유한 값, 빈 값x
        • (후보 키 : 부분 집합으로 유일성, 최소성)
        • 참조 무결성 : 참조 관계 테이블 사이에 일관된 값 유지
        • 외래 키 - 참조 무결성 : 참조 대상이 존재해야 함 → 참조 객체 존재시 취소, 참조 객체까지 연산, 참조 객체 값 null → RESTRICTED:, CASCADE, SET NULL

commit : 트랜잭션이 성공적으로 종료 / rollback : 비 정상 종료로 연산된 결과 취소

 

인덱스란

  • 정의 : 추가적인 쓰기와 저장 공간을 활용해 db 테이블 검색 속도를 향상시키기 위한 자료 구조
  • → 전체적인 연산 속도 향상
  • 관리 : 항상 최신 정렬 상태 유지 필요 (DML에 따라 각 해당하는 인덱스도 반영)
  • 장점 : 조회 속도에 따른 성능 향상 (부하 감소)
  • 단점 : db의 10% 저장공간을 인덱스 관리에 사용, 잘못 사용하면 성능이 저하
  • (빈번하게 조작(x)되는 속성에 걸면 인덱스 크기 커짐)

 

  • 인덱스 구현 : 해시 테이블 & b+tree
    • 해시 테이블 : (키, 테이블) 구조로 빠른 검색에 유용 → 부등호 자주 사용되는 순차 검색에 x
    • b+tree : 리프노드만 인덱스+”데이터” 나머지는 데이터 위한 인덱스만 있어 linkedList로 연결
  • 인덱스 생성시, 어떻게 db에 저장 되는지
    • 인덱스 설정 기준 : 카디널리티(높을수록 값 중복도 높음), 선택도(한 칼럼 값으로 얼마나 여러 row가 조회), 조회 활용도, 수정 빈도
    • 테이블 당 하나의 Clustered Index만 생성 → 물리적인 데이터 정렬에 이용(일반적 PK)
    • Non Clustered Index테이블당 여러 개를 생성 → 인덱스에 의해 찾아가야함
    • 두개 이상의 필드를 조합하여 생성한 Index
  • db에서 null 의미 : 값이 존재하지 않음 (입력 되지 않은, 알 수 없는 값)

참고자료

'Spring > DB' 카테고리의 다른 글

[DB] 다양한 DB 비교  (0) 2023.10.04
[DB] PostgreSQL과 MySQL  (0) 2023.08.08
[멋사] DB 연동  (0) 2023.04.06
DB(MySQL) & Spring 오류  (0) 2023.03.08

PostgreSQL과 MySQL

 

이 2가지는 서로 적합한 분야가 다르다고 표현되곤 합니다.

 

주로 MySQL은 쉽고 빠르게 데이터베이스를 구축하여 사용할 수 있는 RDBMS으로 속도와 안정성에 중심을 두어 웹사이트와 온라인 트랜잭션(동시에 다수의 트랜잭션이 발생하는 상황)에 적합하고

PostgreSQL은 상속, 함수, 오버로딩 등 기능을 가진 객체 관계형 데이터베이스(ORDMNS)로 복잡한 쿼리와 대규모 데이터베이스를 다루는 경우에 적합합니다.

 

 

그에 따라 DB 사용 순위에서 높은 위치에 자리하고 있습니다.

https://db-engines.com/en/ranking

Mysql은 다양한 어플리케이션 중 특히 웹의 표준 구성 요소로 사용에 적합합니다.


마찬가지로 ProgreSQL은 광범위한 데이터 유형(json, bool, 열거 등)을 지원할 뿐만 아니라 객체 유형 데이터, 사용자 정의 함수 및 저장 프로시저(하나의 함수처럼 실행시키기 위한 쿼리 집합)도 지원합니다.

 

이러한 ProgreSQL가 복잡한 대량의 데이터 작업을 수행에 적합한 이유"특수 데이터베이스 상황 처리"에 유리하기 때문입니다. 테이블과 열 정보뿐만 아니라 데이터 유형, 함수, 액세스 방법 등 많은 정보를 카탈로그 기반 작업으로 확장이 가능합니다.

 


 

질문

왜 사용하였는지(비교와 함께)
: 복잡한 쿼리를 보다 높은 성능으로 이용할 수 있는 방법을 사용하는 방법을 찾다가, Mysql에 비해서 복잡한 다량의 작업에 유리한 ProgreSQL을 사용하게 됨

어떤 면에서 효과적이였는지

어떤 것이 어려웠는지


위 내용은 관련 회사에서 내린 정의를 활용해서 정리한 글 입니다.

https://www.integrate.io/ko/blog/postgresql-vs-mysql-the-critical-differences-ko/

 

PostgreSQL과 MySQL 비교: 주요 차이점

사용 사례에 더 나은 DBMS를 결정하기 위해 MySQL과 PostgreSQL을 비교합니다.

www.integrate.io

https://www.postgresql.org/docs/9.0/extend-how.html

 

How Extensibility Works

PostgreSQL is extensible because its operation is catalog-driven. If you are familiar with standard relational database systems, you know that they store information about databases, tables, columns, etc., in what are commonly known as system catalogs. (So

www.postgresql.org

 

'Spring > DB' 카테고리의 다른 글

[DB] 다양한 DB 비교  (0) 2023.10.04
[DB] 트랙잭션과 인덱스  (0) 2023.08.28
[멋사] DB 연동  (0) 2023.04.06
DB(MySQL) & Spring 오류  (0) 2023.03.08

데이터 받는 방식

  • get : query(주소 뒤)
  • post : http body 이용 → 민감한 정보를 보호해서 전달할 수 있음

 

JSON

Http Body에서는 json이라는 형식 이용

  • <key, value> 구조로, {}안에 값을 넣음
{
	"key":"value",
	"key2":[1,2],
	"key3": {"inner" :"value2" }
}

 

spring layerad 구조

  • controller : 들어온 데이터를 객체화
    • @RestController : @Controller + @ResponseBody
  • service : controller에서 받은 데이터 가공
  • repository : DB 직접 관리

 

주로 사용되는 기술 & 패턴

JPA : ORM(객체 관계 매핑) 표준

ORM : 객체와 db 관계 매핑하는 도구

mvc : model - view - controller 디자인 패턴

 

ORM 사용 이유

객체와 DB 사이 불일치 해결 → @Entity

 

Intellj - mysql 연결

community : intellj - setting -plugin - database navigator → mysql 설정

 

Domain

Wrapper 클래스 이용 : null인 경우에 오류 안나기 위해

'Spring > DB' 카테고리의 다른 글

[DB] 다양한 DB 비교  (0) 2023.10.04
[DB] 트랙잭션과 인덱스  (0) 2023.08.28
[DB] PostgreSQL과 MySQL  (0) 2023.08.08
DB(MySQL) & Spring 오류  (0) 2023.03.08

+ Recent posts