Lombok이란?

Lombok은 자바에서 Model(DTO, VO, Domain Class) 클래스를 작성할 때, 멤버 변수에 대한 Getter/Setter Method, Equals(), hashCode(), ToString()과 멤버 변수에 값을 설정하는 생성자 등등을 @Getter, @Setter 같은 어노테이션을 통해 자동으로 생성해주는 라이브러리 이다.

공식홈페이지

시작하기

라이브러리 의존성 설정

Maven

1
2
3
4
5
6
7
8

<dependencies>
	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<version>1.18.4</version>
		<scope>provided</scope>
	</dependency>
</dependencies>

Gradle

1

provided 'org.projectlombok:lombok:1.18.4'

AssertJ 메소드 임포트

1

import lombok.*;

Lombok 어노테이션

실제 사용

Lombok 어노테이션을 이용하여 만든 Event Class

1
2
3
4
5
6
7

@Builder @AllArgsConstructor @NoArgsConstructor
@Getter @Setter @EqualsAndHashCode(of="id")
public class Event {

    private Integer id;
    private String name;
}

실제로 만들어진 .class파일

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.doohong.restapi.event;

public class Event2 {
    private Integer id;
    private String name;

    public static Event2.Event2Builder builder() {
        return new Event2.Event2Builder();
    }

    public Event2(final Integer id, final String name) {
        this.id = id;
        this.name = name;
    }

    public Event2() {
    }

    public Integer getId() {
        return this.id;
    }

    public String getName() {
        return this.name;
    }

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

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

    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof Event2)) {
            return false;
        } else {
            Event2 other = (Event2)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$id = this.getId();
                Object other$id = other.getId();
                if (this$id == null) {
                    if (other$id != null) {
                        return false;
                    }
                } else if (!this$id.equals(other$id)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof Event2;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $id = this.getId();
        int result = result * 59 + ($id == null ? 43 : $id.hashCode());
        return result;
    }

    public static class Event2Builder {
        private Integer id;
        private String name;

        Event2Builder() {
        }

        public Event2.Event2Builder id(final Integer id) {
            this.id = id;
            return this;
        }

        public Event2.Event2Builder name(final String name) {
            this.name = name;
            return this;
        }

        public Event2 build() {
            return new Event2(this.id, this.name);
        }

        public String toString() {
            Integer var10000 = this.id;
            return this.name;
        }
    }
}

빈 등록 방법

빈 등록 방법에는 크게 3가지 방법이 있다

XML을 이용한 빈 등록

1
2
3

<bean id="aaa" class="xxx.yyy.zzz.AAA">
   <property name="prop"></property>
</bean>

위와 같은 방법으로 xml 설정파일에 직접 등록할 수 있다.

하지만 xml을 통한 빈 등록 방식은 2가지 정도의 문제점이 있다.

1. 빈의 성격 구분을 하기 힘들어진다.
2. 어플리케이션의 크기가 조금만 커져도 빈의 양이 늘어 관리하기 버거울 수 있다.

그래서 스프링에서는 클래스에 특정 애노테이션을 부여하고 부여한 클래스를 찾아 자동으로 빈등록을 해주는 빈 스캐닝 이라는 기능을 제공해준다.

Annotation을 이용한 빈 등록

빈 등록 Annotation

@Repository, @Service, @Controller는 더 특정한 유즈케이승 대한 @Component의 구체화된 형태이다.

빈 의존관계 주입 Annotation

@Component를 통해 자동으로 Bean을 등록하고, @Autowired로 의존관계를 주입받는 어노테이션을 클래스에서 선언하여 사용했을 경우에는 해당 클래스가 위치한 특정 패키지를 Scan하기 위한 설정을 XML에 해야함.

1

<context:component-scan base-package="패키기 경로" />

다음과 같은 태그를 넣어 주기만 하면 dev.wedding.kr.test패키지 하위에 존재하는 빈 스캔 대상(스테레오 타입 내오테이션 클래스)을 빈 으로 등록해준다.

자바 코드로 빈 등록

스프링 3.0 부터 기존의 xml 방식을 벗어나 java로 설정 파일을 작성할 수 있게 되었다.

java로 설정파일을 작성하게 되면 IDE의 기능을 최대한 활용할 수 있기 때문에
작성하기도 쉽고, 이해하기도 쉬워진다.

게다가 IDE에서 문법 체크를 지원해주므로 실수할 일도 줄어들게 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Configuration
public class ConfigurationBeanFactory {
    
    @Bean
    public CarInfoProvider kiaCar(){
        return new KiaCar();
    }
    
    @Bean
    public CarInfoProvider hyundaiCar(){
        return new HyundaiCar();
    }
    
}

래스 레벨에서는 @Configuration을 붙이고, 메서드 레벨에서는 @Bean애노테이션을 붙이면 된다.

@Bean이 붙은 메서드명이 각각의 bean의 이름이 된다. 리턴되는 객체를 스프링 컨테이버가 빈으로 활용한다.

IoC(Inversion of Control)

IoC는 번역하면 제어의 역전 이라는 뜻이다.

일반적인 프로그램은 자신이 사용할 오브젝트를 직접 선택하고 생성한다. ex) new Class();

오브젝트의 대한 제어권을 자신이 가지고 있는 능동적인 상태인 것이다.

하지만 스프링에서는 프로그램의 흐름을 프레임워크가 주도하게 된다. ex) @Autowired 등으로 Bean을 자동 주입

즉, 제어권이 컨터에너로 넘어가게 되고 이것을 제어권의 흐름이 바뀌었다고 해서 IoC(Inversion of Control : 제어의 역전)이라고 한다.

제어권이 컨테이너로 넘어옴으로써 DI(의존성 주입), AOP(관점 지향 프로그래밍)등이 가능하게 된다.

DI(Dependency Injection)

DI는 번역하면 의존성 주입 이라는 뜻이다.

객체간의 의존성을 자신이 아닌 외부에서 주입하는 개념이다.

객체지향에서 의존하고 있다라는 의미는 하나의 오브젝트에서 다른 오브젝트를 사용할때를 말한다.

A라는 클래스에서 B라는 클래스를 사용할 경우 A클래스는 B클래스에 의존하고 있다고 표현한다.

B클래스를 생성해서 A클래스에 넣어주는 과정, 이를 의존성 주입이다.

주입은 제 3자가 해준다. IoC의 개념이다. 결국 DI는 IoC의 세부적인 개념이다!.

Spring Framework란?

java 엔터프라이즈 개발 을 편리하게 해주는 오픈소스 경량급 애플리케이션 프레임워크이다.

• 애플리케이션 프레임워크
  • 특정 계층이나 기술, 업무 분야에 국한되지 않고 애플리케이션 전 영역을 포괄하는 범용적인 프레임 워크
• 경량급 프레임워크
  • 단순한 웹컨테이너에서도 엔터프라이즈 개발의 고급 기술을 대부분 사용할 수 있다.
• 엔터프라이즈 개발 용이
  • 개발자가 복잡하고 실수하기 쉬운 Low Level(보안,인증)에 많이 신경 쓰지 않으면서 Business Logic 개발에 전념할 수 있도록 해준다.
• 오픈소스
  • Spring은 Open Source 의 장점을 충분히 취하면서 동시에 Open Source 제품의 단점과 한계를 잘 극복한다.

Spring Framework 전략

1. Protable Service
2. Abstraction
3. DI
4. AOP
5. POJO

Protable ServiceAbstraction(서비스 추상화)

트랜잭션 추상화, OXM 추상화, 데이터 액세스의 Exception 변환기능 등 기술적인 복잡함은 추상화를 통해 Low Level의 기술 구현 부분과 기술을 사용하는 인터페이스로 분리한다.

DI(Dependency Injection)

Spring은 객체지향에 충실한 설계가 가능하도록 단순한 객체 형태로 개발할 수 있고, DI는 유연하게 확장 가능한 객체를 만들어 두고 그 관계는 외부에서 다이내믹하게 설정해준다.

AOP(Aspect Oriented Programming)

AOP는 애플리케이션 로직을 담당하는 코드에 남아 있는 기술 관련 코드를 분리해서 별도의 모듈로 관리하게 해주는 강력한 기술

POJO(Plain Old Java Object)

POJO는 객체지향 원리에 충실하면서, 특정 환경이나 규약에 종속되지 않고 필요에 따라 재활용될 수 있는 방식으로 설계된 객체

Spring Framework 특징

• 컨테이너 역할
  • Spring 컨테이너는 Java 객체의 Life Cycle을 관리하며, Spring 컨테이너로 부터 필요한 객체를 가져와 사용할 수 있다.
• DI(Dependency Injection)지원
  • Spring은 설정 파일이나 어노테이션을 통해서 객체간의 의존관계를 설정할 수있다.
• AOP 지원
  • Spring은 트랜잭션이나 로깅, 보안과 같이 공통적으로 필요로 하는 모듈들을 실제 핵심 모듈에서 분리해서 적용할 수 있다.
• POJO 지원
  • Spring 컨테이너에 저장되는 Java객체는 특정한 인터페이스를 구현하거나, 특정 클래스를 상속받지 않아도 된다.
• 트랜잭션 처리를 위한 일관된 방법을 지원
  • JDBC, JTA 등 어떤 트랜잭션을 사용하던 설정을 통해 정보를 관리하므로 트랜잭션 구현에 상관없이 동일한 코드 사용가능
• 영속성(persistence)과 관련된 다양한 API 지원
  • Spring은 MyBatis, Hibernate 등 데이터베이스 처리를 위한 ORM(Object Relational Mapping) 프레임워크들과의 연동 지원

객체 지향 프로그래밍 입문 - 최범균님의 인프런 강좌을 보고 작성하였습니다.

다형성(Polymorphism)

여러(poly) 모습(morph)을 갖는것

객체 지향에서는 한 객체가 여러 타입을 갖는 것

• 즉 한 객체가 여러 타입의 기능을 제공
• 타입 상속으로 다형성 구현

추상화(Abstraction)

데이터나 프로세스 등을 의미가 비슷한 개념이나 의미 있는 표현으로 정의하는 과정

두 가지 방식의 추상화

• 특정한 성질, 공통 성질(일반화)

타입 추상화

여러 구현 클래스를 대표하는 상위 타입 도출

• 흔히 인터페이스 타입으로 추상화
• 추상화 타입과 구현은 타입 상속으로 연결

추상 타입 사용에 따른 이점 : 유연함

추상화는 의존 대상이 변경하는 시점에

추상화 -> 추상 타입 증가 -> 복잡도 증가

• 아직 존재하지 않는 기능에 대한 이른 추상화는 주의
  • 잘못된 추상화 가능성, 복잡도만증가
• 실제 변경, 확장이 발생할 때 추상화 시도

추상화를 잘 하려면

구현을 한 이유가 무엇 때문인지 생각해야 함

객체 지향 프로그래밍 입문 - 최범균님의 인프런 강좌을 보고 작성하였습니다.

상속(Inheritance)이란

상위 클래스의 기능을 재사용, 확장하는 방법

상속을 통한 기능 재사용시 발생할 수 있는 단점

1. 상위 클래스 변경 어려움
2. 클래스 증가
3. 상속 오용

상속의 단점 해결 방법은 -> 조립!!

조립(Composition)

여러 객체를 묶어서 더 복잡한 기능을 제공

보통 필드로 다른 객체를 참조하는 방식으로 조립 또는 객체를 필요 시점에 생성/구함

특정 기능을 재사용 하고 싶다면 특정 객체를 생성하여 사용

상속보다는 조립

상속하기에 앞서 조립으로 풀 수 없는지 검토

진짜 하위 타입인 경우에만 상속 사용

객체 지향 프로그래밍 입문 - 최범균님의 인프런 강좌을 보고 작성하였습니다.

캡슐화(encapsulation)란?

캡슐화(encapsulation)는 일반적으로 연관 있는 변수와 함수를 클래스로 묶는 작업을 말한다.

객체가 기능을 어떻게 구현 했는지 외부에 감추는 것

• 구현에 사용된 데이터의 상세 내용을 외부에 감춤

캡슐화만 잘해도 좋은 코드를 만들 수 있음

정보은닉(Information Hiding) 의미 포함(최근에 포함해서 이야기 많이함)

캡슐화의 장점

외부에 영향 없이 객체 내부 구현 변경 가능

• 클래스 내부 메소드의 구현만 변경하면 되게끔 -> 외부 소스코드의 연쇄적인 변경 x

캡슐화를 잘 할수 있는 규칙!!

Tell, Don’t Ask 규칙
= 데이터를 달라고 부탁하지 말고 직접 해달라고 하기!
Demeter’s Law 규칙

• 메서드에서 생성한 객체의 메서드만 호출
• 파라미터로 받은 객체의 메서드만 호출
• 필드로 참조하는 객체의 메서드만 호출

acc.getExpDate().isAfter(now) -> acc.isExpired();
Date date = acc.getExpDate(); date.isAfter(now); -> acc.isValid(now);

객체 지향 프로그래밍(Object-Oriented Programming)

객체 지향 프로그래밍 이란 기존 절차 지향 프로그래밍 기법만의 유지보수와 기존 소프트웨어 재사용이 어려움에 좀더 나은 프로그램을 만들기 위한 프로그래밍 패러다임이다.

프로그래밍에서 필요한 데이터를 추상화 시켜 상태와 행위를 가진 객체를 만들고 그 객체들 간의 유기적인 상호작용을 통해 로직을 구성하는 프로그래밍 방법이다.

객체 지향 프로그래밍은 인간중심적 프로그래밍 패러다임이다.

유지보수와 재사용성이 높다.

software maintenance is not “keep it working like before.” It is “keep being useful in a changing world” -jessica Kerr

객체지향 VS 절차지향

객체지향

• 데이터와 프로시저를 알맞게 묶음
• 설계에 많은 시간이 투자된다.
• 유지보수 및 업그레이드가 쉽다.

절차지향

• 데이터가 여로 프로시저를 이용
• 객체지향에 비해 쉽다.
• 이러한 데이터를 공유하는 방식은 변화가 필요할 때 수정을 복잡하게 만든ㄴ다.

  객체

객체란 데이터와 기능을 가진 물리적으로 존재하거나 추상적으로 생각 할 수 있는 것.

객체의 핵심 -> 기능제공

• 객체는 제공하는 기능으로 정의
• 내부적으로 가진 필드로 정의 하지 않음

클래스(Class)

클래스는 특정한 기능을 가진 객체를 생성하게 해주는 설계도라고 할 수 있다.
클래스로 부터 만들어진 객체를 해당 클래스의 인스턴스라고 한다.

클래스에는 객체에 포함될 변수와 메소드를 정의해야 한다.

접근제어자(Access Modifier)

접근제어자는 변수나 메소드, 클래스에 대한 접근을 제어하는 문법이다.

접근을 제어하는 이유는 객체가 가진 고유의 멤버 변수값들이 외부에서 잘못 변경되는 것을 막기 위해서 이다.

자바에는 다음과 같은 접근제어자가 있다.

1. private
2. default
3. protected
4. public

private

접근제어자가 private 으로 설정 되어 있다면 그 변수나 메소드는 해당 클래스에만 접근이 가능하다.

최상위 클래스 선언에서는 private를 사용할 수 없다.

default

접근제어자를 별도로 설정하지 않는다면 default 접근제어자가 된다. default 접근제어자는 해당 패키지 내에서 접근이 가능하다.

protected

protected 접근제어자는 default 접근제어자와 마찬가지로 동일 패키지내에서 접근이 가능하며 추가적으로 해당 클래스를 상속받은 외부 패키지의 클래스에서도 접근이 가능하다.

public

public 접근제어자는 모든 클래스에 의해 접근할 수 있다. 즉 접근 제약이 없다.

접근 권한

public > protected > default > private

꿀팁

메소드를 오버라이딩 할 경우 부모 클래스의 메소드의 접근제어자보다 좁아질 수는 없다.

그러나 확장될 수는 있다.

private 로 선언된 메소드를 public 으로 오버라이딩하여 모든곳에서 접근 가능하도록 수정이 가능하다.

String 에 대한 더 자세한 설명

이전 포스트에서 말했듯이 String 객체의 값은 변경할 수 없다.
나는 String 객체의 값을 변경 시킬수 있다고 생각하시는 분들을 위해 아래 예제를 통해 설명하겠다.

1
2
3

String a = "Hello";
a = a+" World";
System.out.println(a); //Hello World

이 예제를 보면 a가 참조하는 메모리의 Hello 라는 값에 World 라는 문자열을 더해서 String 객체의 값을 변경 시킨 것으로 보인다

하지만 실제로는 메모리에 Hello World 를 다시 만들고 a를 다시 참조하게 한다.

간단하게 String 클래스의 immutable(불변) 에 대하여 복습 하였다.

String pool 이란??

String은 자바 개발자라면 자주 쓰게되는 자료형 이다.
간혹 자바에서 ==연산자를 이용해서 문자열을 비교하려고 할때 원치 않는 결과를 얻었던 경험들이 있을 것이다.

스트링은 두가지 생성 방식이 있고 그에 따라 각각 차이점이 존재한다.

1. new 연산자를 이용한 방식
2. 리터럴을 이용한 방식

new를 통해 String을 생성하면 Heap영역에 존재하게 되고 리터럴을 이용할 경우 String constant pool이라는 영역에 존재하게 된다.

예제를 통해 쉽게 설명해 보도록 하겠다.

1
2
3
4
5

String a = "Hello";
String b = "Hello";
String c = new String("Hello");
System.out.println(a==b);  //true
System.out.println(a==c);  //false

위에 예제의 결과에서 왜 3가지 객체가 다 같은 값을 가지고 있음에도 불구하고 비교 결과가 다른지 의문을 가진 분들이 있을것이다.

우선 == 연산은 값을 비교하는것이 아니라 같은 메모리를 참조하는지 비교하는 것이다.

• a의 경우 Hello 라는 문자열을 String pool 에 넣게 된다.
• b의 경우는 이미 같은 문자열이 String pool 에 존재하기에 같은 값을 참조하게 된다.
• c의 경우에는 new 연산자를 사용하여 새로운 객체를 명시적으로 생성하도록 했기 때문에 String pool이 아닌 다른 주소값을 참조하게된다.

이러한 이유로 위와 같은 결과를 얻을 수 있다.

이 예제를 통해 왜 String 객체의 값을 변경할 수 없어야 하는지 이유도 알 수 있다.
만약에 String 객체의 값의 변경이 가능하다면 a의 값을 변경 하였을때 원치 않게 b의 값도 변경될 수 있다.

String 객체의 값을 비교하는 equals()

equals() 메소드를 이용하여 두 문자열 객체의 실제 값을 비교할 수 있다.

그렇기 때문에 문자열 비교는 equals() 를 사용하는 것이 좋지만 속도적인 부분이나 메모리 부분 때문에 ==을 사용해야한다면 방법은 있다.

intern() 메소드를 사용하는 방법이다.

intern()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

String a = "Hello";
String b = new String("Hello");
String c = b.intern();
System.out.println(a.equal(b));  // true
System.out.println(a==c);  // true
``` 

**intern()** 메소드를 사용하면 해당 리터럴이 pool 에 존재하는지 화가인하고 존재하면 해당 pool 에 있는 리터럴을 리턴하고 없다면 리터럴을 pool 에 집어넣는다.

그렇기 때문에 c의 경우는 String c = "Hello" 로 해석할 수 있고 pool 에 이미 a가 만든 Hello 가 존재하므로 a와 같은 주소를 참조하게 된다.

아마도 **intern()** 메소드보다 **equals()** 메소드를 더 많이 사용하게 되겠지만  만약 사용하게 된다면 아래와 같이 사용할 수 있지 않을까 싶다.

```java
String id = "user";
String compareId = UserDto.getId().intern();
if(id == user){
    ...
}

그냥 이렇게도 사용할 수 있지 않을까 싶어 내가 만든 예시이다.

속도나 메모리를 엄청 신경 써야 하지 않는다면 문자열 비교는 equals()로 습관화 하는것이 좋은 방법일것 같다.

String pool 의 위치

String pool 은 java 6 버전까지 Perm 영역이었다.

하지만 Perm 영역은 고정된 사이즈이며 Runtime 에 사이즈가 확장되지 않는다

그래서 intern 되는 String 값이 커지면 OutOfMemoryException을 발생시킬 수 있었고 그에따라 java 7 버전에서 heap 영역으로 String pool 의 위치를 변경하였다.