함께 주도 개발

[Spring] 클라이언트의 json 요청 값과 서버의DTO 네이밍이 다를 때

nohriter — Thu, 8 Sep 2022 11:01:47 +0900

API를 설계하다 보면 서버에서 요청 값으로 설계한 Request DTO의 네이밍과 클라이언트 쪽에서 요청하는 Json 네이밍이 간혹 다른 경우가 발생합니다. 이런 경우에 Json 데이터를 DTO 객체에 매핑하는 과정에서 key값이 일치하지 않아 매핑되지 않는 문제가 발생하게 되는데요. 이때 @JsonProperty, @JsonNaming 어노테이션을 사용하면 문제를 해결할 수 있습니다.

@JsonProperty

아래는 서버에서는 카멜케이스를 사용하지만 클라이언트 쪽에서는 언더바를 이용하여 요청을 한 코드이다.

//Json 요청 예시
{ 
    "post_name": "nori",
    "post_content": "zzang",
    "category": "FREE"
}

@Data
public class WriteRequest {

    @JsonProperty("post_name") // Json으로 요청된 값
    private String postName;

    @JsonProperty("post_content") // Json으로 요청된 값
    private String postContent;

    private String category;

}

위 처럼 변경하고자 하는 필드에 각각 @JsonProperty를 붙여주면 된다.

그런데 만약 필드가 30개 이상 된다면 유지보수에도 어렵고, 코드 가독성에도 좋지 않다.

이럴 때 사용하는 것이 @JsonNaming이다.

@JsonNaming

//Json 요청 예시
{ 
    "post_name": "nori",
    "post_content": "zzang",
    "category": "FREE"
}

@Data
@JsonNaming(value = PropertyNamingStrategy.SnakeCaseStrategy.class)
public class WriteRequest {

    private String postName;

    private String postContent;

    private String category;

}

@JsonNaming 어노테이션을 클래스단에 붙여주고, 사용하고자 하는 전략을 명시해주면 모든 필드에 적용이 가능하다.

참고

https://cbw1030.tistory.com/315

[Java] 8.인터페이스

nohriter — Wed, 7 Sep 2022 09:00:07 +0900

자바의 인터페이스에 대해 알아보겠습니다.

1. 인터페이스

인터페이스는 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메소드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 일반 메서드 또는 멤버 변수를 가질 수 없다. 오직 추상메소드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않는다. 추상클래스가 미완성 설계도라면, 인터페이스는 밑그림만 그려져 있는 기본 설계도라 할 수 있다. 인터페이스도 추상클래스처럼 완성되지 않은 불완전한 것이기 때문에 그 자체만으로 사용되기보다는 다른 클래스를 작성하는데 도움 줄 목적으로 작성된다.

기존에는 인터페이스에 일반 메소드를 구현할 수 없었지만, 자바 8 버전부터 default 예약어를 통해 일반 메서드 구현이 가능하다.

2. 인터페이스 정의하는 방법

인터페이스를 작성하는 것은 클래스를 작성하는 것과 같다. 다만 키워드로 class 대신 Interface를 사용한다는 것만 다르다. 그리고 interface에도 클래스처럼 접근제어자로 public 또는 default만 사용할 수 있다.

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

제약사항

1. 모든 멤버변수는 public static final 이어야 하며, 이를 생략할 수 있다.

2. 모든 메서드는 public abstract 이어야 하며, 이를 생략할 수 있다. (단, jdk.1.8부터 static 메서드와 default 메서드는 예외)

인터페이스에 정의된 모든 멤버에 예외없이 적용되는 사항이기 때문에 제어자를 생략할 수 있는 것이며, 생략된 제어자는 컴파일 시에 컴파일러가 자동적으로 추가해준다.

interface PlayingCard {
    public static final int SPADE = 4;
    final int DIAMOND = 3;	// public static final int DIAMOND = 3;
    static int HEART = 2;	// public static final int CLOVER = 2;
    int CLOVER = 1;			// public static final int CLOVER = 1;

    public abstract String getCardNumber();
    String getCardKind() 	// public abstract String getCardKind();
}

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

인터페이스도 추상클래스처럼 그 자체로는 인스턴스를 생성할 수 없으며, 추상클래스가 상속을 통해 추상메서드를 완성하는 것처럼, 인터페이스도 자신에 정의된 추상메서드의 몸통을 만들어주는 클래스 클래스를 작성해야 하는데, 그 방법은 추상클래스가 자신을 상속받는 클래스를 정의하는 것과 다르지 않다. 다만 클래스는 확장한다는 의미의 키워드 'extends'를 사용하지만 인터페이스는 구현한다는 의미의 키워드 'implements'를 사용한다.

class 클래스이름 implements 인터페이스이름 {
    // 인터페이스에 정의된 추상메서드를 모두 구현해야 한다.
}

class Fither implements Fightable {
    public void move(int x, int y) { /* 내용 생략 */ }
    public void attack(Unit u) { /* 내용 생략 */ }    
}

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

다형성을 공부하면 자손클래스의 인스턴스를 부모 타입의 참조 변수로 참조하는 것이 가능하다는 것을 알 수 있다.

인터페이스도 이를 구현한 클래스의 부모라 할 수 있으므로 해당 인터페이스 타입의 참조 변수로 클래스의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로 형변환도 가능하다.

public interface Animal {
    void sound();
}

public class Dog implements Animal {
 
    @Override
    public void sound() {
        System.out.println("멍멍");
    }
 
    public void sleep() {
        System.out.println("쿨쿨 Zzz");
    }
}

public class Lion implements Animal {
 
    @Override
    public void sound() {
        System.out.println("크아앙");
    }
 
    public void hunting() {
        System.out.println("사냥을 합니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal lion = new Lion();
 
        dog.sound();
        lion.sound();
 
      //  dog.sleep();     compile error 
      //  lion.hunting();  compile error 
      
      ((Dog)dog).sleep(); 	  // O
      ((Lion)lion).hunting();     // O
    }
}

dog은 Animal 인터페이스 타입이기 때문에 dog.sleep() 메서드는 호출하지 못하므로, Dog 클래스로 캐스팅하여 사용해야 한다.

4. 인터페이스 상속

인터페이스는 인터페이스로부터만 상속받을 수 있으며, 클래스와 달리 다중상속, 즉 여러 개의 인터페이스로부터 상속을 받는 것이 가능하다.

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

interface Attackable {
	void attack(Unit u);
}

interface Fightable extends Movable, AttackeAble {...}

클래스 상속과 마찬가지로 자손 인터페이스(Fightable)은 조상 인터페이스(Moveable, Attacable)에 정의된 멤버를 모두 상속받는다.

그래서 Fightable 자체에는 정의된 멤버가 하나도 없지만 조상 인터페이스로부터 상속받은 두 개의 추상메서드를 멤버로 갖게 된다.

인터페이스는 클래스와 달리 Object클래스와 같은 최고 조상이 없다.

5. 인터페이스의 default 메서드와 static 메서드

default 메서드

이전에는 인터페이스에 추상 메서드만 선언할 수 있었는데, JDK 1.8부터 default 메서드와 static 메서드를 추가할 수 있게 되었다.

조상 클래스에 새로운 메서드를 추가하는 것은 별 일이 아니지만, 인터페이스의 경우에는 보통 큰일이 아니다. 인터페이스에 새로운 메서드를 추가한다는 것은, 추상 메서드를 추가한다는 것이고, 이 인터페이스를 구현한 기존의 모든 클래스들이 새로 추가된 메서드를 구현해야 하기 때문이다.

인터페이스가 변경되지 않으면 제일 좋겠지만, 아무리 설계를 잘해도 언젠가 변경은 발생하기 마련이다.

JDK의 설계자들은 고심 끝에 default 메서드라는 것을 고안해 내었다.

default 메서드는 추상메서드의 기본적인 구현을 제공하는 메서드로, 추상 메서드가 아니기 때문에 default 메서드가 새로 추가되어도 해당 인터페이스를 구현한 클래스를 변경하지 않아도 된다. default 메서드는 앞에 키워드 "default"를 붙이며, 추상메서드와 달리 일반 메서드처럼 몸통{}이 있어야 한다. default 메서드 역시 접근 제어자는 public이며, 생략 가능하다.

interface MyInterface {
    void method();
    void newMethod(); // 추상 메서드
}

interface MyInterface {
    void method();
    default void newMethod() {...} // default 메서드
}

static 메서드

static 메서드는 인스턴스와 관계가 없는 독립적인 메서드이기 때문에 JDK1.8 이전에도 추가하지 못할 이유가 없었다.

인터페이스의 인스턴스 생성과는 관계없이 인터페이스 타입에서 호출이 가능한 정적 메서드 접근 제어자는 public으로 설정되어 있다.

static 메서드를 사용할 때에는 인터페이스 타입을 통해서 사용한다.

6. 인터페이스의 private 메서드

JDK 1.8에서 default 메서드와 static 메서드가 추가되었지만, 특정 기능을 처리하는 내부 메서드일 뿐인데도, 외부에 공개되는 public이라는 단점이 있었다. 이런 문제를 해결하기 위해 JDK 1.9에서 private 메서드와 private static 메서드가 추가되었다.

private 메서드의 사용은 인터페이스 내부에서 코드의 재사용성을 향상하는데, 예를 들어서 두 개의 default 메서드가 같은 코드를 공유해야 하는 경우 중복이 발생하게 되는데 이를 방지할 수 있 고, interface에 대한 캡슐화를 유지 할 수 있다.

private 메서드를 사용하기 위한 4가지 규칙

private 인터페이스 메서드는 추상 메서드가 될 수 없다.
private 메서드는 인터페이스 내부에서만 사용될 수 있다.
private static 메서드는 다른 static, non-static 인터페이스 메서드에서 사용될 수 있다.
private non-static 메서드는 private static 메서드 내부에서 사용될 수 없다.

private 메서드 예제

public interface CustomInterface {

  void method1();

  default void method2() {
    method4(); // 디폴트 메서드 안의 private 메서드
    method5(); // non-static 메서드 안의 static 메서드
    System.out.println("default method 2");
  }

  static void method3() {
    method5(); // static 메서드 안의 private static 메서드
    System.out.println("static method");
  }

  private void method4() {
    System.out.println("private method 4");
  }

  private static void method5() {
    System.out.println("private staic method");
  }
}

public class CustomClass implements CustomInterface {

  @Override
  public void method1() {
    System.out.println("abstract method");
  }

  public static void main(String[] args) {
    CustomInterface instance = new CustomClass();
    instance.method1();
    instance.method2();
    CustomInterface.method3();
  }
}

결과

abstract method
private method 4
private staic method
default method 2
private staic method
static method

private 메서드 예제

import java.util.function.IntPredicate;
import java.util.stream.IntStream;

public interface CustomCalculator {

  default int addEvenNumbers(int... nums) {
    return add(n -> n % 2 == 0, nums);
  }

  default int addOddNumbers(int... nums) {
    return add(n -> n % 2 != 0, nums);
  }

  private int add(IntPredicate predicate, int... nums) {
    return IntStream.of(nums)
        .filter(predicate)
        .sum();
  }
}

public class Main implements CustomCalculator {

  public static void main(String[] args) {
    CustomCalculator demo = new Main();

    int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int sumOfEvens = demo.addEvenNumbers(nums);
    System.out.println(sumOfEvens);

    int sumOfOdds = demo.addOddNumbers(nums);
    System.out.println(sumOfOdds);
  }
}

결과

20
25

참고로 Odd라는 조건은 결국 Even의 논리적인 부정이므로 IntPredicate의 negate() 메서드를 사용해도 된다.

이 역시 IntPredicate의 default 메서드로 구현되어있습니다. (Functional Interface지만, default 메서드는 람다식을 만드는데 문제가 되지 않음을 알 수 있다.

public interface CustomCalculator {

  IntPredicate isEven = n -> n % 2 == 0;

  default int addEvenNumbers(int... nums) {
    return add(isEven, nums);
  }

  default int addOddNumbers(int... nums) {
    return add(isEven.negate(), nums);
  }

  private int add(IntPredicate predicate, int... nums) {
    return IntStream.of(nums)
        .filter(predicate)
        .sum();
  }
}

참고

백기선님 온라인 스터디 8주차 - 인터페이스

인터페이스를 아는것 보다 좀 더 깊이 공부해봅시다.

velog.io

자바의정석

[Java] static 키워드

nohriter — Thu, 1 Sep 2022 21:34:21 +0900

Java의 static 키워드는 필드, 메서드, 클래스에 적용할 수 있습니다.

static 키워드를 사용하여 선언하였을 때 각각 어떤 차이점이 있는지 알아보겠습니다.

1. static field(변수, 상수)

클래스 안에서 변수를 선언하면 멤버 변수로 선언이 되며, 멤버변수에 접근하려면 car1.name 처럼 객체를 통해서 접근해야 한다.

Car car1 = new Car();
System.out.println(car1.name)

만약 static 키워드를 사용하여 변수를 선언하면 멤버 변수와 다른 특성을 갖게되는데,

아래와 같이 객체 car1을 통해서 접근할 수 있지만, 클래스 Car를 통해서도 접근할 수 있다.

System.out.println(Car.sNumberOfCars);

Car car1 = new Car();
System.out.println(car1.sNumberOfCars);

클래스를 통해서 접근을 하게 되면, 객체를 만들지 않고 외부에서 접근할 수 있다.

static으로 선언된 변수는 프로그램이 실행될 때 생성 및 초기화되기 때문에 객체를 생성하지 않아도 이미 변수는 생성된 상태이다.

아래에 Car 클래스에는 3개의 static field가 존재한다.

public class Car {

    public final static String MANUFACTURE_NAME = "BMW";
    public final static String CAR_NAME = "BMW 320D";

    public static int sNumberOfCars = 0;

    public Car() {
        sNumberOfCars++;
    }
}

위의 코드에서 static으로 선언된 변수는 Car 객체를 생성하지 않아도 접근이 가능하다.

MANUFACTURE_NAME와 CAR_NAME는 final static으로 선언했기 때문에 값 변경이 안되는 상수(Constant)이다.
sNumberOfCars는 static으로 선언했기 때문에 언제나 값을 변경할 수 있는 변수(Variable)가 된다.

보통 static 상수를 쉽게 구분하기 위해 대문자와 _ 만을 사용하여 이름을 짓는다.

클래스 이름을 통해서 접근

static field는 아래와 같이 객체를 생성하지 않고 클래스 이름을 통해서 접근할 수 있다. 위 코드에서 sNumberOfCars 는 Car 객체를 생성할 때 1이 증가되도록 구현되었기 때문에 모든 객체들이 하나의 변수를 공유하기 때문에 3이 출력된다.

Car car1 = new Car();
Car car2 = new Car();
Car car3 = new Car();

System.out.println(Car.CAR_NAME);
System.out.println(Car.MANUFACTURE_NAME);
System.out.println("Number of cars : " + Car.sNumberOfCars);

출력:

BMW 320D
BMW
Number of cars : 3

객체를 통해서 접근

static field도 아래와 같이 객체를 통해서 접근할 수도 있다. 하지만 static field는 Class를 통해서 접근하는 방법을 권장한다. 그 이유는 멤버 변수를 접근하고 있는지, static 변수를 접근하고 있는지 구별이 어렵기 때문이다.

Car car1 = new Car();
Car car2 = new Car();
Car car3 = new Car();

System.out.println(car1.CAR_NAME);
System.out.println(car1.MANUFACTURE_NAME);
System.out.println("Number of cars : " + car1.sNumberOfCars);

static field를 사용하는 이유

static field는 대부분 상수(인스턴스들마다 공통된 값)를 선언할 때 많이 사용되며, 이렇게 상수를 선언하면 다른 클래스에서도 Car.MANUFACTURE_NAME을 통해 상수에 접근할 수 있다.

public class Car {
  public final static String MANUFACTURE_NAME = "BMW";
  public final static String CAR_NAME = "BMW 320D";
}

중요핵심

1. static field는 프로그램이 실행될 때 생성 및 초기화되기 때문에 객체를 생성하지 않아도 접근이 가능하다.

2. static으로 상수를 선언할 때는 CAR_NAME 처럼 관습적으로 대문자와 _를 이용하여 이름을 짓는다.

3. static field는 클래스와 객체를 통해서 모두 접근이 가능하지만, 클래스를 통해서 접근해야 한다.(구분이 어렵기 때문)

4. static으로 상수가 아닌, 변수를 선언하는 일은 많지 않다. static 변수를 많이 선언하면 객체지향과 멀어지고 스파게티 코드가 될 수 있기 때문이다.

2. static 메서드

static 메서드도 static field와 비슷하게 메서드를 선언할 때 static을 사용하면 객체를 생성하지 않아도 그 메서드를 호출할 수 있다.

public class Car {
    public final static String MANUFACTURE_NAME = "BMW";
    public final static String CAR_NAME = "BMW 320D";

    public int year = 2018;

    public Car() {
    }

    public static void printCarName() {
        System.out.println("{ Brand : " + MANUFACTURE_NAME + ", Name : " + CAR_NAME + " }");
    }
}

static filed와 마찬가지로 printCarName()도 클래스와 객체를 통해서 모두 호출이 가능하다. 하지만 객체의 메서드를 호출하는 것인지 static 메서드를 호출하는 것인지 구분이 안되기 때문에 클래스를 통해서만 호출되어야 한다.

Car.printCarName();

Car car1 = new Car();
car1.printCarName();

static 메서드 주의할 점

static 메서드는 객체를 생성하지 않아도 호출할 수 있다. 이것은 메서드가 객체와 분리되어 있다는 의미다. 그래서 메소드 내부에서 super, this와 같은 키워드를 사용할 수 없고 클래스의 멤버 변수에 접근할 수도 없다. 내부에 선언된 변수 외에 static field, static 메소드만 접근할 수 있다.

중요핵심

1. static 메서드는 객체 생성 없이 호출할 수 있다. 그렇기 때문에 멤버 변수에 접근할 수 없고, static field 또는 메서드만 접근 가능하다.

2. static 메서드는 객체 및 클래스를 통해서 호출할 수 있지만, 멤버 메서드와 구분하기 어렵기 때문에 클래스를 통해서만 호출해야 한다.

3. static 메서드는 객체 생성 없이 호출 가능하기 때문에 Utils 클래스들을 만드는데 많이 사용된다.

4. static 메서드는 클래스이름.메서드명 과 같이 작성하기 때문에, 클래스 속성과 연관된 메서드를 묶어주는 효과가 있다.

3. static 클래스

자바는 외부 클래스에 static 키워드를 붙일 수 없지만, inner 클래스에는 static 키워드를 붙일 수 있다.
따라서 static 클래스를 이해하기 위해서는 inner 클래스를 알아야 한다. (이글에서는 내부 클래스에 대한 설명은 하지 않겠다)

위에서 static 메서드는 객체를 생성하지 않아도 호출할 수 있기 때문에 메서드와 객체가 분리되어 있다고 했다.

static 클래스도 분리라는 의미에서 비슷한 특성이 있다. static 키워드를 이용하여 class를 선언하면, 상위 클래스와 분리를 해 준다.

아래에 예시로 Car 클래스 하위에 Wheel 클래스를 선언하였다. 이런 구조로 선언된 Wheel 클래스를 Inner class라고 부르며, Inner class의 특징 중 하나는 상위 클래스와 연결되어 있는 것이다. 그래서 Wheel 클래스는 상위 클래스인 Car 클래스의 멤버 변수에 접근이 가능하다.

public class Car {
    public int year = 2018;

    public Car() {
    }

    public class Wheel {
        public Wheel() {
            year = 10;
        }
    }
}

만약 아래와 같이 static으로 Wheel클래스를 선언하면 Car 클래스와 분리가 되고, 분리되었다는 것은 Wheel 클래스에서 Car 클래스의 멤버변수에 접근할 수 없다는 의미이다. 이렇게 static으로 선언된 하위 클래스를 Static nested class라고 한다.

public class Car {
    public int year = 2018;

    public Car() {
    }

    public static class Wheel {
        public Wheel() {
            // year = 10; // compile error!
        }
    }
}

Static nested class는 상위 클래스가 생성되지 않아도, 외부에서 직접 객체를 생성할 수 있다.

아래와 같이 하위 클래스를 외부에서 직접 객체를 생성할 수 있고, 이것이 Inner class와의 가장 큰 차이점이라고 할 수 있다.

Car.Wheel wheel = new Car.Wheel();

static class를 사용하면 특정 클래스와 연관된 클래스들을 하위에 선언하여 관련있는 클래스들을 모아둘 수 있다.

출처

Java - Static 키워드 이해하기

Java의 static keyword는 field, method, class에 적용할 수 있습니다. static 키워드의 공통점은 객체와의 분리입니다. 객체를 생성하지 않고 접근할 수 있습니다. 또한, 어떤 클래스 아래에 static 변수, 메소

codechacha.com

[Java] 7.패키지

nohriter — Wed, 31 Aug 2022 17:13:23 +0900

자바의 패키지에 대해 알아보겠습니다.

1. 패키지 키워드

패키지(package)란, 관련 된 클래스(인터페이스 포함)들의 묶음이다. 서로 관련된 클래스들끼리 그룹 단위로 묶어 놓음으로써 클래스를 효율적으로 관리할 수 있다. (접근 보호와 네임 스페이스 관리) 같은 이름의 클래스일 지라도 서로 다른 패키지에 존재하는 것이 가능해서, 다른 개발자가 개발한 클래스 라이브러리의 클래스 이름과 충돌하는 것을 피할 수 있다.

클래스가 물리적으로 하나의 클래스파일(*.class)인 것과 같이 패키지는 물리적으로 하나의 디렉토리이다.

예를 들어, java.lang.String 클래스는 디렉토리 java의 서브 디렉토리인 lang에 속한 String.class 파일이다.

1. 하나의 소스파일에는 첫 번째 문장으로 단 한번의 패키지 선언만을 허용한다.
2. 모든 클래스는 반드시 하나의 패키지에 속해야한다.
3. 패키지는 점(.)을 구분자로 하여 계층구조로 구성할 수 있다.
4. 패키지는 물리적으로 클래스 파일(.class)을 포함하는 하나의 디렉토리이다.

패키지의 선언

클래스나 인터페이스의 소스파일(.java)의 맨 위에 다음과 같이 한 줄만 적어주면 된다.

package 패키지명;

클래스명과 쉽게 구분하기 위해서 대문자도 허용하지만, 소문자로 하는 것을 원칙으로 하고 있다.

모든 클래스는 반드시 하나의 패키지에 포함되어야하며, 소스파일에 자신이 속할 패키지를 지정하지 않는 모든 클래스는 자동적으로 자바에서 기본적으로 제공하는 '이름없는 패키지(unnamed package 또는 default package)'에 속하게 된다.

2. import

import는 컴파일러에게 소스파일에 사용된 클래스의 패키지에 대한 정보를 제공한다.

import의 선언

모든 소스파일(*.java)에서 import 문은 package 문 다음에, 그리고 클래스 선언문 이전에 위치해야한다.
import문은 package 문과 달리 한 소스파일에 여러 번 선언할 수 있다.

import 패키지명.클래스명;
or
import 패키지명.*; // 지정된 패키지에 속하는 모든 클래스를 패키지명 없이 사용할 수 있다.

static import

import 문을 사용하면 클래스의 패키지명을 생략할 수 잇는 것과 같이 static import 문을 사용하면 static 멤버를 호출할 떄 클래스 이름을 생략할 수 있다.

import static java.lang.Integer.*;
import static java.lang.Math.random;
import static java.lang.System.out;

out.println(random());
// System.out.println(Math.random());

3. 클래스패스

클래스패스란 말 그대로 클래스를 찾기위한 경로이다. 자바에서 클래스패스의 의미도 똑같다. 즉, JVM이 프로그램을 실행할 때, 클래스파일을 찾는 데 기준이 되는 파일 경로를 말하는 것이다. 소스 코드(.java 파일)를 컴파일하면 소스 코드가 “바이트 코드”(바이너리 형태의 .class 파일)로 변환된다. java runtime(java 또는 jre)으로 이 .class 파일에 포함된 명령을 실행하려면, 먼저 이 파일을 찾을 수 있어야 한다. 이때 .class 파일을 찾기 위해 classpath에 지정된 경로를 사용한다. classpath는 .class 파일이 포함된 디렉토리와 파일을 콜론으로 구분한 목록이다. java runtime은 이 classpath에 지정된 경로를 모두 검색해서 특정 클래스에 대한 코드가 포함된 .class 파일을 찾는다. 찾으려는 클래스 코드가 포함된 .class 파일을 찾으면 첫 번째로 찾은 파일을 사용한다.

4. 접근제어자

객체 지향에는 대표적인 4대 특성이 있는데 바로 추상화, 상속, 다형성, 캡슐화이다. 이 중 캡슐화는 정보 은닉이라고도 하는데, 서로 관련 있는 속성과 메서드를 클래스에 하나로 묶고 사용자가 필요로 하는 인터페이스만 제공하고, 나머지 내부적으로 구현된 내용은 외부로부터 감추는 것을 의미한다.

이덕에 사용자 입장에서는 별도로 복잡한 코드를 실행하지 않고(사용자의 실수 방지) 특정 인터페이스만 호출함으로써 원하는 결과를 얻을 수 있게 하며, 객체 입장에서는 클래스 내부에 선언된 데이터를 보호(수정 방지)할 수 있게 된다. 아울러 외부에 공개되지 않은 멤버의 경우 해당 클래스 외부로의 파급 효과가 없으므로 수정이 용이하다는 장점도 있다.

이때 자바에서 구현 내용을 내부에 감추는 방법으로 접근 제어자(private, default, protected, public)를 사용할 수 있다.

자바에서 제공하는 접근 제어자로는 private, default, protected, public이 있으며 각각의 접근 제어자별 특징은 다음과 같다.

구분	public	protected	default	private
동일 클래스	O	O	O	O
동일 패키지 + 상속	O	O	O	X
동일 패키지	O	O	O	X
다른 패키지 + 상속	O	O	X	X
다른 패키지	O	X	X	X

접근 제어자를 사용하면 멤버(속성, 메서드, 생성자) 또는 클래스에 대한 외부의 접근 권한을 지정할 수 있다.

참고로 접근 제어자를 생략할 경우 default인 것으로 간주하며 접근 제어자 private의 경우 같은 클래스의 인스턴스끼리는 서로 접근 가능하다. 또한 접근 제어자 protected의 경우 자신(슈퍼 클래스)과 상속 관계에 있는 서브 클래스에서 접근 가능하지만 같은 패키지 내의 클래스에서도 접근이 가능하므로 접근 제어자 default와 잘 구별하여 사용하여야 한다.

출처

캡슐화(정보 은닉)를 위한 Java의 접근 제어자 이해하기

캡슐화란? 객체 지향에는 대표적인 4대 특성이 있는데 바로 추상화, 상속, 다형성, 캡슐화이다. 이 중 캡슐화는 정보 은닉이라고도 하는데, 서로 관련 있는 속성과 메서드를 클래스에 하나로 묶

ikjo.tistory.com

백기선님 온라인 스터디 7주차 - 패키지

패키지에 대해서 정리합니다.

velog.io

[JAVA] 패키지란? (package, import, classpath...)

패키지 패키지(package)란, 클래스 묶음이다. 패키지에는 클래스 또는 인터페이스를 포함시킬 수 있으며, 서로 관련된 클래스들끼리 그룹 단위로 묶어 놓음으로써 클래스를 효율적으로 관리할

doozi0316.tistory.com

[Java] 오버라이딩(Overriding)

nohriter — Wed, 24 Aug 2022 15:24:30 +0900

자바의 오버라이딩에 대해 알아보겠습니다.

오버라이딩(Overriding)

오버라이딩이란?

오버라이딩(overriding)이란 상속 관계에 있는 부모 클래스에서 이미 정의된 메서드를 자식 클래스에서 같은 시그니쳐를 갖는 메소드로 다시 정의하는 것이라고 할 수 있다.

자바에서 자식 클래스는 부모 클래스의 private 멤버를 제외한 모든 메서드를 상속받는다. 이렇게 상속받은 메소드는 그대로 사용해도 되고, 필요한 동작을 위해 재정의하여 사용할 수도 있다. 즉, 메소드 오버라이딩이란 상속받은 부모 클래스의 메서드를 재정의하여 사용하는 것을 의미한다.

오버라이딩의 조건

1. 오버라이딩이란 메서드의 동작만을 재정의하는 것이므로, 메소드의 선언부는 기존 메소드와 완전히 같아야 한다. 하지만 메소드의 반환 타입은 부모 클래스의 반환 타입으로 타입 변환할 수 있는 타입이라면 변경할 수 있다.

2. 부모 클래스의 메서드보다 접근 제어자를 더 좁은 범위로 변경할 수 없다.

3. 부모 클래스의 메소드보다 더 큰 범위의 예외를 선언할 수 없다.

메서드 오버라이딩

자바에서는 메서드 오버라이딩을 통해 상속받은 부모 클래스의 메서드를 자식 클래스에서 직접 재정의할 수 있다.

@Override 어노테이션

주로 오버라이딩 할 때는 컴파일러에서 컴파일 타임에 체크할 수 있도록 하기 위해
@Override 어노테이션을 붙여주는 것이 좋다. 오타를 쳐서 실수를 하는 경우를 방지해준다.

class Parent {

    void display() { System.out.println("부모 클래스의 display() 메소드입니다."); }

}

class Child extends Parent {
	
    void display() { System.out.println("자식 클래스의 display() 메소드입니다."); }

}

 

public class Inheritance05 {

    public static void main(String[] args) {

        Parent parent = new Parent();

        pa.display(); // "부모 클래스의 display() 메소드입니다."

        Child child = new Child();

        ch.display(); // "자식 클래스의 display() 메소드입니다."

        Parent pc = new Child();

        pc.display(); // "자식 클래스의 display() 메소드입니다."

    }

}

오버로딩과 오버라이딩

오버로딩과 오버라이딩은 그 단어의 유사함으로 인해 혼동하기 쉽다. 하지만 이름만 비슷할 뿐 그 개념은 확실히 다르며, 그 차이점을 아는 것이 중요하다.

⭐️ 오버로딩(overloading)
새로운 메서드를 정의하는 것

⭐️ 오버라이딩(overriding)
상속받은 기존의 메서드를 재정의하는 것

class Parent {

    void display() { System.out.println("부모 클래스의 display() 메소드입니다."); }

}

class Child extends Parent {

    // 오버라이딩된 display() 메소드

    void display() { System.out.println("자식 클래스의 display() 메소드입니다."); }

    void display(String str) { System.out.println(str); } // 오버로딩된 display() 메소드

}

 

public class Inheritance06 {

    public static void main(String[] args) {

        Child ch = new Child();

        ch.display(); // "자식 클래스의 display() 메소드입니다."

        ch.display("오버로딩된 display() 메소드입니다."); // "오버로딩된 display() 메소드입니다."

    }

}

참고

http://www.tcpschool.com/java/java_inheritance_overriding

[Java] 자바는 왜 다중상속을 지원하지 않을까?

nohriter — Wed, 24 Aug 2022 14:17:43 +0900

자바는 왜 다중상속을 지원하지 않는지 알아보겠습니다.

1. 자바는 왜 다중상속을 지원하지 않을까?

다이아몬드 문제

다중 상속을 지원하게 되면 하나의 클래스가 여러 상위 클래스를 상속받을 수 있다. 이런 특징 때문에 발생하게 되는 문제가 '다이아몬드 문제'이다.

위의 클래스 다이어그램과 같은 상속 구조에서 발생되는 문제가 다이아몬드 문제이다. 예를 들어 GrandFather이라는 클래스가 myMethod()라는 이름의 메서드를 가지고 있다고 가정해 보자. 그리고 FatherA와 FatherB가 각각 오버라이딩하여 구현하였다면, FatherA와 FatherB를 모두 상속받은 Son 클래스 입장에서는 어떤 부모의 myMethod()를 사용해야 할까? 이런 문제로 인하여 충돌이 발생하게 된다.

코드로 나타내면 아래와 같다.

class GrandFather {
    void myMethod(){
        System.out.println("GrandFather");
    }
}

class FatherA extends GrandFather {
    @Override
    void myMethod(){
        System.out.println("FatherA");
    }
}

class FatherB extends GrandFather {
    @Override
    void myMethod(){
        System.out.println("FatherB");
    }
}

class Son extends FatherA, FatherB{
    @Override
    void myMethod() {
        super.myMethod(); //FatherA를 출력해야 할까? FatherB를 출력해야 할까?
    }
}

Son클래스 입장에서는 같은 이름의 myMethod가 두개의 상위 클래스에 모두 정의되어 있어, 어떤 메소드를 실행해야 될지 알 수가 없다.

같은 객체지향 언어인 C++에서는 이런 문제가 있음에도 불구하고 개발자에게 일임하고, 자바는 내부적으로 구현이 불가하도록 막아두었다. (C나 C++은 좀 더 자유로운 반면에 JAVA는 개발 편의성을 생각하는 언어라는 사실을 알 수 있다.)

자바 인터페이스는 다중상속 되던데?

한가지 의아한 점이 생길 수 있는데, 이런 문제가 있음에도 불구하고 자바 인터페이스는 다중상속이 가능하기 때문이다.

interface GrandFather {
    void myMethod();
}

interface FatherA extends GrandFather {
    @Override
    void myMethod();
}

interface FatherB extends GrandFather {
    @Override
    void myMethod();
}

interface Son extends FatherA, FatherB{
    @Override
    void myMethod();//상위 인터페이스에서 구현된 것이 없기 때문에 충돌이 발생하지 않는다.
}

인터페이스는 실질적인 구현이 이루어지지 않고 메소드에 대한 선언만 하고 있기 때문에 위처럼 메소드가 겹치더라도 최종 구현 부분은 구현 객체에서 이루어질 것이기 때문에 interface는 다중 상속이 가능하다.

자바8의 default method는?

자바8 default method는 내부적으로 코드 구현이 가능하다. 따라서, 인터페이스라고 하더라도 마치 class 처럼 다중상속을 받을 수 없게 된다.

interface GrandFather {
    default void myMethod(){
        System.out.println("GrandFather");
    };
}

interface FatherA extends GrandFather {
    @Override
    default void myMethod(){
        System.out.println("FatherA");
    }
}

interface FatherB extends GrandFather {
    @Override
    default void myMethod(){
        System.out.println("FatherB");
    }
}

interface Son extends FatherA, FatherB{
     //컴파일 에러 발생 
}

Class의 다중 상속처럼 컴파일이 진행되지 않지만, myMethod()를 새롭게 오버라이딩 하면 충돌을 해결 할 수 있다.

출처

자바는 왜 다중상속을 지원하지 않을까? (다이아몬드 문제)

다이아몬드 문제 다중 상속을 지원하게 되면 하나의 클래스가 여러 상위 클래스를 상속 받을 수 있습니다. 이런 특징 때문에 발생하게 되는 문제가 있는데, 바로 '다이아몬드 문제' 입니다. 위의

siyoon210.tistory.com

[Java] 6.상속

nohriter — Wed, 24 Aug 2022 13:05:19 +0900

자바의 상속에 대해 알아보겠습니다.

1. 자바 상속의 특징

상속이란

상속이란 상위 클래스에서 정의한 필드와 메서드를 하위 클래스에서도 동일하게 사용할 수 있게 물려받는 것이다.

상속을 사용하는 이유

코드를 재사용하기 편하고 클래스 간 계층구조를 분류하고 관리하기 쉬워진다.

자바 상속의 특징

서브클래스는 슈퍼클래스의 모든 멤버(필드, 메서드, 중첩 클래스)를 상속한다. 생성자는 멤버가 아니므로, 상속되지 않는다. 그러나 슈퍼클래스의 생성자는 서브클래스에서 실행될 수 있다. ex) super()
자손의 변경은 조상에 영향을 미치지 않는다.
자바는 단일상속만을 허용한다. (c++은 다중상속 허용)
명시적으로 슈퍼클래스를 지정해주지 않는다면, 모든 클래스의 암시적인 슈퍼클래스는 Object 클래스(모든 클래스의 조상)가 된다.
클래스들은 궁극적으로 최상위 클래스 Object에서 파생된 클래스에서 계속해서 파생될 수 있다.(상속의 횟수에 제한을 두지 않는다.) 따라서 모든 클래스는 Object의 자손이라고 볼 수 있다.

2. super 키워드

super

super 키워드는 서브클래스에서 슈퍼클래스를 가리키기 위해 사용하는 키워드이다.
super 키워드는 슈퍼클래스의 멤버에 접근하기 위해서 사용할 수 있고, 메서드 오버라이딩을 할 때 슈퍼클래스의 메서드를 호출해서 사용할 수도 있다. super를 사용해서 필드에 접근을 할 수도 있으나 권장되지 않는다.
super 키워드는 멤버변수와 지역변수를 구분할 때 this 를 사용했듯 상속받은 멤버와 자신의 멤버를 구분할 때 사용한다.

슈퍼클래스 멤버에 접근

기본적으로 상속을 하면 슈퍼클래스의 멤버 중 private, default가 아닌 멤버들을 참조할 수 있다.
슈퍼클래스의 메서드와 동일한 시그니처를 가진 메서드를 선언한다면 이를 오버라이딩이라고 한다.(매개변수와 리턴 타입은 변경 불가)
오버라이딩 할 때는 컴파일러가 컴파일 타임에 체크할 수 있도록 @Override 애노테이션을 붙여주는 것이 좋다. (오타방지)
오버라이딩 된 메서드는 슈퍼클래스의 메서드를 가리키기 때문에 super라는 키워드로 호출을 해야 한다.

LSP(리스코프 치환 원칙)

객체지향의 원칙 중에서 LSP 리스코프 치환 원칙(Liskov Substitution Principle)이 있는데, 오버라이딩을 하면서 이 원칙이 깨지도록 하면 안 된다. (LSP 원칙은 상위 타입의 객체를 하위 타입의 객체로 치환하더라도 상위 타입을 사용하는 다른 코드는 이전과 동일하게 동작해야 한다는 원칙이다.)

super()

super() 키워드를 통해서 서브클래스는 부모 클래스의 생성자를 호출할 수 있다.
슈퍼클래스의 멤버는 슈퍼클래스의 생성자를 호출해서 초기화해야 한다.
this()는 클래스의 다른 생성자를 호출하는 데 사용되지만, super()는 조상 클래스의 생성자를 호출하는 데 사용된다.

조상 클래스의 생성자를 호출해야하는 이유

조상클래스의 생성자를 호출해야하는 이유는 자손 클래스의 멤버가 조상클래스의 멤버를 사용할 수도 있으므로 조상의 멤버들이 먼저 초기화되어 있어야 하기 때문이다. 때문에 무조건 Object 클래스를 제외한 모든 클래스의 생성자는 첫 줄에 반드시 자신의 다른 생성자 또는 조상의 생성자를 호출해야 한다. (넣지 않으면 컴파일러가 자동으로 추가한다.)

서브클래스에서 슈퍼클래스 생성자 호출

class PointTest {    
    public static void mian(String args[]) {    
        Point 3D p3 = new Point3D(1, 2, 3);
    }
}

class Point {
    int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    String getLocation() {
        return "x :" + x + ", y : " + y;
    }

    class Point3D extends Point {
        int z;

        Point3D(int x, int y, int z) {
        // 생성자 첫 줄에서 다른 생성자를 호출하지 않기 때문에 컴파일러가 이 부분에 super();를 삽입한다.
        // super()는 Point3D의 조상인 Point클래스의 기본 생성자인 Point()를 의미한다.
            this.x = x;
            this.y = y;
            this.z = z;
        }

        String getLocation() { // 오버라이딩
            retrun "x: " + x + ", y : " +  y + ", z : " + z;
        }
    }

슈퍼클래스의 멤버는 슈퍼클래스의 생성자를 호출해서 초기화해야 한다.

super 클래스에 기본 생성자가 없는 경우에는 super()가 호출되면 에러가 난다.
따라서 위 코드에서 Point 클래스에 기본생성자가 없기 때문에 예외가 발생하게 되고,
이를 막기 위해선 super()가 Point(int x, int y) 를 호출하도록 super(x, y) 로 수정하면 된다.

따라서, 슈퍼클래스의 멤버는 슈퍼클래스의 생성자를 호출해서 초기화하도록 해야 한다.

메서드 오버라이딩 알아보기

3. 다이나믹 메서드 디스패치

다이나믹 메서드 디스패치는 자바의 테크닉 중 하나로, 런타임에 오버라이딩 된 메서드가 실행되는 것을 의미한다.

이는 참조 타입이 부모 타입인 경우에도 동작하므로 런타임 시점에 다형성을 만족하도록 할 수 있다.

public class Animal {
  public void move() {
    System.out.println("Animals can move");
  }
}

public class Dog extends Animal {
  @Override
  public void move() {
    System.out.println("Dogs can walk and run");
  }
}

public class Main {

  public static void main(String[] args) {
    Animal a = new Animal(); // Animal 참조, Animal 객체
    Animal b = new Dog(); // Animal 참조, Dog 객체

    a.move(); // Animal 클래스에 정의된 메서드 실행
    b.move(); // Dog 클래스에 정의된 메서드가 실행됨(다이나믹 메소드 디스패치)
  }
}

3. 추상 클래스

추상 클래스는 abstract라는 키워드가 추가된 클래스이다. 이 클래스는 추상 메서드를 포함하고 있거나, 포함하지 않을 수 있다.

추상 클래스 자체는 인스턴스화를 할 수 없지만, 서브클래싱을 할 수는 있다. 클래스에 추상 메서드가 포함된 경우에는 반드시 그 클래스는 추상 클래스어야 한다.

인터페이스와의 비교

추상 클래스는 인터페이스와 비슷하지만 많은 점이 다릅니다.

비슷한 점

인스턴스화 할 수 없다.
메서드를 여러 개 혼합할 수 있다.

다른 점

추상 클래스는 필드를 정의할 수 있다. 접근제어자도 자유롭게 정의 가능하다. 반면 인터페이스에서 모든 필드는 public static final이다.
추상 클래스는 하나만 상속 가능하지만 인터페이스는 여러 개의 인터페이스를 구현할 수 있다.

추상 클래스와 인터페이스 어떤 것을 사용해야 할까?

추상 클래스

밀접하게 관련이 되어있는 여러 클래스 간의 코드 공유
추상 클래스를 확장하는 클래스 사이에 많은 공통 메서드, 필드가 존재하고, public 이외의 접근 제어자가 필요한 경우
static, final 이 아닌 필드를 선언하려고 할 때, 상태를 액세스하고 수정할 수 있도록 하고 싶은 경우

인터페이스

관련 없는 클래스들이 인터페이스를 구현할 것으로 예상되는 경우(예, Comparable, Cloneable)
특정 데이터 타입의 동작을 정의하지만, 구현에는 신경 쓰고 싶지 않은 경우
타입의 다중 상속을 이용하려 하는 경우

추상 클래스가 인터페이스를 상속하는 경우 꼭 모든 메서드를 구현하지 않아도 된다.

4. final 키워드

final이 사용될 수 있는 곳 - 클래스, 메서드, 멤버 변수, 지역변수

Java의 final 키워드는 변경 불가능의 의미를 가진다. 변수의 경우에는 읽기 전용이라고 생각하자.

메서드의 경우에는 오버라이드 불가를 나타낸다. 특히 생성자에서 호출되는 메서드는 final로 선언하는 편이 바람직하다. 왜냐하면 오버라이딩으로 동작을 변경할 수 있기 때문이다. (의도치 않는 변경을 예방할 수 있음)

클래스에 선언된 final 키워드는 서브클래싱 할 수 없다. 즉, 확장이 불가능하게 막는다.

참고

백기선님 온라인 스터디 6주차 - 상속

열심열심

velog.io

[JAVA] 상속이란? (추상클래스, super, final, 오버라이딩...)

상속 기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것 장점 및 특징 적은 양의 코드로 새로운 클래스 작성 가능 코드를 공통적으로 관리해 코드의 추가/변경이 용이 코드의 재사용

doozi0316.tistory.com

[DB] 트랜잭션과 ACID 특성

nohriter — Sun, 21 Aug 2022 16:52:46 +0900

트랜잭션과 ACID 특성에 대해 알아보겠습니다.

1. 트랜잭션(transaciton)

트랜잭션이란 DBMS에서 데이터를 다루는 논리적 단위를 말한다. 트랜잭션은 완전히 완료되기도 하고 전혀 완료되지 않을 수도 있으며, 데이터베이스 상태를 한결같은 상태로 둔다. 트랜잭션의 전형적인 예는 은행 계좌에서 현금을 인출할 때 일어나는 과정이다. 현금이 계좌에서 인출되거나, 인출되지 않거나 둘 중의 하나일 뿐 외의 결과는 존재하지 않는다.

만약 중간에 실행이 중단되었을 경우, 처음부터 다시 실행하는 rollback을 수행하고, 오류 없이 실행을 마치면 commit을 하는 실행 단위를 의미한다. 즉, 한 번 질의가 실행되면 질의가 모두 수행되거나 모두 수행되지 않는 작업 수행의 논리적 단위이다.

예를 들어, 친구에게 인터넷 뱅킹으로 10,000원을 송금하는 상황을 가정해보자.

내가 친구에게 송금을 한다면, 나의 계좌에서 10,000원을 차감하고 친구의 계좌에 10,000원을 증가시켜야 한다.

그런데 알 수 없는 오류로 인해 나의 계좌에서는 10,000원이 줄었지만 친구 계좌에는 10,000원이 증가되지 않는다면 어떻게 될까?

나의 10,000원은 공중으로 증발해버리는 문제가 발생한다.

이러한 경우가 생기지 않도록 중간에 오류가 발생하면 다시 처음부터 송금을 하도록 하는 것이 rollback이다.

오류 없이 정상적으로 송금이 됐다면 정상적으로 실행이 끝났으므로 commit을 한다.

즉, 송금 과정을 하나의 트랜잭션이라 볼 수 있다.

1. 각 트랜잭션은 하나의 특정 작업으로 시작을 해서 묶여 있는 모든 작업들을 다 완료해야 정상적으로 종료한다.

2. 만약 하나의 트랜잭션에 속해있는 여러 작업 중에서 단 하나의 작업이라도 실패하면, 이 트랜잭션에 속한 모든 작업을 실패한 것으로 판단한다.

3. 작업이 하나라도 실패를 하게 되면 트랜잭션도 실패이고, 모든 작업이 성공적이면 트랜잭션 또한 성공이다.

4. 성공 또는 실패 라는 두 개의 결과만 존재하는 트랜잭션은, 미완료된 작업 없이 모든 작업을 성공해야 한다.

⭐️ DBMS의 성능 측정

트랜잭션을 작업수행의 논리적 단위라고 한다.
그렇기 때문에 DBMS의 성능은 초당 트랜잭션의 실행 수( TPS : Transaction per second )로 측정한다.

[ 트랜잭션 사용 이유 ]

트랜잭션은 DB 서버에 여러 개의 클라이언트가 동시에 액세스 하거나 응용프로그램이 갱신을 처리하는 과정에서 중단될 수 있는 경우 등 데이터 부정합을 방지하고자 할 때 사용한다.

프로세스를 병렬로 처리하지 않도록 하여 한 번에 하나의 프로세스만 처리하도록 하면 부정합이 발생하지 않는데, 이는 효율이 너무 떨어진다. 즉, 병렬로 처리할 수밖에 없는 현실적인 상황으로 인해 부정합을 방지하고자 트랜잭션을 사용한다.

2. ACID의 특성

트랜잭션에는 4가지의 특성이 있고, 4가지의 앞글자만 따서 ACID라 한다.

ACID 트랜잭션은 가능한 최대한의 데이터 안정성과 무결성을 보장해준다. 작업 하나가 일부분만 완료되는 바람에 데이터가 일관적이지 않은 상태가 되는 불상사가 절대로 일어나지 않게 해 준다는 뜻이다. 예를 들어 ACID 트랜잭션이 없다고 가정하면, 데이터베이스 테이블에 몇몇 데이터를 쓰던 중에 예기치 못하게 정전이 되면 데이터 중 일부는 저장이 되고 일부는 저장되지 않는 사태가 발생할 수 있다.

[ 원자성 ]

트랜잭션에 포함 된 작업은 전부 수행되거나 전부 수행되지 않아야 한다.
즉, All or Nothing의 개념으로서 작업이 일부분만 실행되지 않는다는 것을 말한다.

[ 일관성 ]

트랜잭션을 수행하기 전이나 후나 데이터베이스는 항상 일관된 상태를 유지해야한다.

트랜잭션이 성공적으로 완료되면 일관적인 DB상태, 트랜잭션 이전과 이후 DB의 상태는 이전과 같이 유지되는 것을 말한다.

예를 들어 어떤 테이블의 기본키와 같은 속성은 유지되어야 한다는 것 또는 A에서 B로 돈 이체를 할 때 A와 B계좌의 돈의 총합은 같아야한다

[ 격리성 ]

데이터베이스는 클라이언트들이 같은 데이터를 공유하는 것이 목적이므로 여러 트랜잭션이 동시에 수행되어야 한다.

격리성은 트랜잭션 수행시 다른 트랜잭션의 작업이 끼어들지 못하도록 보장하는 것을 말한다.(서로 독립적)

실제로 동시에 여래 개의 트랜잭션이 수행될 때, 각 트랜잭션은 고립(격리) 되어 있어 연속으로 실행해도 동일한 결과를 나타낸다.

[ 지속성 ]

완료(commit) 된 트랜잭션은 데이터베이스에 영구적으로 보존되는 것을 말하며, 런타임오류나 시스템 오류가 발생해도 유효하다.

만약 완료 후에 컴퓨터가 꺼진다면 데이터는 이미 저장되었으므로 보존되고, 완료 전에 컴퓨터가 꺼진다면 데이터는 Atomicity 원칙을 따라 트랜잭션 수행하기 전으로 돌아간다.

[ 트랜잭션과 DBMS ]

DBMS는 원자성을 유지하기 위해 회복(복구)관리자 프로그램을 작동시킴.
DBMS는 일관성을 유지하기 위해 동시성 제어 알고리즘과 무결성 제약조건을 활용함.
DBMS는 격리성/고립성을 유지하기 위해 동시성 제어 알고리즘을 작동시킴.
DBMS는 지속성을 유지하기 위해 회복 관리자 프로그램을 이용함.

어떤 트랜잭션이 실행되다가 장애에 의해 부분 완료되는 상황은 원자성과 지속성이라는 속성에 위배된다. 그래서 DBMS는 이를 유지하기 위해 회복 관리자 프로그램을 이용하는데, 일부만 진행된 트랜잭션을 취소시켜 원자성을 유지할 뿐 아니라 값을 트랜잭션 이전의 상태로 복원시켜 지속성을 유지시켜준다. 또한 일관성과 고립성을 유지하기 위해서 값에 동시에 접근하지 않도록 하므로 동시성 제어(Locking)를 활용하여 이를 해결한다. 파일 시스템과 같은 경우처럼 값이 덮어 씌워지는(Overwrite) 경우 일관성이 무너질 수 있고 그러한 경우는 고립성에 위배되는 경우이므로 Locking을 하여 이를 만족시킨다. 여기에 더해 DBMS는 잘못된 값에 대한 입력이 오면 일관성이 무너질 수 있으므로 이를 유지시키기 위해 무결성 제약조건도 활용한다.

[ 기타 개념들 ]

롤백(Rollback): 트랜잭션이 행한 모든 연산을 취소시키거나 트랜잭션을 재시작함.

Rollback 연산은 트랜잭션의 실행 중에 장애가 발생한 경우에 수행된다. 장애가 발생한 경우는 데이터베이스에 일부만 반영되어 일관되지 못한 상태를 가질 수 있으므로 모두 취소하거나 트랜잭션을 재시작해야 한다.

트랜잭션은 아래와 같이 5가지 상태를 가진다.

활동(Active)
부분완료(Partially Committed)
완료(Committed)
실패(Failed)
철회(Aborted)

활동

트랜잭션이 Begin_transaction으로 부터 실행을 시작하였거나 실행 중인 상태를 의미한다.

부분 완료

마지막 명령문을 실행시킨 직후의 상태를 의미하며 실패 또는 완료의 상태로 전이하게 된다.

실패

트랜잭션의 실행 중에 장애나 오류가 발생하여 정상적인 실행을 더 이상 할 수 없는 상태이며 Rollback 연산을 수행한 상태인 철회 상태로 전이하게 된다.

철회

Rollback에 의해 트랜잭션이 재시작 되거나 강제종료 되는 경우, 철회의 원인이 트랜잭션 자체의 논리적인 오류가 아닌 경우에는 재시작되며, 트랜잭션 철회의 원인이 트랜잭션 내부의 논리적인 오류에 의해 오류를 수정해야 하는 상황이거나 얻고자 하는 데이터가 데이터베이스에 존재하지 않는 경우에 강제 종료 된다.

참고

[DB이론] 트랜잭션(transaction)과 ACID 특성을 보장하는 방법

1. 트랜잭션( transaction ) 트랜잭션이란 질의(query)를 하나의 묶음 처리해서 만약 중간에 실행이 중단됐을 경우, 처음부터 다시 실행하는 Rollback을 수행하고, 오류없이 실행을 마치면 commit을 하는

victorydntmd.tistory.com

[데이터베이스] 트랜잭션의 ACID 성질 - 하나몬

트랜잭션이란 여러 개의 작업을 하나로 묶은 실행 유닛을 말한다. 데이터베이스 트랜잭션은 ACID라는 특성을 가지고 있다. ACID는 데이터베이스 내에서 일어나는 하나의 트랜잭션(transaction)의 안

hanamon.kr

[Database] 8. 트랜잭션, 동시성 제어, 회복

[ 본 사진은 쉽게 배우는 오라클로 배우는 데이터베이스 개론과 실습 ppt에서 캡처했습니다. ] 이번 장에서는 트랜잭션(Transaction), 동시성 제어(Locking or Currency Control), 회복(Recovery)에 대해 알아보

mangkyu.tistory.com

트랜잭션 4가지 특징 (ACID)

Transaction_4_Principle 트랜잭션 4가지 특징 ACID ? ㅇㅇ 이번 설날에 대학교 동아리 졸업하신 형들이랑 학교근처에서 술자리를 가졌다. 형들중 한명이 나에게 트랜잭션 4가지 특징을 물었다. 아토믹...

bactoria.tistory.com

[DB] 데이터베이스 인덱스의 자료구조

nohriter — Sun, 7 Aug 2022 14:47:52 +0900

데이터베이스 인덱스의 자료구조

인덱스는 여러 자료구조를 이용해서 구현할 수 있는데, 대표적으로 해시 테이블(Hash Table)과 B+Tree가 있다.

1. 해시 테이블(Hash Table)

해시 테이블은 key와 value를 한 쌍으로 데이터를 저장하는 자료구조이다. (key, value)로 쌍을 표현하며, key값을 이용해 대응되는 value값을 구하는 방식이다. 해시 충돌이라는 변수가 존재하지만 평균적으로 O(1)의 매우 빠른 시간만에 원하는 데이터를 탐색할 수 있는 구조이다.

해시 테이블을 이용한다면 인덱스는 (key, value) = (컬럼의 값, 데이터의 위치)로 구현하는데, 해시 테이블은 실제로 인덱스에서 잘 사용되지 않는다.

그 이유는, 해시 테이블은 등호(=) 연산에 최적화되어있기 때문이다. 데이터베이스에선 부등호(<, >) 연산이 자주 사용되는데, 해시 테이블 내의 데이터들은 정렬되어 있지 않으므로 특정 기준보다 크거나 작은 값을 빠른 시간 내에 찾을 수가 없다.

2. B+Tree

기존의 B-Tree는 어느 한 데이터의 검색은 효율적이지만, 모든 데이터를 한 번 순회하는 데에는 트리의 모든 노드를 방문해야 하므로 비효율적이다. 이러한 B-Tree의 단점을 개선시킨 자료구조가 B+Tree이다.

B+Tree는 오직 leaf node에만 데이터를 저장하고 leaf node가 아닌 node에서는 자식 포인터만 저장한다.

그리고 leaf node끼리는 Linked list로 연결되어있다.

또, B+Tree에서는 반드시 leaf node에만 데이터가 저장되기 때문에 중간 node에서 key를 올바르게 찾아가기 위해서 key가 중복될 수 있다.

B-Tree 예시

B+Tree 예시

이로 인한 장점이 뭐가 있을까?

1. leaf node를 제외하고 데이터를 저장하지 않기 때문에 메모리를 더 확보할 수 있다. 따라서 하나의 node에 더 많은 포인터를 가질 수 있기 때문에 트리의 높이가 더 낮아지므로 검색 속도를 높일 수 있다.

2. Full scan을 하는 경우 B+Tree는 leaf node에만 데이터가 저장되어 있고, leaf node끼리 linked list로 연결되어 있기 때문에 선형 시간이 소모된다. 반면 B-Tree는 모든 node를 확인해야 한다.

반면, B-Tree의 경우 최상의 경우 특정 key를 root node에서 찾을 수 있지만, B+Tree의 경우 반드시 특정 key에 접근하기 위해서 leaf node까지 가야 하는 단점이 있다.

인덱스에서 B-Tree 대신 주로 B+Tree를 사용하는 이유는 뭘까?

해시 테이블에서 언급했듯이 인덱스 컬럼은 부등호를 이용한 순차 검색 연산이 자주 발생할 수 있다. 따라서 B+Tree의 Linked list를 이용하면 순차 검색을 효율적으로 할 수 있게 된다.

B+Tree의 검색 과정은 B-Tree와 동일하다. 반면 B+Tree의 삽입과 삭제 과정은 약간의 차이가 있다. 기본적으로 B+Tree의 삽입과 삭제는 항상 leaf node에서 일어난다.

1) 삽입

(1) key의 수가 최대보다 적은 leaf node에 삽입하는 경우

해당 node의 가장 앞이 아닌 곳에 삽입되는 경우는 단순히 삽입해 주면 된다.

하지만, leaf node의 가장 앞에 삽입되는 경우는, 해당 node를 가리키는 부모 node의 포인터의 오른쪽에 위치한 key를 K로 바꿔준다. 그리고 leaf node끼리 Linked list로 이어줘야 하므로 삽입된 key에 Linked list로 연결한다.

(2) key의 수가 최대인 leaf node에 삽입하는 경우

key의 수가 최대이므로 삽입하는 경우 분할을 해주어야 한다. 만약 중간 node에서 분할이 일어나는 경우는 B-Tree와 동일하게 해주면 된다.

leaf node에서 분할이 일어나는 경우는 중간 key를 부모 node로 올려주는데 이때, 오른쪽 node에 중간 key를 붙여 분할한다. 그리고 분할된 두 node를 Linked List로 연결해준다.

이후 과정은 B-Tree의 과정과 동일하다.

2) 삭제

(1) 삭제할 key가 leaf node의 가장 앞에 있지 않은 경우

B-Tree와 동일한 방법으로 삭제된다.

(2) 삭제할 key가 leaf node의 가장 앞에 위치한 경우

이 경우는 leaf node가 아닌 node에 key가 중복해서 존재한다. 따라서 해당 key를 노드보다 오른쪽에 있으면서 가장 작은 값으로 바꿔주어야 한다.

출처

[DB] 11. 인덱스(Index) - (1) 개념, 장단점, B+Tree 등

[목차] 1. 인덱스(Index)란? 2. 인덱스(Index)의 장단점 3. 인덱스를 사용하면 좋은 경우 4. 인덱스의 자료 구조 1. 인덱스(Index)란? 인덱스(Index)는 데이터베이스의 테이블에 대한 검색 속도를 향상시켜

rebro.kr

[자료구조] 인덱스의 자료구조 (B-Tree)

nohriter — Sun, 7 Aug 2022 14:40:17 +0900

1. B-Tree란?

B-Tree는 탐색 성능을 높이기 위해 균형 있게 높이를 유지하는 Balanced Tree의 일종이다. 모든 leaf node가 같은 level로 유지되도록 자동으로 밸런스를 맞춰준다. 자식 node의 개수가 2개 이상이며, node 내의 key가 1개 이상일 수 있다.

node의 자식 수 중 최댓값을 K라고 하면, 해당 B-Tree를 K차 B-Tree라고도 한다.

B-Tree의 조건은 다음과 같다.

1. node의 key의 수가 k개라면, 자식 node의 수는 k+1개이다.

2. node의 key는 반드시 정렬된 상태여야 한다.

3. 자식 node들의 key는 현재 node의 key를 기준으로 크기 순으로 나뉘게 된다.

4. root node는 항상 2개 이상의 자식 node를 갖는다. (root node가 leaf node인 경우 제외)

5. M차 트리일 때, root node와 leaf node를 제외한 모든 node는 최소 M/2개, 최대 M개의 서브 트리를 갖는다.

6. 모든 leaf node들은 같은 level에 있어야 한다.

위의 트리는 3차 B-Tree의 예시이다. 주황색 부분은 '자식 node를 가리키는 포인터'이고, 살구색 부분은 '각 node의 key'이다. key와 데이터가 1대1 대응하고 있다.

node 안에서 key들은 항상 정렬된 상태를 유지하며, 이진 탐색 트리처럼 항상 각 key의 왼쪽 자식은 자신보다 작고, 오른쪽 자식은 자신보다 크다.

Balanced tree를 사용하는 이유는 뭘까?

일반적인 트리인 경우 탐색하는데 평균적인 시간 복잡도로 O(logN)을 갖지만, 트리가 편향된 경우 최악의 시간복잡도로 O(N)을 갖게 된다.

root node부터 탐색을 한다고 가정하고, 왼쪽처럼 편향된 트리에서 leaf node까지 탐색한다면 모든 node를 방문하기 때문에 O(N)의 시간이 걸리게 된다. 이러한 단점을 보완하기 위해 트리가 편향되지 않도록 항상 밸런스를 유지하는 트리가 필요하다. 자식들의 밸런스를 잘 유지하면 최악의 경우에도 O(logN)의 시간이 보장된다.

2. B-Tree의 key 검색

그렇다면 원하는 값은 어떻게 찾을까?

이는 이진 탐색 트리에서와 비슷하다. 원하는 값을 K라고 가정하자.

1) root node부터 탐색을 시작한다.

2) node의 key를 순회하여 K가 존재하면 탐색을 종료한다.

3) k가 존재하지 않는다면, 어떤 이웃한 두 key 사이에 K가 들어가는 경우 사이의 포인터를 통해 자식 node로 내려간다.

4) leaf node까지 2~3을 반복한다.

예를 들어 위의 B-Tree 예시에서 14라는 key를 검색한다고 가정해보자. 아래와 같이 진행된다.

root node의 key를 순서대로 확인

7보다 크므로 다음 key 확인. 15보다 작으므로 사이에 있는 포인터가 가리키는 자식으로 이동

자식으로 이동한 후 key 순서대로 확인

11보다 크므로 11의 오른쪽에 있는 포인터를 통해 자식으로 이동

마찬가지로 순서대로 탐색 후 14 확인

실제 데이터베이스에선 한 node에 매우 많은 key가 포함될 수 있기 때문에, 정렬되어 있음을 이용하여 binary search 등으로 효과적으로 찾을 수 있다.

3.B-Tree의 key 삽입

B-Tree는 균형을 유지해야 하기 때문에 key를 삽입하는 경우 트리의 변형이 발생할 수 있다. 삽입하는 과정은 다음과 같다.

1. 빈 트리인 경우 root node를 만들어 K를 삽입한다. root node가 가득 찬 경우 node를 분할하여 leaf node를 생성한다.

2. K가 들어갈 leaf node를 검색 과정과 동일하게 탐색한다.

3. 해당 leaf node에 자리가 남아있다면 정렬을 유지하도록 알맞은 위치에 삽입하고, leaf node가 꽉 차 있다면 K를 삽입한 후 해당 node를 분할한다.

4. node가 분할되는 경우 node의 중앙값을 기준으로 분할한다. 중앙값은 부모 node로 합쳐지거나 새로운 node로 생성되고, 중앙값을 기준으로 왼쪽의 key는 왼쪽 자식, 오른쪽의 key는 오른쪽 자식으로 생성된다.

마찬가지로 동일한 B-Tree에서 13이라는 key를 삽입해보자. 검색하는 과정은 생략하였다.

12와 14사이에 삽입이 된다.

node에 들어갈 수 있는 key 수보다 더 많이 삽입된 상태

leaf node의 중간값인 13이 부모 node에 합쳐진다. 12와 14는 각각 13의 왼쪽, 오른쪽 자식이 된다.

부모 node또한 key가 꽉 차있으므로 중앙값인 11을 분할해준다.

root node에 11이 합쳐졌다. root node도 역시 key가 꽉차있다.

root node의 중앙값인 11을 분할한다.

4. B-Tree의 key 삭제

특정 key를 삭제하는 경우도 마찬가지로 균형을 유지하기 위해서 트리의 변형이 필요하다. 삽입하는 과정보다는 조금 더 복잡하다.

삭제되는 key가 어느 node에 속해있는지, node의 상태는 어떤지에 따라 삭제되는 방식이 조금씩 다르다. 경우는 다음과 같이 나눠진다.

1. 삭제할 key가 leaf node에 있는 경우

1-1) 현재 node의 key 수가 최소보다 큰 경우

1-2) 현재 node의 key 수가 최소이고, 왼쪽 또는 오른쪽 형제 node의 key 수가 최소보다 큰 경우

1-3) 현재 node와 왼쪽, 오른쪽 형제 node의 key 수가 최소이고, 부모 node의 key 수가 최소보다 큰 경우

1-4) 현재 node와 왼쪽, 오른쪽 형제 node, 부모 node 모두 key 수가 최소인 경우

2. 삭제할 key가 leaf node를 제외한 node에 있는 경우

2-1) 현재 node 또는 자식 node의 key 수가 최소보다 큰 경우

2-2) 현재 node와 자식 node 모두 key 수가 최소인 경우

설명의 편의를 위해 용어를 다음과 같이 임의로 정의했다.

Lmax := 현재 node의 왼쪽 자손 중 가장 큰 key
Rmin := 현재 node의 오른쪽 자손 중 가장 작은 key
par := 현재 node를 가리키는 부모 node의 포인터의 오른쪽에 있는 key. 가장 우측에 있는 포인터인 경우 왼쪽에 있는 key
K := 삭제할 key

1. 삭제할 key가 leaf node에 있는 경우

1-1) 현재 node의 key 수가 최소보다 큰 경우

leaf node이면서 현재 node의 key 수가 최소보다 큰 경우에는 단순히 삭제해도 무방하다.

1-2) 현재 node의 key 수가 최소이고, 왼쪽 또는 오른쪽 형제 node의 key 수가 최소보다 큰 경우

K를 par로 바꿔준다. 그리고 par를 왼쪽 형제 node의 key 수가 최소보다 크다면 Lmax로, 오른쪽 형제 node의 key 수가 최소보다 크다면 Rmin로 바꿔준다.

ex) K = 10

10이 있는 node의 key 수가 최소. par = 11

K를 par로 대체

par를 Rmin으로 대체

삭제 완료

1-3) 현재 node와 왼쪽, 오른쪽 형제 node의 key 수가 최소이고, 부모 node의 key 수가 최소보다 큰 경우

K를 삭제하고, par를 부모 node에서 분할하여 형제 node와 합쳐준다. 그러면 부모 node의 key 수가 하나 줄고, 자식 node의 수도 하나 줄어들어 B-Tree 조건을 유지한다.

ex) K = 16

16이 있는 node, 오른쪽 형제 node key 수 최소. par = 17

par를 부모node에서 분할하여 형제 node와 합쳐줌

삭제 완료

1-4) 현재 node와 왼쪽, 오른쪽 형제 node, 부모 node 모두 key 수가 최소인 경우

부모 node가 root인 subtree의 높이가 줄어들기 때문에 트리의 재구조화가 필요하다.

이 경우는 2-2) 경우와 동일하므로 뒤에서 함께 설명하겠다.

2. 삭제할 key가 leaf node를 제외한 node에 있는 경우

2-1) 현재 node 또는 자식 node의 key 수가 최소보다 큰 경우

K의 Lmax 또는 Rmin과 자리를 바꿔준다. 그러고 나면 leaf node에서의 K 삭제와 동일해진다.

ex) K = 15

Lmax = 14, Rmin = 16

이후 과정은 case 1과 동일하다.

2-2) 현재 node와 자식 node 모두 key 수가 최소인 경우

현재 node와 자식 node가 모두 key 수가 최소라면, K를 삭제하는 경우 B-Tree 조건을 만족하기 위해서 트리의 높이를 줄여야 한다. 즉, 트리를 재구조화하며 그 과정은 다음과 같다.

1. K를 삭제하고 K의 양쪽 자식을 하나로 합친다. 합쳐진 node를 n1이라고 하자.

2. K의 par를 K의 형제 node에 합쳐준다. 합쳐진 node를 n2라고 하자.

3. n1을 n2의 자식이 되도록 연결한다.

4-1. 만약 n2의 key 수가 최대보다 크다면 key 삽입 과정과 동일하게 분할을 한다.

4-2. 만약 n2의 key 수가 최소보다 작다면 2.로 돌아가서 동일한 과정을 반복한다. (n2의 par를 n2의 형제 node에 합쳐준다)

ex) K = 4

K = 4. 현재 node와 자식 node 모두 key 수가 최소이다.

K를 삭제하고 K의 양쪽 자식 node를 합쳐준다. (n1)

K의 par인 7을 형제 node에 합친다. 그리고 n1을 자식으로 연결한다.

n2의 key 수가 최대보다 크므로 분할해야 한다.

중앙값인 9를 분할한다.

삭제 완료

출처

[DB] 10. B-Tree (B-트리)

[목차] 1. B-Tree란? 2. B-Tree의 key 검색 3. B-Tree의 key 삽입 4. B-Tree의 key 삭제 참고) emplam27.log 블로그 https://hyungjoon6876.github.io/jlog/2018/07/20/btree.html https://helloinyong.tistory.co..

rebro.kr