docker rm -f $(docker ps -aq)

위 명령어를 입력하면 현재 포트번호의 PID가 나온다.

sudo kill -9 PID

해당 포트를 사용하고 있는 프로세스를 종료할 수 있다.

• 객체와 테이블 매핑
• 필드와 컬럼 매핑
• 기본 키 매핑
• 연관관계 매핑

  객체와 테이블 매핑

  @Entity

• @Entity가 붙은 클래스는 JPA가 관리하는 엔티티
• 주의
  • 기본 생성자가 필수(parameter가 없는 public or protected)
  • final class, enum, interface, inner class에는 사용할 수 없다.
  • 저장할 필드에 final 키워드를 사용할 수 없다.

데이터베이스 스키마 자동 생성

• DDL을 어플리케이션 실행 시점에 자동 생성(로딩 시점에 create table이 가능)
• DB에 맞는 방언을 사용해서 적절한 DDL 생성
• 이렇게 생성된 DDL은 개발 장비에서만 사용!!

필드와 컬럼 매핑

@Entity
@Table(name = "MBR")
public class Member {

    @Id
    private Long id;

    @Column(name = "name", updatable = false, nullable = false, length = 10, columnDefinition = "varchar(100) default 'EMPTY'")
    private String username;

    @Column()
    private BigDecimal age;

    @Enumerated(EnumType.STRING) //enum을 사용할 때 , ORDINAL은 지양 -> ENUM의 순서가 바뀌면 알기 힘듦
    private RoleType roleType;

    @Temporal(TemporalType.TIMESTAMP) //java8 이후론 특별히 필요하지 않음
    private Date createDate;

    @Temporal(TemporalType.TIMESTAMP)
    private Date lastModifiedDate;

    @Lob//varchar을 넘기는 큰 양의 문자를 사용할 때
    private String description;

    @Transient //db와 관계없이 메모리에서만 사용하고 싶을 때
    private int temp;

    protected Member() {
    }
}

• @Column()

  • name : DB에서 실제 사용할 컬럼명을 설정
  • updatable : updatable = false이 되어 있으면 업데이트 쿼리가 날아가지 않음
  • nullable : NOT NULL 제약 조건
  • columnDefinition = varchar(100) default 'EMPTY', 컬렴을 직접 정의할 수 있음

• @Enumrated()

  • Enum타입을 DB와 매핑할때 사용
  • EnumType: ORDINAL -> ENUM의 순서대로(0, 1, 2...) 컬럼에 매핑 -> 사용지양 EnumType는 반드시 EnumType.STRING를 사용하는 것이 좋다.
  • @Temporal()
    • 날짜와 관련된 DB매핑
    • TemporalType : 표현방법에 맞게 DATE, TIME, TIMESTAMP 존재하는데 현재는 잘 사용하지 않는다.

• @Lob

  • clob, blob 타입에 사용

• @Transient

  • DB매핑과 관계 없이 자바 내 메모리에서만 사용하고 싶을 때

기본 키 매핑

• 영속성 컨텍스트의 변경내용을 데이터베이스에 반영

플러시 발생시 생기는 일

• 변경 감지
• 수정된 엔티티 쓰기 지연 SQL 저장소에 등록
• 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송

영속성 컨텍스트를 플러시 하는 방법

• em.flush() - 직접 호출

            Member member = new Member(200L, "member200");
            em.persist(member);
            em.flush();
            //트랜잭션을 커밋하지 않아도 query가 실행된다.

• transaction commit - 플러시 자동 호출
• JPQL 쿼리 실행 - 플러시 자동 호출

조심해야 할 부분

• flush는 영속성 컨텍스트를 비우지는 않는다.
• 영속성 컨텍스트의 변경내용을 데이터베이스에 동기화 한다.
• 트랜잭션이라는 작업 단위가 있기 때문에 commit직전에만 db를 동기화하면 되기 때문에 flush가 가능

(해당 게시물은 JAVA ORM 표준 JPA 프로그래밍 을 듣고 정리한 글 입니다.)

JPA에서 가장 중요한 두가지!

• 영속성 컨텍스트
• 객체와 관계형 데이터 베이스 매핑하기(Object Relational Mapping)

영속성 컨텍스트

• JPA를 이애하는데 가장 중요한 용어로 '엔티티를 영구 저장하는 환경'이라는 뜻이다.
• EntityManager.persist(entity); entity를 영속성 컨텍스트에 저장한다는 의미이다.
• EntityManager와 PersistenceContext가 매핑됨.

엔티티의 생명주기

• 비영속(new / transient)

  • 영속성 컨텍스트와 전혀 관계가 없는 새로운 상태

    
    Member member = new Member();
    member.setId("1L");
    member.setName("JWbase");
    
    객체를 생성한 상태여서 영속성 컨텍스트에서 관리 되지 않는 비영속 상태라고 부른다.

• 영속 (managed)

  • 영속성 컨텍스트에 관리되는 상태

    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();
    
    // 객체를 저장한 상태 (영속)
    em.persist(member);

  • tracnsaction.commit()를 해야지만 DB에 query가 동작한다.

• 준영속 (detached)

  • 영속성 컨텍스트에 저장되었다가 분리된 상태

    // 회원 엔티티를 영속성 컨텍스트에서 분리, 준 영속 상태
    em.detach(member);

• 삭제 (removed)

  • 삭제된 상태

    em.remove(member);

    영속성 컨텍스트의 이점

• 1차 캐시

• 동일성(identity) 보장

• 트랜잭션을 지원하는 쓰기 지연(transactional write-behind)

• 변경 감지(Dirty Checking)

• 지연 로딩(Lazy Loading)

엔티티 조회, 1차캐시

Member member = new Member();
member.setId("1L");
member.setName("JWbase");

//1차 캐시에 저장됨
em.persist(member);

//1차 캐시에서 조회
Member findMember = em.find(Member.class, "1L");

• 만약 Member.findMember2 = em.find(Member.class, "2L") 처럼 1차 캐시에 없는 객체를 영속성 컨텍스트에서 조회하면 DB에서 조회해서 조회해온 결과를 1차캐시에 저장하고 객체를 반환해준다.
• 보통 영속성 컨텍스트(엔티티 매니저)는 DB트랙잭션을 만들때 만들고 닫을 때 같이 날아가기 때문에 큰 장점은 없다.

동일성(Identity) 보장

            Member findMember1 = em.find(Member.class, 120L);
            Member findMember2 = em.find(Member.class, 120L);
            System.out.println("result = " + (findMember1 == findMember2)); //true

• 1차 캐시로 반복 가능한 읽기(Repeatable read) 등급의 트랜잭션 격리 수준을 데이터베이스가 아닌 어플리케이션 차원에서 제공한다.

트랜잭션을 지원하는 쓰기 지연

EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();

        em.persist(memberA);
        em.persist(memberB);
        //이 코드까지 실행되더라도 INSERT문을 날리지 않는다.

        //commit를 하는 순간에 INSERT문을 날린다.
        transacion.commit();

변경 감지

Member member = em.find(Member.class, 160L);
member.setName("JWClassic"); //em.persist(member)를 하지 않아도 update가 된다.

• JPA는 commit시점에 flush()를 호출하고 엔티티와 스냅샷을 비교한다.
• 변경 된 점이 있다면 쓰기 지연 SQL 저장소에 UPDATE SQL을 생성하고 DB에 UPDATE SQL을 날린 후 커밋한다.

엔티티 삭제

Member memberA = em.find(Member.class, "memberA");

em.remove(memberA); //엔티티 삭제

MySQL에서 비교 연산자는 = 외에도 <> 연산자를 사용할 수 있다. 흔히 알고 있는 != 에 해당하는 연산자라고 생각하면 된다. <> 연산자는 '값이 서로 다른 경우' 참이 되는 조건식으로 변경된다.

예를 들어

SELECT no, name
FROM sample21;

해당 데이터를 조회 했을 때 다음과 같은 값이 나온다고 하자.

SELECT no, name
FROM sample21
WHERE no = 2;

• no = 2 인 조건식을 걸어주면 no 컬럼에서 값이 2인 값만 나올 수 있다.

<> 연산자의 경우는

SELECT no, name
FROM sample21
WHERE no <> 2;

• 2가 아닌 경우를 출력하는 모습을 볼 수 있다.

• Java8에서 추가 된 기능으로 연속 된 정보를 처리하는데 사용한다. 자바에서 연속된 배열을 사용하는 경우는 보통 Array나 Collections에서 사용한다.

  다음과 같이 1, 3, 5라는 값이 정수 배열로 있을 때 asList() 메소드를 사용해서 List로 변환 한다.

Integer[] values = { 1, 3, 5 };
List<Integer> list = new ArraysList<>(Arrays.asList(values));

Arrays 클래스에 있는 stream()이라는 메소드를 사용해서 List로 변경하는 방법도 있다.

Integer[] values = { 1, 3, 5 };
List<Integer> list = Arrays.stream(values)
                            .collect(Collectors.toList());

Stream의 구조

스트림은 다음과 같은 구조를 가진다.

    list.stream()
    .filter(x -> x > 10)
    .count();

• 스트림 생성( stream() ) : 컬렉션의 목록을 스트림 객체로 변환한다. 여기서 스트림 객체는 java.util.stream 패키지의 Stream 인터페이스를 뜻함.

• 중개 연산( filter(x -> x > 10 ) : 생성된 스트림 객체를 사용하여 중개 연산 부분에서 처리한다. 하지만 이 부분에서는 아무런 결과를 리턴하지 못함 그래서 중개 연산(intermediate operation)이라고 부른다.

• 종단 연산( count() ) : 마지막으로 중개 연산에서 작업된 내용을 바탕으로 결과를 리턴

중개 연산은 반드시 있어야 하는 것은 아니고 0개 이상의 중개 연산이 존재할 수 있다고 생각하는 것이 좋다.

stream()은 순차적으로 데이터를 처리한다. 즉, 10개의 데이터가 있다면 0 ~ 9번재 인덱스를 하나씩 처음부터 처리한다.

Stream에서 제공하는 연산의 종류

스트림에서는 다양한 종류의 연산을 제공하지만 지금은 일반적으로 많이 사용되는 연산자(foreach(), map(), filter())를 알아 보자

foreach()

• for 루프를 수행하는 것처럼 각각의 항목을 꺼냄

@Getter
@Setter
public class StudentDTO {
    private String name;
    private int age;
    private int scoreMath;
    private int scoreEnglish;

    public StudentDTO(String name, int age, int scoreMath, int scoreEnglish) {
        this.name = name;
        this.age = age;
        this.scoreMath = scoreMath;
        this.scoreEnglish = scoreEnglish;
    }
}

import java.util.ArrayList;
import java.util.List;

public class StudentForEachSample {
    public static void main(String[] args) {
        StudentForEachSample sample = new StudentForEachSample();

        List<StudentDTO> studentList = new ArrayList<>();
        studentList.add(new StudentDTO("베이스", 40, 100, 100));
        studentList.add(new StudentDTO("스트림", 30, 85, 55));
        studentList.add(new StudentDTO("포이치", 20, 95, 75));

        sample.printStudentName(studentList);
    }

    private void printStudentName(List<StudentDTO> students) {
        students.stream()
                .forEach(student -> System.out.println(student.getName()));
    }
}

printStudentName() 메소드를 보면 학생들의 이름을 출력하는 기능을 하고 있다.

students.stream()까지는 스트림을 생성하는 부분이여서 넘어가고 forEach()를 보자. 람다식을 이용해서 매개변수로 넘어온 students List에서 하나의 studentDTO 객체를 의미한다.

forEach(student -> System.out.println(student.getName());

// 해당 코드는 위 코드와 동일한 기능을 한다.
for(StudentDTO student : students) {
    System.out.println(student.getName());
}

map()

• 데이터를 특정 데이터로 변환

위에서 확인한 스트림의 구조를 다시 살펴보면

    list.stream()
    .filter(x -> x > 10)
    .count();

앞 서 설명했던 forEach() 메소드 같은 경우에는 종단 연산에 속하고 지금 살펴 볼 map() 메소드의 경우는 중개 연산에 속한다.

List<Integer> intList = Arrays.asList(1,2,3,4,5,6);

• 해당 리스트를 모두 * 3해서 출력하는 예제이다.

private void mulitplayWithFor(List<Integer> integerList) {
        for (Integer value : integerList) {
            int tempValue = value * 3;
            System.out.println(tempValue);
        }
    }

private void mulitplayWithFor(List<Integer> integerList) {
        for (Integer value : integerList) {
            System.out.println(value * 3);
        }
    }

스트림을 사용하지 않으면 보통 이런식으로 작성하는 경우가 대부분이라고 생각한다. 스트림을 사용하면 이런식으로 작성할 수 있다.

     private void mulitplayWithFor(List<Integer> integerList) {
        integerList.stream()
                .forEach(value -> System.out.println(value * 3));
    }

하지만 3배로 변환된 값의 합을 구한다고 하면 복잡해진다. 이럴때 map()을 이용해서 편하게 사용할 수 있다.

        integerList.stream()
                .map(x -> x * 3)
                .forEach(System.out::println);

map(x -> x * 3)을 거치고 나면 {1, 2, 3, 4, 5, 6}의 값이 {3, 6, 9, 12, 15, 18}로 변경된다. 또한, map()은 숫자 뿐만 아니라 객체도 변경이 가능하다. 위의 예제 인 StudentDTO 리스트에서 이름만 추출해서 List로 뽑아내보도록 하자.

List<StudentDTO> studentList = new ArrayList<>();
        studentList.add(new StudentDTO("베이스", 40, 100, 100));
        studentList.add(new StudentDTO("스트림", 30, 85, 55));
        studentList.add(new StudentDTO("포이치", 20, 95, 75));

        List<String> studentNames = studentList.stream()
                .map(studnet -> studnet.getName())
                .collect(Collectors.toList());

이런 식으로 StudentDTO 객체에 있는 name값만 추출해서 리스트로 반환할 수 있다.

filter()

• 데이터를 조건으로 거를때 사용 위의 예제에서 수학 점수가 90점 이상 인 사람의 이름만 출력하도록 해보자

    private void filterWithMathScoreForLoop(List<StudentDTO> studentList, int scoreCutLine) {
        for (StudentDTO studnet : studentList) {
            if (studnet.getScoreMath() > scoreCutLine) {
                System.out.println(studnet.getName());
            }
        }
    }

  해당 코드를 스트림을 사용해 작성하면

    private void filterWithMathScoreForLoop(List<StudentDTO> studentList, int scoreCutLine) {
        studentList.stream()
                .filter(student -> student.getScoreMath() > scoreCutLine)
                .forEach(student -> System.out.println(student.getName()));
    }

  이렇게 나타낼 수 있다. 즉, filter는 조건문 처럼 스트림 내에서 필요한 데이터를 걸러서 처리할 때 사용한다.

Stream 정리

• 스트림은 Collction과 같이 목록을 처리할 때 유용하게 사용
  • 스트림 생성 - 중간 연산 - 종단 연산으로 구분
  • 중간 연산은 데이터를 가공할 때 사용되고 연산 결과로 Stream 타입을 리턴하기 때문에 여러개의 중간 연산을 연결할 수 있음
  • 종단 연산은 스트림 처리를 마무리 하기 위해 사용되며, 숫자나 List같은 데이터를 리턴

종류

List 컬렉션

• 객체를 인덱스로 관리하기 때문에 인덱스로 검색, 삭제 할 수 있는 기능 제공

• 종류 : ArrayList, Vector, LinkedList

• ArrayList

  • 가장많이 사용하는 List Collection
  • 길이의 제한 없이 객체를 추가 할 수 있음
  • 객체의 번지를 저장 -> 동일한 객체 중복저장 시 동일한 번지 저장
  • null 저장가능

      List<E> list = new ArrayList<E>(); // E에 지정된 타입의 객체만 저장
        List<E> list = new ArrayList<>(); // E에 지정된 타입의 객체만 저장
        List list = new ArrayList(); // 모든 타입의 객체 저장

  • 객체 추가시 인덱스 0번부터 차례대로 저장
  • 특정 인덱스의 객체 제거시 앞으로 1씩 당겨짐
  • 객체 삭제 및 삽입이 자주 일어나면 비효율

• Vector

  • ArrayList와 동일한 구조
  • 동기화(Synchronized)된 메소드로 구성 되어 있어 멀티 스레드가 Vector() 메소드 실행X
  • 안전하게 객체 추가 또는 삭제

        List<E> list = new Vector<E>(); // E에 지정된 타입의 객체만 저장
        List<E> list = new Vector<>(); // E에 지정된 타입의 객체만 저장
       List list = new Vector(); // 모든 타입의 객체 저장

• LinkedList

  • 인접 객체를 체인처럼 연결해서 관리

  • 삽입, 삭제시 앞뒤 링크만 변경하면 되므로 빈번한 삽입이 일어나는 곳에 사용

         List<E> list = new LinkedList<E>(); // E에 지정된 타입의 객체만 저장
           List<E> list = new LinkedList<>(); // E에 지정된 타입의 객체만 저장
           List list = new LinkedList(); // 모든 타입의 객체 저장

Set 컬렉션

• 저장 순서가 유지 되지 않음

• 중복 저장 X

• 하나의 null만 저장 가능

• 수학의 집합에 비유

• 종류 : HashSet, TreeSet

• HashSet

  • 가장 많이 사용 되는 Set 컬렉션

      Set<E> set = new HashSet<E>(); // E에 지정된 타입의 객체만 저장
        Set<E> set = new HashSet<>(); // E에 지정된 타입의 객체만 저장
        Set set = new HashSet(); // 모든 타입의 객체를 저장

  • HashCode() 리턴값이 같고, equals() true 리턴 -> 동일한 객체이므로 중복저장X

Map 컬렉션

• key와 value로 구성된 Entry객체 저장

• key는 중복 X, value는 중복 O

• 종류 : HaspMap, Hashtable, TreeMap, Properties, LinkedHashMap

• HashMap

  • 키 객체가 HashCode() 메소드의 리턴값이 같고 equals() 메소드가 true면 동일 키로 본다.
  • HashMap 생성 하는방법

    Map<K, V> map = new HashMap<K, V>();

• Hashtable

  • HaspMap과 동일한 내부
  • 동기화된 메소드로 구성되어 멀티 스레드가 동시에 Hashtable 메소드 실행 X
  • 멀티 스레드 환경에서도 안전하게 추가, 삭제

    Map<String, Integer> map = new Hashtable<>();

• Properties

  • Hashtable의 자식 클래스로 Hashtable의 특징을 그대로 가지고 있음
  • key, value를 String으로 제한한 컬렉션
  • 주로 .properties인 프로퍼티 파일을 읽을 때 사용
  • 프로퍼티 파일은 key , value가 = 기호로 연결되어 있는 텍스트 파일
  • ISO 8859-1 문자셋, 한글은 \u + 유니코드

    // database.properties 파일
      dirver=oracle.jdbc.OracleDriver
        url=jdbc:oracle:thin:@localhost:1521:orcl
        username=scott
        password=tiger
      admin=\uD64D\uAE38\u3D9
    

  // Properties 파일 읽는법

  Properties properties = new Properties();
    properties.load(Xxx.class.getResourceAsStream("database.properties"));

• fix: for bug fixes
• docs: for documentation updates
• style: for code style changes (e.g. whitespace, formatting)
• refactor: for code refactoring (i.e. improving the code without changing its functionality)
• test: for adding or updating tests
• chore: for changes to build processes, tooling, or other non-code changes

한글

• 수정: 버그 수정
• 문서: 문서 업데이트
• 스타일: 코드 스타일 변경 (예: 공백, 서식)
• 리팩터링: 코드 리팩터링 (즉, 기능을 변경하지 않고 코드를 개선)
• 테스트: 테스트 추가 또는 업데이트
• 기타: 빌드 프로세스, 도구 또는 기타 비코드 변경 사항

• Colletions에 있는 메소드 중 shuffle() 메소드는 배열이나 리스트를 랜덤으로 출력할 때 사용

public class ShuffleEx {
    public static void main(String[] args) {

        ArrayList<String> fruitList = new ArrayList<>();
        fruitList.add("apple");
        fruitList.add("banana");
        fruitList.add("grape");
        fruitList.add("melon");
        fruitList.add("orange");

        System.out.println("fruitList = " + fruitList);

        Collections.shuffle(fruitList);
        System.out.println("shuffleFruitList = " + fruitList);
    }
}

fruitlist = [apple, banana, grape, melon, orange]
shuffleFruitList = [melon, banana, orange, grape, apple]

1. 핸들러 조회 : 핸들러 매핑을 통해 요청 URL에 매핑된 핸들러(컨트롤러)를 조회한다.
2. 핸들러 어댑터 조회 : 핸들러를 실행할 수 있는 핸들러 어댑터를 조회한다.
3. 핸들러 어댑터 실행 : 핸들러 어댑터를 실행한다.
4. 핸들러 실행: 핸들러 어댑터가 실제 핸들러를 실행
5. ModelAndView반환 : 핸들러 어댑터는 핸들러가 반환하는 정보를 ModelAndView로 변환해서 반환
6. viewResolver호출: 뷰 리졸버를 찾고 실행한다.

• JSP의 경우 : InternalResourceViewResolver가 자동 등록되고, 사용된다.

7. View 반환 : 뷰 리졸버는 뷰의 논리 이름을 물리 이름으로 바꾸고, 렌더링 역할을 담당하는 뷰 객체를 반환

DispatcherServelt 구조 살펴보기

• 스프링 MVC의 프론트컨트롤러 = DispatcherServlet

• DispathcerServlet이 스프링 MVC의 핵심

• DispathcerServlet도 부모 클래스에서 HttpServlet을 상속받아서 사용하고, 서블릿으로 동작

  • DispathcerServlet -> FrameWorkServlet -> HttpSerlvetBean -> HttpServlet

• 스프링 부트는 DispathcerServlet을 서블릿으로 자동으로 등록하면서 모든경로(urlPatterns="/")에 대해서 매핑

  • 참고 : 더 자세한 경로가 우선순위가 높아서 기존에 등록한 서블릿도 함께 동작

요청흐름

• 서블릿이 호출되면 HttpServlet이 제공하는 service()가 호출
• 스프링 MVC는 DispathcerServlet의 부모님 FrameWork에서 service()를 오버라이드
• FrameworkServlet.service()를 시작으로 여러 메서드가 호출되면서 DispathcerServlet.doDispatch()가 호출

DispathcerServlet.doDispatch()

protected void doDispatch(HttpServletRequest request, HttpServletResponse
response) throws Exception {

    HttpServletRequest processedRequest = request;
    HandlerExcutionChain mappedHandler = null;
    ModelAndView mv = null;

    // 1. 핸들러 조회
    mappedHandler = getHandler(processedRequest);
    if(mappedHandler == null) {
        noHandlerFound(processedRequest, response);
        return;
    }

    // 2. 핸들러 어댑터 조회 - 핸들러를 처리할 수 있는 어댑터
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

    // 3. 핸들러 어댑터 실행 -> 4. 핸들러 어댑터를 통해 핸들러 실행 -> 5. ModelAndView 반환
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
}

private void processDispathchResult(HttpServletRequest request,
HttpServletResponse response, HandlerExecutionChain mappedHandler, ModelAndView mv, 
Exception exception) throws Exception {
    // 뷰 렌더링 호출
    render(mv, request, response);
}

protected void render(ModelAndView mv, HttpServletRequest request,
HttpServletResponse response) throws Exception {
    // 6. 뷰 리졸버를 통해서 뷰찾기,
    // 7. View 반환
    view = resolveViewName(viewName, mv.getModelInternal(), locale, request);

    // 8. 뷰 렌더링
    view.render(mv.getModelInternal(), request, response);
}

• 스프링 MVC의 큰 강점은 DispathcerServlet 코드의 변경없이, 원하는 기능을 변경하거나 확장 할수 있다.
• 인터페이스만 구현해서 DispathcerServlet에 등록하면 컨트롤러를 만들 수 있음

• 운영 시스템에서는 System.out.println()같은 시스템 콘솔을 사용하지 않고 SLF4J 로깅 라이브러리를 사용한다.
• 로그 라이브러리는 Logback, Log4J, Log4J2등 수많은 라이브러리가 있는데 통합해서 인터페이스로 제공하는 것이 SLF4J 인터페이스
• 실무에서는 보통 스프링부트가 기본으로 제공하는 Logback을 대부분 사용

로그 선언

private Logger log = LoggerFactory.getLogger(getClass());
private static final Logger log = LoggerFactory.getLogger(Xxx.class));
@Slf4j: 롬복 사용

로그호출

log.info("hello");
System.out.println("hello)

@RestController
public class LogTestController {
    private final Logger log = LoggerFactory.getLogger(getClass());
        @RequestMapping("/log-test")
        public String logTest() {
            String name = "Spring";
            log.trace("trace log={}", name);
            log.debug("debug log={}", name);
            log.info(" info log={}", name);
            log.warn(" warn log={}", name);
            log.error("error log={}", name);
            //로그를 사용하지 않아도 a+b 계산 로직이 먼저 실행됨, 이런 방식으로 사용하면 X
            log.debug("String concat log=" + name);
            return "ok";
}

• @RestController

  • @Controller는 반환 값이 String이면 viewName으로 인식, 그래서 view를 찾고 view가 랜더링
  • @RestController는 반환 값으로 view를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력 따라서, return 에 ok를 바로 메시지로 받을 수 있다.

• 테스트

  • 로그가 출력되는 포멧을 확인

    2023-02-24 09:41:22.364  INFO 13428 --- [nio-8080-exec-2] hello.springmvc.basic.LogTestController  : info log=Spring 

  • 시간(2023-02-24 09:41:22.364), 로그레벨(INFO),
  • 프로세스ID(13428),
  • 쓰레드명([nio-8080-exec-2]),
  • 클래스명(hello.springmvc.basic.LogTestController),
  • 로그메시지(info log=Spring)

• 로그 레벨 설정

  • src/main/resources/application.properties 파일에서 설정

    #전체 로그 레벨 설정(기본은 info)
    logging.level.root=info
    

  #hello.springmvc 패키지와 그 하위 로그 레벨 설정 logging.level.hello.springmvc=debug ````

• 올바른 로그 사용법

  log.debug("data =" + data)
            /*로그 출력 레벨을 info로 설정해도 해당 코드에 있는 "data=" + data가
            실제 실행이 되어버려 결과적으로 문자더하기 연산이 발생) */
   log.debug("data = {}", data)
            /* 로그 출력레벨을 info로 설정하면 아무일도 발생하지 않아서 의미없는 연산이 발생하지 않음

• 로그 사용시 장점

  • 쓰레드정보, 클래스 이름 같은 부가 정보를 함께 볼 수 있고, 출력 모양을 결정
  • 로그 레벨에 따라 개발 서버에는 모든 로그를 출력하고, 운영서버에서는 출력하지 않는 등 로그를 상황에 맞게 조절할 수 있다.
  • 시스템 아웃 콘솔에만 출력하는 것이 아니라, 파일, 네트워크 등, 로그를 별도의 위치에 남길 수 있음 특히, 파일로 남길 때는 특정용량, 일별에 따라 로그를 분할하는 것도 가능
  • 성능도 System.out보다 좋음(내부 버퍼링, 멀티 쓰레드)

  • 실무에서는 꼭 로그를 사용하자!