Web Server와 WAS

아파치를 알아보기 전에 Web Server와 Web Application Server에 대한 이해가 필요하다.

1. Web Server

Web Server는 보통 HTTP 서버를 의미한다. HTTP 서버란 URL(웹 주소) 및 HTTP(프로토콜 주소)를 이해하는 소프트웨어이다. HTTP 서버는 저장하는 웹 사이트의 도메인 이름을 통해 액세스 할 수 있으며 이러한 호스팅 된 웹 사이트의 콘텐츠를 최종 사용자의 장치로 전달한다.

1-1. Web Server의 동작

1. 클라이언트에서 HTTP를 통해 파일을 요청한다.
2. 요청이 올바른 Web 서버에 도달하면 HTTP 서버가 요청을 수락하고 요청된 문서를 찾는다.
3. 찾는 문서를 HTTP를 통해 브라우저로 다시 반환한다. (이때, 요청된 문서를 찾지 못한다면, ‘404 Not Found’ 를 반환)

여기서 Web Server의 역할은 정적인 자료를 처리하는 서버이다.

HTML, CSS, IMAGE 등 정적 파일들을 서버에 저장하고, 요청시마다 서버에 저장된 파일을 사용자에게 HTML로 반환해준다. 그렇기 때문에 Web Server는 서버 자원의 한계가 생기고, 리소스를 많이 차지한다는 단점이 발생한다.

2. Web Application Server (WAS)

위의 웹 서버의 단점을 해결하고자 나온 것이 WAS이다.

WAS는 웹서버 + 웹 컨테이너로 구성되어 있다. 여기서 웹 컨테이너는 Servlet과 JSP를 실행할 수 있는 서블릿 컨테이너(Servlet Container)이며, 동적 컨텐츠(Servlet, JSP)를 처리한다.

WAS는 웹서버와 웹 컨테이너의 결합으로 다양한 기능을 컨테이너에 구현하여 다양한 역할을 수행할 수 있는 서버를 말한다.

2-1. WAS의 동작

1. 클라이언트에서 HTTP 요청을 한다.
2. 해당 요청은 우선 Web Server에서 정적데이터만 필요한 요청인지 확인한다.
3. 확인 결과 정적 데이터만이 필요하다면, 그대로 요청에 대한 응답을 클라이언트에게 보내준다.
4. 만약 동적 데이터가 필요한 요청이라면, 웹 컨테이너(서블릿 컨테이너)에 넘겨준다.
5. 웹 컨테이너는 요청정보를 파악하여 실시간으로 페이지에 필요한 파일을 생성하여 클라이언트에 반환한다.

이처럼 웹 컨테이너는 클라이언트 요청에서 실시간으로 결과를 만들어내고 이것을 다시 클라이언트에 전달해주는 역할을 한다.

Web Server와 WAS의 가장 큰 차이점은 이 웹 컨테이너가 있느냐 없느냐의 차이이다.

Apache와 Tomcat

Web Server와 WAS에 대해 알아보았으니, Apache와 Tomcat은 무엇인지 알아보자.

Apache

Apache는 아파치 소프트웨어 재단의 오픈소스 프로젝트로, HTTP Request를 처리하는 웹 서버이다. 클라이언트 요청이 왔을때만 응답하는 정적 웹페이지에 사용된다. 즉, 정적 데이터(HTML, CSS, IMAGE)만을 처리한다.

Tomcat

Tomcat은 흔히 WAS(Web Application Server)라고 한다.

동적인 웹(Dynamic Web)을 만들기 위한 웹 컨테이너, JSP와 Servlet을 구동하기 위한 서블릿 컨테이너 역할을 수행한다. 웹서버에서 정적으로 처리해야할 데이터를 제외한 JSP, ASP, PHP 등은 웹 컨테이너(톰캣)에게 전달한다. 동적인 데이터 처리가 가능하고, DB 연결, 데이터 조작, 다른 응용 프로그램과 상호 작용이 가능하다.

Apache-Tomcat이란?

많은 사람들이 Apache-Tomcat은 사실 Tomcat을 말하는 것이다. 위에서 알아봤듯이, 아파치와 톰캣의 기능은 나뉘어져 있지만 Tomcat안의 웹 컨테이너를 통해 일부 Apache의 기능을 하기 때문에, Apache-Tomcat이라는 이름으로 불리게 되었다.

Tomcat에서 Apache의 기능을 한다면, Tomcat만을 사용하면 안되는 것일까?

웹페이지는 정적 데이터뿐만 아니라 동적 데이터도 함께 존재한다. 만약 Tomcat에서 정적 데이터와 동적 데이터 모두를 처리하게 한다면, 그만큼 부하도 커질 것이고, 응답 또한 느려질 가능성이 크다. (WAS는 정적 데이터를 바로 반환하는 Web Server보다 데이터 처리 속도가 느리다.) 그래서 정적 데이터는 아파치가 동적 데이터는 톰캣이 분산 처리하는 것이다.

정리

Apache - 정적인 파일을 처리해주는 Web Server (80 포트) Tomcat - DB처리와 같은 동적인 기능들을 가공하여 HTML 파일로 만들어 클라이언트에게 제공하는 WAS (8080 포트)

Web Server - HTTP, HTTPS를 통해 웹 브라우저에서 요청하는 HTML 문서나 오브젝트(이미지 파일 등의 정적 콘텐츠)를 전송해주는 서비스 프로그램 Web Application Server - 서버 계층에서 애플리케이션이 동작할 수 있는 환경을 제공하고, 안정적인 트랜잭션 처리와 관리, 다른 시스템과의 애플리케이션 연동을 지원하는 서버로 동적 콘텐츠(Sevlet, JSP)를 처리하기 위해 사용

추가

웹 서버의 종류

• Apache
• Google Web Server
• Nginx
• ISS

웹 어플리케이션 서버의 종류

• Tomcat
• WebLogic
• Jeus
• Resin

본 내용은 인프런의 자바 ORM 표준 JPA 프로그래밍 - 기본편 강의를 수강하고 정리한 글입니다.

JPA에서 가장 중요한 것 중 하나는 연관관계 매핑이라고 할 수 있습니다. 이는 "객체와 테이블을 매핑하여 패러다임 불일치 문제를 해결"하고자 만들어진 JPA의 사용 목적과도 일치합니다.

객체와 테이블의 연관관계 차이

테이블 - 외래키를 통한 JOIN으로 관계 설정 객체 - 참조를 통한 관계 설정

우선 객체와 데이터베이스 테이블간의 차이를 이해하고 이 둘 사이의 매핑이 어떻게 이루어지는지 이해하는 것이 중요합니다. 테이블의 경우, 외래키를 통해서 테이블 간 연관관계를 설정합니다. 그에 반해 객체는 참조를 통해서 관계를 맺습니다.

아래의 예제를 통해 객체의 참조와 테이블의 외래키를 어떻게 매핑하는 것이 올바른지 알아보겠습니다.

객체를 테이블에 맞추어 모델링

객체를 테이블에 맞추어 모델링 할 경우엔 MEMBER 테이블에 TEAM_ID의 외래키를 갖게 되고, 참조가 아닌 외래키를 그대로 사용하게 됩니다.

MEMBER

@Entity
public class Member {
    @Id @GenerateValue
    private Long id;

    private int age;

    @Column(name = "USERNAME")
    private String name;

    @Column(name = "TEAM_ID")
    private Long teamId;

    ...
}

TEAM

@Entity
public class Team {
    @Id @GenerateValue
    private Long id;

    private String name;
    ...
}

만약 찾은 멤버가 어느 팀 소속인지 알고 싶다면 어떻게 코드를 작성해야 할까요?

Member findMember = em.find(Member.class, member.getId());

Long findTeamId = findMember.getTeamId();

Team findTeam = em.find(Team.class, findTeamId);

1. 멤버를 찾고
2. 멤버에서 팀 아이디를 찾아오고
3. 찾아온 팀 아이디로 팀을 찾아야 합니다.

이처럼 객체를 테이블에 맞추어 데이터 중심으로 모델링하면, 협력관계를 만들 수 없습니다. 테이블은 단지 외래키 team_id를 가지고 있을뿐 객체끼리 어떠한 관계설정이 되어있지 않기 때문에, 바로 TEAM 객체를 찾는 것이 불가능합니다. 이러한 설계는 어떤 것을 조회할때 항상 데이터베이스에 접근해야하기때문에 비효율적이며, 객체지향적이지 않다고 할 수 있습니다.

그렇다면 어떻게 작성하는 것이 옳은 방법일까요?

용어 이해

이를 위해서 이해해야하는 기본 용어는 크게 3가지가 있습니다. 그 중 오늘은 단방향 연관관계와 양방향 연관관계에 대해서 알아보도록 하겠습니다.

• 방향(Direction) : 단방향, 양방향

• 다중성 (Muliplicity) : 다대일(N:1), 일대다(1:N), 일대일(1:1), 다대다(N:M)
• 연관관계의 주인 (Owner) : 객체지향 양방향 연관관계는 관리 주인이 필요

1. 단방향 연관관계

데이터베이스 테이블의 경우 외래키 하나로 양쪽 테이블의 조인이 가능합니다. 그렇기 때문에 데이터베이스 테이블에는 방향이라는 개념이 존재하지 않습니다. 그러나 객체는 참조하는 객체를 가진 쪽에서만 다른 객체를 참조하는 것이 가능합니다. 이처럼 한 방향으로 객체를 참조하는 것을 단방향 관계라고 합니다. 표에서 보듯이, MEMBER객체는 외래키가 아닌 TEAM 참조값을 그대로 가지고 있는 것을 볼 수 있습니다. 여기서 MEMBER는 TEAM을 참조하고 있기 때문에 접근이 가능하지만, TEAM에서 MEMBER는 확인이 불가능한 단방향 연관관계입니다. 즉, member.getTeam()은 가능하지만, team.getMember()는 불가능합니다. 이것을 코드로 표현하면 어떻게 하면 될까요?

// Member
@Entity
public class Member {

    @Id @GenerateValue
    private Long id;

    @Column(name = "USERNAME")
    private String name;

    private int age;

    // @Column(name = "TEAM_ID")
    // private Long teamId;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    ...
}


// TEAM
@Entity
public class Team {

    @Id @GenerateValue
    private Long id;

    private String name;
    ...
}

하나의 팀에 여러명의 member가 소속되니까, MEMBER 쪽에 @ManyToOne으로 다대일 연관관계를 설정해줍니다. 해당 어노테이션을 통해서 어느쪽이 N인지 JPA에게 관리하도록 해줍니다. @JoinColumn(name = "TEAM_ID")으로 외래키 team_id와 매핑해줍니다. 외래키 TEMA_ID를 직접 사용했던 테이블 중심 설계와 다르게 @JoinColumn 어노테이션을 사용해 매핑해 줍니다.

연관관계 저장

// 팀 저장
Team team = new Team();
team.setName("teamA");
em.persist(team);

// 회원 저장
Member member = new Member();
member.setName("member1");
member.setTeam(team);    // 단방향 연관관계 설정, 참조 저장
em.persist(member);

이처럼 member에 team_id가 아닌 team 객체 자체를 넣어줍니다.

연관관계 조회

// 조회
Member findMember = em.find(Member.class, member.getId());

// 참조를 통해서 연관관계 조회
Team findTeam = findMember.getTeam();

데이터 중심 설계의 조회 방식과 다르게, findMember.getTeam()을 통해 객체 그래프 탐색이 가능하게 됩니다.

수정

// 새로운 팀B
Team teamB = new Team();
teamB.setName("TeamB");
em.persist(teamB);

// 회원 1에 새로운 팀B 설정
member.setTeam(teamB);

2. 양방향 연관관계

양방향 관계란 양쪽에서 참조하는 객체를 가져, 서로 참조가 가능한 것을 의미합니다. 엄밀히 말하면 양방향 관계라는 것은, 각각 객체를 참조하고 있는 두 개의 단방향 관계를 의미합니다.

Member 객체에는 Team 참조값이 있고, Team 객체에는 member를 List로 양방향에서 참조값을 갖습니다.

// Member
@Entity
public class Member {

    @Id @GenerateValue
    private Long id;

    @Column(name = "USERNAME")
    private String name;

    private int age;

    // @Column(name = "TEAM_ID")
    // private Long teamId;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    ...
}

// Team
@Entity
public class Team {

    @Id @GenerateValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();
    ...
}

MEMBER와 TEAM은 (N:1)의 연관관계를 갖기 때문에, Team 쪽에는 @OneToMany 어노테이션을 통해 매핑해주면 됩니다. mappedBy는 현재 1 : N 매핑에서 무엇과 연결되어 있는지 나타내주는 것으로 반대쪽 매핑의 필드명을 적어주면 됩니다. Member의 team과 매핑되어있음을 나타내줍니다.

// 조회
Member findMember = em.find(Member.class, member.getId);
List<Member> members = findMember.getTeam().getMembers();

for (Member member : members) {
System.out.println("m = " + member.getUsername());
}

// 결과
// m = member1
// m = member2

이렇게 양방향 모두로 객체 그래프 탐색이 가능하게 되었습니다.

연관관계의 주인, mappedBy 설정

사실, 두 객체가 서로 양방향 연관관계를 맺는다는 것은 두 개의 단방향 연관관계가 있다는 것을 의미합니다. 위의 코드에서도 보았다시피, 회원에서 팀으로 참조값 하나, 팀에서 회원으로 참조값이 존재합니다. 서로 다른 단방향 연관관계 2개를 양방향인 것처럼 보이게 할 뿐입니다. 반면에 데이터베이스 테이블은 외래 키 하나로 양쪽에서 조인이 가능합니다.

이렇게 데이터베이스 테이블과 객체가 관계를 맺는 차이를 해결하기 위해서 JPA에서는 연관관계의 주인을 지정해주어야합니다.

mappedBy는 양방향 연관관계의 주인을 지정합니다. 객체의 두 관계중 하나를 연관관계의 주인으로 지정합니다. 연관관계의 주인만이 외래 키를 관리(등록, 수정) 할 수 있으며, 주인이 아닌 쪽은 읽기만 가능합니다.

mappedBy 속성은 연관관계의 주인이 아닌 객체에 사용합니다. mappedBy라는 이름 그대로, 어느쪽에 매핑되었는지를 표현해줍니다.

그렇다면 연관관계의 주인을 어떻게 지정해야 할까요?

연관관계의 주인은 외래 키를 가지고 있는 쪽으로 하면 됩니다.

Fk를 가지고 있는 쪽이 연관관계의 주인이며, '진짜 매핑'이라고 합니다. 주인의 반대편은 '가짜매핑'이 되는 것이죠. 데이터베이스 테이블의 관계로 생각했을때는 외래키가 있는쪽이 N, 없는 쪽은 1이기 때문에, N쪽을 연관관계의 주인으로 생각하면 됩니다.

양방향 연관관계의 주의점

만약 연관관계의 주인이 아닌쪽에 값을 넣으면 어떤 문제가 발생할까요?

Team team = new Team();
team.setName("TeamA");
em.persist(team);

Member member = new Member();
member.setName("member1");

// 역방향(주인이 아닌 방향)에만 연관관계 설정
team.getMambers().add(member);

em.persist(member);

member1을 저장하고 TEAM의 컬렉션에 담은 후 저장했습니다. 여기에서 member1은 제대로 저장이 될까요? 위 코드를 실행하고 데이터베이스에서 회원 테이블을 조회하면 다음과 같은 결과가 나옵니다.

외래 키 TEAM_ID에 null 값이 들어가있는 것을 볼 수 있습니다. 양방향 연관관계를 설정할때, 연관관계의 주인만이 외래 키를 관리(등록, 수정) 할 수 있으며, 주인이 아닌 쪽은 읽기만 가능하다고 했습니다. 해당 코드에서는 연관관계의 주인이 아닌 역방향에만 값을 넣었기 때문에 위와 같은 문제가 발생한 것입니다. 가짜매핑에 값을 넣으면 JPA는 읽기만 가능합니다.

반대로 연관관계의 주인에 값을 넣어보면 아래와 같이 MEMBER의 TEAM_ID가 올바르게 들어간 것을 볼 수 있습니다.

Team team = new Team();
team.setName("TeamA");
em.persist(team);

Member member = new Member();
member.setName("member1");
member.setTeam(team);

em.persist(member);

순수한 객체 관계를 고려한 연관관계 매핑

그렇다면 정말 연관관계의 주인에만 값을 넣어주면 되는 걸까요?

가장 권장되는 방법은 양쪽 모두에 값을 입력하는 것입니다.

Team team = new Team();
team.setName("TeamA");
em.persist(team);

Member member = new Member();
member.setName("member1");
member.setTeam(team);        // 양쪽에 값 세팅
em.persist(member);

team.getMembers().add(member);    // 양쪽에 값 세팅

JPA에서 양방향 매핑 시 양쪽 모두에 연관관계를 설정하는 이유는 JPA가 JAVA 객체 관점과 데이터베이스 테이블 관점에서 관계를 관리하기 때문입니다.

연관관계의 주인은 외래키를 관리하며, 연관관계의 주인이 아닌쪽은 읽기만 가능합니다. 이로 인해 연관관계의 주인쪽에서만 setTeam()과 같은 메서드를 사용하여 연관관계를 설정하면 JPA가 이를 테이블에 반영할 수 있으나, JAVA 객체 상에서는 양쪽 모두에 반영할 필요가 있습니다. 그렇기 때문에 테스트 케이스 작성 시와 같은 JPA를 사용하지 않을때 문제가 발생합니다. 이때는 JPA 없이 순수 자바 코드를 통해 테스트를 하기 때문에 양쪽 모두에 값을 세팅해주지 않으면 양방향 연관관계를 올바르게 사용할 수 없습니다.

따라서, JAVA 객체 상의 일관성을 유지하고 순수한 객체 관계를 고려하여 양쪽 모두에 설정하는 것이 좋습니다.

연관관계 편의 메서드

연관관계 편의 메서드는 양쪽 모두에 연관관계를 세팅해야하는 불편함을 해소하고자 사용하는 방법입니다.

위의 코드와 같이 member.setTeam(team);, team.getMembers().add(member); 처럼 각각 코드를 작성하다보면, 한쪽에만 작성한다던지하는 실수가 발생할 수 있습니다.

public class Member {

  private Team team;

  public void setTeam(Team team) {
    this.team = team;
    team.getMembers().add(this);    // 연관관계 편의
  }

  ...
}

이렇게 setTeam() 메서드를 연관관계 편의 메서드로 변경해 양방향 관계를 설정할 수 있습니다.

본 내용은 인프런의 자바 ORM 표준 JPA 프로그래밍 - 기본편 강의를 수강하고 정리한 글입니다.

영속성 컨텍스트란?

영속성 컨텍스트란 "엔티티를 영구 저장하는 환경" 이라는 뜻이다. 쉽게 생각하자면, 영속성 컨텍스트는 애플리케이션과 데이터베이스 사이에서 객체를 보관하는 가상의 DB라고 생각하면 된다.

EntityManager.persist(object)

• persist()를 통해서 영속성 컨텍스트에 객체를 저장한다.
• 엔티티 매니저를 통해서 영속성 컨텍스트에 접근하고 관리할 수 있다.
• 엔티티 매니저를 생성할때 하나 만들어진다.

엔티티의 생명주기

엔티티는 EntityManager를 통해 영속성 컨텍스트에 저장이 된다. 하지만, 이는 실제 DB가 아니기때문에 생명주기를 갖는다.

1. 비영속(new/transient)

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

Member member = new Member()
member.setId(1L);
member.setName("홍길동");

엔티티 객체를 생성했지만,영속성 컨텍스트에 저장하지 않은 상태이다.

2. 영속(managed)

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

// 객체를 생성한 상태
Member member = new Member()
member.setId(1L);
member.setName("홍길동");

EntityManager em = emf.createEntityManager();
em.getTransaction().begin();

// 객체를 영속화
em.persist(member);

em.persist(member)를 통해서 Member 객체를 영속화 하였다. 이를 통해 Member 객체는 영속성 컨텍스트에 의해서 관리된다.

3. 준영속(detached)

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

em.detach(member);

회원 엔티티를 영속성 컨텍스트에서 분리하여 더 이상 영속성 컨텍스트에 의해서 관리되지 않도록 한다.

4. 삭제(removed)

삭제된 상태

em.remove(member);

엔티티를 영속성 컨텍스트와 데이터베이스에서 삭제한다.

영속성 컨텍스트의 장점

1. 1차 캐시
2. 동일성(identity) 보장
3. 트랜잭션을 지원하는 쓰기 지연 (Transactional write-behind)
4. 변경 감지 (Dirty checking)
5. 지연 로딩 (Lazy Loading)

1. 1차 캐시

영속성 컨텍스트의 내부에는 1차 캐시 라는 것이 있다. 영속성 컨텍스트에 의해 관리되는 영속 상태의 엔티티를 여기에 저장한다. 이 1차 캐시에는 키와 값이 존재하는데, 여기서 키는 데이터베이스의 PK(식별자 값)이며, 값은 Entity 객체 자체이다.

1-1. 1차 캐시에서 조회 방법

Member member = new Member()
member.setId(1L);
member.setName("홍길동");

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

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

위의 코드를 살펴보면 조회의 흐름을 다음과 같다.

1. 데이터베이스가 아닌 1차 캐시에서 조회한다.
2. 조회하는 값이 있으면, 엔티티를 반환한다.
3. 조회하는 값이 없으면, 데이터베이스에서 조회한다. (이때는 select 쿼리 전송)
4. 데이터베이스에서 찾은 엔티티를 1차 캐시에 저장한다.
5. 엔티티를 반환한다.

위의 흐름을 통해 알 수 있듯이, 만약 1차 캐시에 1L번의 member 객체가 존재하지 않아 데이터베이스에서 엔티티를 찾아왔다면, 이후 1번 member 객체를 다시 찾을때는 DB가 아닌 1차 캐시에서 찾아오는 것을 알 수가 있다. 물론 데이터베이스에 SELECT 쿼리도 전송되지 않는다.

동일성(identity) 보장

Member a = em.find(Member.class, "101L");
Member b = em.find(Member.class, "101L");

System.out.print(a == b)     // true

먼저 위와 같이 조회를 했을 때, 아래와 같이 한번의 쿼리가 전송된다.

위에서 알아봤듯이, 1차캐시에서 조회했지만 존재하지 않은 101번 객체는, 데이터베이스에서 조회하게 되며 1차 캐시에 저장되었다. 이로 인해서 a객체를 조회할 때 1번의 조회 쿼리만 동작한 것이다.

이와 같이 1차 캐시가 있기 때문에 마치 자바 컬렉션에서 꺼낸 것과 같이 동일성 보장이 되며, a와 b의 비교 결과가 true로 나온 것이다.

3. 트랜잭션을 지원하는 쓰기 지연 (Transactional write-behind)

쓰기 지연이란 생성한 쿼리를 SQL 저장소에 모아두었다가 트랜잭션 commit() 시점에 플러시가 되면서 데이터베이스에 sql을 전송하는 것을 말한다.

쓰기 지연 흐름

EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();

transaction.begin(); // [트랜잭션] 시작

em.persist(memberA);
em.persist(memberB);

transaction.commit();

영속성 컨텍스트 안에는 1차 캐시와 쓰기 지연 SQL 저장소가 존재한다. 객체를 persist( )하면, 1차 캐시에 들어가는 동시에, JPA는 이 엔티티를 분석하면서 쿼리를 생성한다. 이렇게 생성한 쿼리는 쓰기 지연 SQL 저장소에 쌓아둔다.

코드를 보자면, em.persist(memberA);로 memberA 객체가 1차 캐시에 들어갔다. 이와 동시에 JPA는 memberA 객체를 분석해 INSERT 쿼리를 작성한다. 작성한 쿼리는 쓰기 지연 SQL 저장소에 둔다. em.persist(memberB); 다음 memberB 객체가 persist( )되면서 1차 캐시와 쓰기 지연 SQL 저장소에 쿼리가 쌓이게 된다.

이후 transaction.commit();이 되면서 쓰기 지연 SQL 저장소에 있던 쿼리가 모두 데이터베이스에 반영된다.

추가적으로 hibernate.batch_size라는 것을 이용하면 사이즈만큼 모아서 한번에 네트워크로 전송할 수도 있다.

4. 변경 감지 (Dirty checking)

변경 감지라는 것은 JPA에서 엔티티를 수정할 때의 변경 방식을 말한다.

Member member = em.find(Member.class, 150L);
member.setName("zzz");

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

// 트랜잭션 commit
tx.commit();

150번 Member 객체를 찾아서 zzz로 name을 수정해주었다. 단순히 set()으로 값을 수정하고 persist()나 다른 무언가를 해주지 않아도 데이터베이스에 update 쿼리가 전송되는 것을 볼 수 있다.

1차 캐시에는 이전에 설명한 pk, 엔티티와 스냅샷이 있다.

스냅샷 - 최초 영속성 컨텍스트에 들어온 1차 캐시 상태

이 스냅샷은 값을 읽어온 최초시점의 상태를 떠두는 것이다. JPA는 데이터베이스 트랜잭션을 커밋하는 시점에 내부적으로 플러시가 호출 되는데, 이 과정에서 엔티티와 스냅샷을 비교한다. 변경된 값이 존재하면 업데이트 쿼리를 쓰기 지연 SQL 저장소에 만들어 두고 플러시 한 뒤, 데이터베이스 트랜잭션을 커밋한다.

이러한 과정을 통해서 persist( ) 할 필요 없이 커밋 시점에 엔티티가 관리되는 것이다.

플러시 (Flush)

플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영하는 것을 말한다. 보통 데이터베이스 트랜잭션이 커밋될 때 이 플러시라는 것이 일어난다. 앞에서 보았듯이 쌓아둔 SQL 쿼리들을 플러시를 통해서 영속성 컨텍스트의 현재 변경사항과 데이터베이스를 맞춰주는 것이다.

플러시 흐름

1. 데이터베이스 트랜잭션 커밋이 발생하면 플러시는 자동으로 일어난다.
2. 변경 감지 (Dirty checking)
3. 수정된 엔티티를 쓰기지연 SQL 저장소에 등록
4. 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송(등록, 수정, 삭제 쿼리)

데이터베이스에 쿼리 전송 -> 데이터베이스 트랜잭션 커밋 순서로 동작한다.

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

1. em.flush - 직접 호출
2. 트랜잭션 커밋 - 플러시 자동 호출
3. JPQL 쿼리 실행 - 츨러시 자동 호출

코드로 알아보기

Member member = new Member(200L, "member200");
em.persist(member);

em.flush();

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

tx.commit();

위의 코드의 결과로는 아래와 같은 결과가 나온다. 원래대로라면 commit하는 시점에 쿼리가 전송되기 때문에 "=========" 선 아래에 INSERT 쿼리가 작성되어야 하지만, 그 전에 flush를 강제 호출 했기때문에 INSERT 쿼리가 즉시 전송된 것이다.

플러시 정리

1. 플러시를 한다고 해서 1차 캐시가 지워지지는 않는다. 즉, 영속성 컨텍스트를 비우는 것이 아니다.
2. 영속성 컨텍스트의 변경 내용을 데이터베이스에 동기화시키는 것이다.
3. 트랜잭션이라는 작업 단위가 중요 -> 커밋 직전에 동기화

이렇게 JPA의 영속성 컨텍스트에 대해서 알아보았다. 영속성 컨텍스트는 JPA를 이해하는데 가장 중요한 용어이다. 눈에 보이지 않고 논리적인 개념으로 어렵게 느껴졌던 영속성 컨텍스트를 이렇게 정리함으로 잘 이해할 수 있었다.

본 내용은 인프런의 자바 ORM 표준 JPA 프로그래밍 - 기본편 강의를 수강하고 정리한 글입니다.

JPA의 동작 방식을 알아보자!

위의 그림을 보고 설명하자면, 먼저 JPA는 Persistence 클래스가 존재한다. 이 클래스는 개발자가 작성한 persistence.xml에서 설정 정보를 읽어와 EntityManagerFactiory라는 클래스를 만든다. 이렇게 만든 EntityManagerFactory에서는 뭔가 필요할 때마다 EntityManager를 찍어내 만든다.

🔗 코드로 확인하기

public class JpaMain {

    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        em.close();
        emf.close();
    }
}

해당 코드를 처음부터 자세히 확인해보자.

public class JpaMain {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("")
}

Persistence라는 클래스의 createEntityManagerFactory()를 통해서 EntityManagerFactory를 반환해 준다. 여기에서 createEntityManagerFactory()안에는 PersistenceUnitName을 넘기라고 한다.

이것은 persistence.xml 파일의 persistence-unit에 설정한 name을 넘겨주면 된다.

public class JpaMain {

    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        em.close();
        emf.close();
    }
}

다음은 EntityManagerFactory에서 createEntityManager()를 꺼낸다. 실제 애플리케이션이 끝나면 EntityManagerFactory를 닫아주기 위해서 close(); 해준다.

🔍 동작 확인하기

위의 내용을 코드를 통해 확인해보자!

저장하기

데이터베이스에 Member 테이블을 생성해주고, JPA에 엔티티를 추가해준다. 그리고 아래와 같이 member를 생성해준다.

    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

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

        em.persist(member);

        em.close();
        emf.close();
    }

하지만 이렇게 실행할 경우 에러가 발생하는데, JPA는 데이터를 변경하는 작업은 반드시 Transaction 안에서 작업해야 하기 때문이다.

여기서 중요한 것은 엔티티 매니저 팩토리는 애플리케이션 로딩 시점에 하나만 생성하여야 하고, 트랜잭션 단위는 DB 커넥션을 얻어 쿼리를 날리고 종료되는 단위마다 엔티티 매니저를 통해 실행된다. 간단하게 생각하자면 엔티티 매니저는 DB 커넥션이라고 할 수 있다.

public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

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

        em.persist(member);
        tx.commit();

        em.close();
        emf.close();
    }

1. 엔티티 매니저에서 getTransaction()으로 트랜잭션을 얻는다.
2. begin() - 트랜잭션 시작
3. member를 만들고
4. em.persist(member)로 member를 저장
5. tx.commit() - 커밋

쿼리와 데이터베이스에 helloA 멤버가 저장된 것을 확인할 수 있다.

또한 이것으로 확인 할 수 있는 것은, 내가 직접 쿼리를 작성할 필요 없이, JPA가 매핑정보를 통해 모든 것을 해준다는 것이다.

위와 같이 코드를 작성할 경우 문제 발생 가능성이 존재한다. 만약 em.persist(member); 나 tx.commit(); 시점에 문제가 생기게 되면, EntityManager close()와 EntityManagerFactory close()가 모두 호출되지 않기 때문이다.

따라서 try-catch 문을 통해 문제가 일어났을 경우에도 코드가 올바르게 동작하도록 수정해주어야 한다.

    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            Member member = new Member();
            member.setId(2L);
            member.setName("HelloB");

            em.persist(member);
            tx.commit();

        } catch (Exception e) {
            tx.rollback();

        } finally {
            em.close();
        }
        emf.close();
    }

1. try문 안에 시도할 코드를 넣어준다. Member를 생성하고, commit()한다.
2. 만약 이 과정까지에서 문제가 발생한다면 catch문에서 Exception이 발생하고 rollback() 한다.
3. 작업이 끝나면 finally문에서 EntityManager를 닫아준다. EntityManager가 결국 내부적으로 데이터베이스 커넥션을 얻어 동작하는 것이기 때문에 반드시 닫아주는 것을 잊지 말자.
4. 전체 애플리케이션이 끝나면 EntityManagerFactory까지 close()해준다.

이렇게 JPA의 동작에 대해서 알아보았다. 하지만 실제로는 이렇게 EntityManager를 생성할 필요 없이 spring이 이러한 것을 해주기 때문에 호출해서 더욱 편하게 사용할 수 있다.

조회하기

 public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            Member findMember = em.find(Member.class, 1L);
            System.out.println("찾은 회원 이름 : "+ findMember.getName());

            tx.commit();
        } catch (Exception e) {
            tx.rollback();

        } finally {
            em.close();
        }
        emf.close();
    }

1. EntityManager에서 find()해준다. 이 엔티티 매니저는 자바 컬렉션과 같이 이해하면 된다.

select 쿼리로 회원을 찾은 것을 볼 수 있다.

삭제하기

 public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            Member findMember = em.find(Member.class, 1L);

            em.remove(findMember);

            tx.commit();
        } catch (Exception e) {
            tx.rollback();

        } finally {
            em.close();
        }
        emf.close();
    }

remove(); 메소드 안에 삭제할 멤버를 넣어주면 Delete 쿼리가 나가면서 삭제된다.

수정하기

  public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            Member findMember = em.find(Member.class, 1L);
            findMember.setName("HelloJPA");

            tx.commit();
        } catch (Exception e) {
            tx.rollback();

        } finally {
            em.close();
        }
        emf.close();
    }

set() 메서드로 변경할 이름으로 바꾸어준다. 여기서 em.persist로 변경한 이름을 저장해주어야 하는게 아닌가? 라는 생각을 할 수도 있지만, 저장하지 않아도 된다.

쿼리를 확인해보면 UPDATE 쿼리가 나간 것을 볼 수 있다.

데이터베이스에 변경한 이름인 helloJPA로 이름이 변경된 것을 확인했다.

그렇다면 저장하지 않았음에도 어떻게 해서 이름을 변경할 수 있는 것일까? 그 이유는 JPA를 통해서 엔티티를 가져오게 되면, 가져온 엔티티는 JPA가 관리를 하게 된다. 이후 트랜잭션 커밋 시점에 관리되는 엔티티는 변경 사항을 체크한다. 트랜잭션이 커밋하기 직전에 UPDATE 쿼리를 실행해 변경사항을 수정하고 트랜잭션이 커밋된다.

프로그래머스 문제를 풀다가 replaceAll()이라는 메소드를 발견하여 알아보았다. 또한 replace()와의 차이가 궁금해 정리해 보았다.

문제명: rny_string

먼저 해당 코딩테스트 문제는 다음과 같다.

문제 설명

'm'과 "rn"이 모양이 비슷하게 생긴 점을 활용해 문자열에 장난을 하려고 합니다. 문자열 rny_string이 주어질 때, rny_string의 모든 'm'을 "rn"으로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항

• 1 ≤ rny_string의 길이 ≤ 100
• rny_string은 영소문자로만 이루어져 있습니다.

입출력 예

즉, 문자열에 m이 있으면 그것을 rn으로 바꾸어 return 하는 것이다.

👉 해당 문제 풀이 보러가기

https://github.com/sooyv/Programmers-Algorithm-JS/commit/455734a9270b72a5371d2a824c8761461d6285c3

먼저 replaceAll()에 대한 MDN의 설명을 찾아보았다. MDN에 따르면 설명은 다음과 같다.

replaceAll()은 String객체에 추가된 새로운 메소드이다. 역할은 문자열에서 특정 문자를 지정한 문자열로 변경하는 역할을 한다.

이것과 비슷한 역할을 하는 메소드로 replace()메소드가 있는데, replace()는 정규식을 통해 찾은 문자열을 지정한 문자열로 바꾸는 역할을 한다.

하지만 replaceAll()을 이용하면, 문자열을 직접 지정해서 바꿔버릴수 있기 때문에 더욱 편리하게 사용이 가능하다.

replace()

또한, 공부를 하던 중 replace()에 대해 더욱 자세히 알 수 있었다. replace()의 예시를 보자.

위와 같이, “m”을 “rn”으로 바꾸었을 때, “mom”의 “rnom”은 바뀌지 않았다. 즉, replace()의 경우 첫번째 문자만 변경이 되는 것을 확인하였다.

replaceAll()

하지만 replaceAll()의 경우 해당 문자열 전체를 바꾼다.

이렇게 편리하게 사용할 수 있는 replaceAll()이지만, ES2021이 도입되지 않은 곳에서는 메서드를 사용 할 수 없다는 문제점이 있었다. 따라서 또 다른 방법으로 replaceAll()을 구현해 보았다.

replaceAll() 구현하기

replaceAll()을 사용하기 위한 방법은 split()과 join()을 사용하는 것이다.

• split을 통해 전체 문자열을 작성한 문자열을 기준으로 나눠 배열로 저장한다.

let str = "hello mom";
str = str.split("m");
console.log(str);
// ['hello ', 'o', '']

• join()을 사용하여 만든 배열을 하나의 문자열로 합쳐준다.

‘m’을 “rn”으로 바꿔줘야하는 것이기 때문에, 배열 사이에 “rn”을 추가한다.

let str = "hello mom";
str = str.split("m");
str = str.join("rn");
console.log(str);
// hello rnorn

👉 해당 문제 풀이 보러가기

https://github.com/sooyv/Programmers-Algorithm-JS/commit/455734a9270b72a5371d2a824c8761461d6285c3

오늘은 프로그래머스 문제 풀이 중, 꼬리 문자열 문제에서 reduce()를 사용한 다른 사람의 풀이를 보았다.

평소 자주 접하는 함수이지만, 헷갈리던 부분에 대해서 명확하게 알고 사용하고자 reduce()함수에 대해 정리해보았다.🧐

reduce 함수는 “줄이다”라는 의미로 누산기라고 생각하면 된다.

리듀서 함수는 네 개의 인자를 가진다.

1. 누산기 (acc)
2. 현재 값 (cur)
3. 현재 인덱스 (idx)
4. 원본 배열 (src)

구문

arr.reduce(callback[, initialValue])

매개변수

callback

배열의 각 요소에 대해 실행할 함수. 다음 네 가지 인수를 받는다.

accumulator

누산기는 콜백의 반환값을 누적한다. 콜백의 이전 반환값 또는, 콜백의 첫 번째 호출이면서 initialValue를 제공한 경우에는 initialValue 값

currentValue

처리할 현재 요소.

currentIndex

Optional처리할 현재 요소의 인덱스. initialValue를 제공한 경우 0, 아니면 1부터 시작

array 

reduce()를 호출한 배열.

initialValue 

callback의 최초 호출에서 첫 번째 인수에 제공하는 값. 초기값을 제공하지 않으면 배열의 첫 번째 요소를 사용하고 빈 배열에서 초기값 없이 reduce()를 호출하면 오류가 발생

사용방법

1. 가장 기본적인 형태

두 개의 인자 - acc accumulator : 누산기, 누적되는 값, 최종적으로 출력되는 값 - cur current : 현재 돌고 있는 요소

const numbers = [1, 2, 3, 4];
let sum = numbers.reduce((acc, cur) => acc + cur);

이것을 풀어서 보면 다음과 같다.

const numbers = [1, 2, 3, 4];
let sum = numbers.reduce((acc, cur) => {
    return acc + cur;
});

동작 흐름을 자세히 보자면 이렇다.

acc 에는 가장 첫 번째 원소인 '1'를 할당하고 (index 0) cur 에는 나머지 원소인 '2, 3, 4'가 순차적으로 들어간다.

acc += cur; // 1 += 2;
acc += cur; // 3 += 3;
acc += cur; // 6 += 4;

console.log(acc); // 10

2. 초기값이 추가된 형태

2개의 인자 + 1개의 초기값 - acc accumulator : 누산기, 누적되는 값, 최종적으로 출력되는 값 - cur current : 현재 돌고 있는 요소 - initialValue : acc의 초기값 (optional)

const numbers = [1, 2, 3, 4];
let sum = numbers.reduce((accumulator, current) => accumulator + current, 0);
console.log(sum);

내가 가장 헷갈렸던 부분이 이 부분이다.

초기값을 할당할 경우 배열의 인덱스는 할당된 초기값이 인덱스 0번이 되어 돌아간다.

acc += cur; // 0 += 1;
acc += cur; // 1 += 2;
acc += cur; // 3 += 3;
acc += cur; // 6 += 4;

console.log(acc); // 10

하나 더 예시를 들어보자면, 다음과 같이 초기값 initialValue 를 10으로 할당했을 때, 동작은

const numbers = [1, 2, 3, 4];
let sum = numbers.reduce((accumulator, current) => accumulator + current, 10);
console.log(sum);

acc += cur; // 10 += 1;
acc += cur; // 11 += 2;
acc += cur; // 13 += 3;
acc += cur; // 16 += 4;

console.log(acc); // 20

위와 같이 되는 것이다.

3. 두 개의 인자 추가하기

4개의 인자 + 1개의 초기값 - acc accumulator : 누산기, 누적되는 값, 최종적으로 출력되는 값 - cur current : 현재 돌고 있는 요소 - idx index : 배열 요소의 순서 (optional) - arr array (또는 src source) : 현재 배열, 원본 배열 (optional) - initialValue : acc의 초기값 (optional)

다음은 평균을 구하는 reduce 함수이다.

마지막에만 나누기를 위해서 index와 arr를 불러왔다.

const avg = numbers.reduce((acc, cur, index, arr) => {
    if (index === arr.length - 1) { // index가 마지막일 때
        return (acc + cur) / arr.length; // cur - 4
    }
    return acc + cur; // cur - 1, 2, 3
    }, 0);
ㅤ
console.log("avg", avg);

👉 해당 문제 풀이 보러가기

https://github.com/sooyv/Programmers-Algorithm-JS/commit/fddf8341a41fead185b3d0e48e45312efad4f94e

소감

꽤 자주 사용하지만 매번 헷갈렸던 메소드를 정확히 알게 되어 가려운 부분을 확실히 긁은 느낌이다. 이번 기회로 기초를 단단히 해놓을 수 있어 다행이라고 생각한다. 앞으로도 빠르게 대충 아는 것보다 하나를 알아도 확실하게 알고자하며 공부를 해야겠다.✊

오늘도 역시 프로그래머스 문제 풀이 중 알게 된 every() 함수에 대해 알아보기로 했다.

.every() every() 메서드는 배열 안의 모든 요소가 주어진 판별 함수를 통과하는지 테스트합니다. Boolean 값을 반환합니다.

즉, 배열의 모든 원소가 주어진 조건을 만족하는지 판별해 모두 만족한다면 ture를, 하나라도 만족하지 않는다면 false를 return 한다.

구문

// 화살표 함수
every((element) => { ... } )
every((element, index) => { ... } )
every((element, index, array) => { ... } )

// 콜백 함수
every(callbackFn)
every(callbackFn, thisArg)

// 인라인 콜백 함수
every(function callbackFn(element) { ... })
every(function callbackFn(element, index) { ... })
every(function callbackFn(element, index, array){ ... })
every(function callbackFn(element, index, array) { ... }, thisArg)

매개변수

callbackFn 각 요소를 시험할 함수. 다음 세 가지 인수를 받습니다.

element 배열에서 처리되는 현재 요소

index 처리할 현재 요소의 인덱스

array every를 호출한 배열

thisArg Optional callbackFn을 실행할 때 this로 사용하는 값.

반환값

callbackFn이 모든 배열 요소에 대해 참(truthy)인 값을 반환하는 경우 true, 그 외엔 false 를 반환합니다.

예제

배열 요소의 크기 테스트

let arr1 = [1, 2, 3, 4, 5];

let result = arr1.every((e) => e > 2);
console.log(result);     // false
// 배열의 모든 요소가 2보다 크다는 조건에 만족하지 않았기 때문에 false 반환


let arr2 = [5, 6, 7, 8, 9];
let result = arr2.every((e) => e > 4);
console.log(result);    // true 
// 배열의 모든 요소가 4보다 크다는 조건에 만족하기 때문에 true 반환

👉 해당 문제 풀이 보러가기

every() 함수 문제풀이 보러가기 - programmers-js-github

프로그래머스 문제 중 배열의 원소만큼 추가하기를 풀다가 다음과 같은 풀이를 보게 되었다.

function solution(arr) {
    return arr.reduce((list, num) => [...list, ...new Array(num).fill(num)], []);
}

이 중 fill()함수에 대해서 알아보고, 이 코드에서 fill()함수가 어떻게 동작하는지 알기 위해서 정리해보고자 한다.

MDN 설명에 따르면

fill() 메서드는 배열의 시작 인덱스부터 끝 인덱스의 이전까지 정적인 값 하나로 채우는 메서드이다.

const array1 = [1, 2, 3, 4];

// Fill with 0 from position 2 until position 4
console.log(array1.fill(0, 2, 4));
// Expected output: Array [1, 2, 0, 0]

// Fill with 5 from position 1
console.log(array1.fill(5, 1));
// Expected output: Array [1, 5, 5, 5]

console.log(array1.fill(6));
// Expected output: Array [6, 6, 6, 6]

Array.prototype.fill() - JavaScript | MDN

구문

arr.fill(value[, start[, end]])

매개변수

예제

arr.fill(’L’, 1, 3)

fill() 메서드는 배열의 start index부터 end index 전까지(end index는 미포함) value값으로 채워주는 함수입니다.

index()가 음수일 때

start나 end index가 음수로 지정되면 배열의 마지막 원소의 index가 -1이 되고,앞으로 올수록 인덱스가 감소한다.

arr.fill(’L’, -3, -1)

fill()을 이용한 배열 초기화

const arr = new Array(5).fill('A');

new Array() 구문을 사용하여 배열을 생성하면,

5개의 element를 가지는 배열이 생성되고,

각 element의 값은 undefined입니다.

여기에 fill() 함수를 사용하면, 생성된 배열의 element의 초기값을 지정할 수 있다.

👉 해당 문제 풀이 보러가기

https://github.com/sooyv/Programmers-Algorithm-JS/commit/7a620cd778abc8fe1685066def96cd6ae717d111

$: 사용자 #: 관리자

1. ls 명령어

List 현재 위치의 파일/디렉터리 목록을 출력

ls -a : 숨김파일도 전부 출력 ls -l : 상세출력 ls -la : 숨김파일도 전부 상세출력

2. cd 명령어

Change Directory

경로 이동 문자 . : 현재 경로 .. : 이전 경로

~ : 현재 로그인한 사용자의 Home 디렉터리 / : 최상위 디렉터리

홈 디렉터리로 이동 ==> cd ~

경로이동방법 상대경로 : 현재 내가 있는 위치를 기준으로 이동 절대경로 : [/]를 기준으로 이동

ex) 현재 내가 /home/so.oyv/test 폴더 안에 있다. home 폴더로 이동하는 절대경로 방법과 상대경로 방법은? cd /home --> 절대경로 cd ../.. --> 상대경로

3. mkdir

make directory 새로운 폴더 생성하기

4. rmdir

remove directory

• rmdir은 실제 사용하지 않음 문제점 : 폴더 안에 다른 파일이 있으면 삭제불가

5. rm

Remove 삭제 명령어 디렉터리든, 파일이든 어떤 파일도 삭제가 가능 rm -r 명령어를 사용해도 삭제가 가능

6. cat 명령어

concatenate 파일의 글[코드]를 읽을 때 사용 ex) cat /etc/passwd

7. vi 명령어 --> 이 외에도 vim 혹은 그래픽모드면 gedit 등 다양한 메모장 프로그램이 있다.

윈도우로 생각하면 메모장 종료 방법 : [:] 입력 후 [q] [Enter]

8. head 와 tail

기본 10줄을 출력한다 head : 위에서 10줄 tail : 아래에서 10줄 만약 5줄만 출력하고 싶다면? -head -5

9. more

많은 글씨가 있으면, 페이지 단위로 끊어서 보여준다 페이지 앞으로 이동 : [Space Bar] 페이지 뒤로 이동 : [b]

10. touch

0kb 파일을 생성하거나, 파일이 존재하면 수정시간 변경

11. mv

move + 이름바꾸기

mv [원본파일] [이동 및 바꿀 파일]

12. cp

파일을 복사한다

13. su

switch user 유저를 변경한다. su 만 치면 root계정으로 접속

14. sudo

관리자권한 super user do

15. Op Code // Operand

int a = 30; mv /home/kitri/test.txt /tmp/abcd.txt

OP code = 명령어 Operand = 주소

mv /home/so.oyv/test /tmp/abcd

touch /home/so.oyv/test

mvc란 Model, View, Controller의 약자이다.

작동 원리

url에서 name=spring!! 을 받았다.

1. Controller?

Controller의 @RequestParam 어노테이션으로 파라미터로 넘어온 "name"을 가져오고, String name은 spring!!이 된다. 이렇게 가져 온 데이터는 model이라는 변수에 addAtrribute에 담아준다.

return "hello-template";

hello-template.html과 매핑된다

2. View

hello-template.html으로 model이 전달되고, ${name}에는 key : name 의 value 값인 spring!!이 전달된다.

✅ 정리!

웹브라우저에서 localhost:8080/hello-mvc를 넘기면 스프링 부트가 띄울때 같이 띄워지는 내장 톰켓 서버를 먼저 거치게 된다. 내장 톰켓 서버는 hello-mvc를 스프링에 던진다. 스프링에서는 Controller에 매핑되어 있는지 찾은 뒤, 매핑되어 있는 메서드를 호출해준다. 리턴시 hello-template으로 하고, key:name, value:spring!! 인 model을 스프링에게 넘겨준다. 스프링은 viewResolver가 view를 찾아주고 템플릿 엔진과 연결시켜준다. viewResolver는 return: hello-template과 똑같은 templates/hello-spring.html을 찾아서 thymeleaf 템플릿 엔진에게 처리를 넘긴다. 템플릿 엔진은 랜더링 후 변환을 한 html을 웹브라우저에 반환한다.

정적일때는 변환하지 않고 그대로 넘겨준다.

자바스크립트의 여덟가지 자료형 중 일곱개는 오직 하나의 데이터(string, number...)만을 담을 수 있어 '원시형(primitive type)'이라고 부른다. 하지만 객체형은 다양한 데이터를 담을 수 있다.

2. 객체의 생성

객체는 중괄호{}를 이용해 만든다. 중괄호 안에는 '키(key):값(value)'쌍으로 구성된 프로퍼티(property)를 여러 개 넣을 수 있다. 이때 키(key)에는 문자형, 값(value)에는 모든 자료형이 허용된다.

비어있는 객체를 만드는 방법은 두 가지가 있다.

1 let user = new object(); // '객체 생성자'
2 let user = {};           // '객체 리터럴'

이때 1번은 '객체 생성자' 문법이고 2번은 '객체 리터럴' 문법이라고 한다.

3. 리터럴과 프로퍼티

중괄호{} 안에는 '키:값'의 쌍으로 구성된 프로퍼티가 들어간다.

let user = {
    name: "chloe",       //키: "name", 값: "chloe"
    age: 24,             //키: "age", 값: 24
    sex: female            //키: "sex", 값: "female"
};

이렇게 되면, 객체 user에는 세 개의 프로퍼티가 생성된 것이다.

1. "name" 과 "chloe"
2. "age" 와 24
3. "sex" 와 "female"

쉽게 생각하자면, user라는 이름을 가진 서랍 안에, name, age, sex라는 세 개의 파일(프로퍼티)이 담겨있는 것이라고 생각하면 된다.

4. 프로퍼티 추가와 삭제

프로퍼티 추가

user. isAdmin = ture;

프로퍼티 값에는 모든 자료형이 올 수 있다. 불린형 프로퍼티를 추가해 보았다.

프로퍼티 삭제

delete user.sex;

delete 연산자를 사용하면 프로퍼티를 삭제할 수 있다.

5. 값 표기법

프로퍼티 키를 만든 다음엔 점 표기법 또는 대괄호 표기법을 프로퍼티에 접근해 값을 읽을 수 있다. 다음은 각각 user 객체의 name에 접근하는 표기법이다.

5-1. 점(.) 표기법

user.name        // "chloe"

점 표기법은 키가 '유효한 변수 식별자’인 경우에만 사용할 수 있다. 공백이 없고, 숫자로 시작하지 않아야하며, $와 _를 제외한 특수 문자가 없어야 한다.

5-2. 대괄호([]) 표기법(square bracket notation)

user["name"]

유효한 변수 식별자가 아닌 경우에는 대괄호 표기법을 사용한다. 대괄호 표기법을 사용할 때에는 ' '또는 " " 따옴표로 묶어 사용해야 한다. 이 경우 여러 단어를 조합해 만든 공백이 있는 프로퍼티를 불러올 수 있다는 장점이 있다.

예를 들어, user라는 객체에 "show vidio"라는 프로퍼티가 있다고 해보자.

user.show vidio

점 표기법을 사용해 작성하면, 자바스크립트는 위와 같은 코드를 이해하지 못할 것이다. use.show 까지는 이해하더라도, 이후 공백 때문에 vidio는 syntax error가 발생한다.

user['show vidio']

이 경우 대괄호 표기법을 사용하는 것이다.

css란 Cascading Style Sheets 의 약자로 이 중 중요한 것은 바로 Cascading이다. 스타일 시트에서 코드의 충돌이 일어나지 않도록 우선순위를 아는것은 중요하다. 우선순위를 알지 못하면 내가 원하는 대로 또는 예상한대로 코드가 나오지 않는 경우가 일어날 수 있다.

캐스케이딩의 우선순위를 결정하는 요인은 다음 세가지이다.

cascading 우선순위

1. Importance(중요도)
2. Specificity(명시도)
3. Source order(코드순서)

1. Importancs(중요도)

css가 어디에 선언 되었느냐에 따라 우선순위가 달라진다.

• head 요소 안의 style 요소
• head 요소 안의 style 요소 안의 @import
• <link> 로 연결된 CSS 파일
• <link> 로 연결된 CSS 파일 내의 @import
• 브라우저 디폴트 스타일시트

2. Specificity(명시도)

태그 속성에 스타일을 줄 때 선택자를 사용한다. 이 선택자를 선언할때 선택자의 유형에 따라 가중치가 주어지고 우선순위가 결정된다. 대상을 명확하게 특정할수록 우선순위가 높아진다.

** style > id > class, pseudo-element > 태그**

class 선택자와 id 선택자가 있을 경우 id 선택자가 우선된다.

<style>
/* 1. specificity: 1-0-1 */
#outer a {
    background-color: red;
}

/* 2. specificity: 2-0-1 */
#outer #inner a {
    background-color: blue;
}
<style>

<body>
    <div id="outer" class="container">
        <div id="inner" class="container">
            <ul>
                <li class="nav"><a href="#">One</a></li>
                <li class="nav"><a href="#">Two</a></li>
            </ul>
        </div>
    </div> 
<body>

위의 경우 첫번째에는 id 1개, class 0개, element 1개이지만, 두번째 코드에서 id 선택자가 2개로 우선순위가 정해졌다. 따라서 background-color는 blue가 된다.

** !important > style > id > class, pseudo-element > 태그**

이 모든 것을 무효화 하는 것이 !important 이다. 이것은 cascading의 우선 순위를 무시한다. 하지만 남용하지 말고 주의해서 사용해야한다.

3. Source order(코드순서)

동일한 가중치를 갖는 요소가 두개 이상인 경우, 마지막에 선언된 코드가 우선된다. 이는 앞에 쓰인 코드가 뒤에 쓰인 코드에 의해 덮여쓰인다고 할 수 있다.

<style>
 h1 {
   color: red;
 }

h1 {
   color:blue;
}
</style>


<div>
  <h1>Hello</h1>
</div>

위의 경우 h1 태그에 적용되는 색상은 blue이다.

참고 MDN - Cascade and inheritance

키(Key)

키는 무엇인가를 식별한다는 의미를 갖고 있다. 키란 데이터베이스의 관계에서 특정 튜플을 식별할 때 사용하는 속성 또는 속성의 집합을 말한다.

후보키(Candidate Key)

후보키는 기본키가 될 수 있는 후보가 될 수 있는 모든 키를 의미한다. 기본키도 후보키에 속한다. 후보키 중 기본키로 지정되지 않은 키를 보조키라고 한다.

기본 키(Primary key)와 외래 키(Foreign key)

기본 키(Primary key : PK)

관계형 데이터베이스에서 테이블 내의 식별자로 이용하기 가장 적합한 컬럼에 정의되는 키이다. 테이블에는 각 행을 고유하게 식별하는 값을 가진 열들이 있다. 이러한 열의 조합을 기본키(PK)라고 하며 테이블의 엔티티(Entity)의 무결성에 사용된다. 기본기 선정의 몇가지 조건은 다음과 같다.

• 테이블은 오직 하나의 Primary key값을 가진다.
• NULL값을 허용하지 않는다.
• 값의 중복이 없어야 한다.
• 키 값이 변하지 않아야 한다.
• 최대한 적은 수의 속성을 가진 것이 좋다.

외래 키(Foreign key : FK)

외래 키는 두 테이블 간 연결을 설정한다. 즉, 어떤 테이블에 포함되어 있으면서, 다른 테이블에서 기본 키를 참조하여 두 테이블 간의 관계를 나타낸다.

• 외래 키는 관계를 표현한다.
• 외래 키는 기본 키와 다르게 하나의 테이블에 여러 개를 지정 할 수 있다.
• 외래 키는 NULL값과 중복 값이 허용된다.
• 참조되는 값이 변경되면 참조하는 값도 변경된다.
• 외래 키는 기본 키의 일부가 될 수 있다.

관계형 데이터베이스에서 두 테이블 간 관계를 연결하는 방법은 부모테이블의 기본 키(Primary key)와 자식테이블의 외래 키(Foreign key)이다.

위의 테이블을 보면 수강 테이블의 외래 키(PK)가 학생테이블의 주 키(Primary key) '학번'에 참조 되어 있는 것을 볼 수 있다. 이것은 학생 테이블이 기본키인 학번이 수강 테이블의 외래키로 전이 되었다고 표현 할 수 있다. 학번은 각 학생의 고유한 값으로 중복 될 일이 없다. 만약 이름이 똑같은 학생이 있을 경우 유일성을 만족하지 못한다. 전공도 마찬가지로 중복의 가능성이 있으므로 Primary key의 조건에 위배된다.

위의 테이블에는 학생테이블과 수강테이블이 있다. 하지만 학생 테이블의 정보와 수강테이블의 정보를 어떻게 연결할 것인가에 대한 문제점이 생긴다. 학생 테이블을 통해 학생의 정보를 알 수는 있지만, 수강 테이블의 정보가 어느 학생의 정보인지 알 수 없다는 것이다.

이와 같은 문제를 해결하기 위해서 '관계'라는 개념이 필요하다.

1. 관계란?

관계형데이터베이스에서의 관계란 테이블 간 업무적인 연관성을 뜻한다. 테이블을 한 업무로 생각하고, 테이블 간 업무적 연관성을 생각해보면 '관계'를 알 수 있는 것이다.

위의 학생테이블과 수강테이블의 연관성은 학생의 성적을 알기 위해 만들어진 것이다. 하지만 위의 테이블에서는 수강테이블에 저장된 01111A를 수강하는 학생이 누구인지 알 수 없는 상태이다. 이를 알기 위해서는 수강 테이블에 등록된 정보 중에는 적어도 하나 이상의 학생 정보를 가지고 있어야 한다. 즉, 현재의 테이블에서는 학생과 수강을 연결할 수 있는 관계가 없기 때문이다.

2. 부모테이블과 자식테이블

두 테이블 간에 관계가 만들어지며, 둘 중 하나의 테이블은 부모(parent)테이블이 되고 다른 하나는 자식(child)테이블이 된다. 이것은 행위의 주체에 따라 구분이 된다. 학생과 수강 두 테이블을 보자면, 학생이 과목을 수강하는 것이기 때문에 학생 테이블이 부모테이블, 수강 테이블이 자식테이블이 된다.

3. 관계의 유형

• 존재의 유형
• 행위의 유형

존재의 유형은 쉽게 소유의 유형이라고 생각하면 된다. 예를 들어 부서와 사원이 있다고 생각해보자. 부서에는 사원이 소속되어 있다. 이것은 어떤 행위에 의해 발생된 일이 아닌, 그냥 그 존재자체의 상태를 말하는 것이다.

행위의 유형은 고객과 주문을 생각해보자. 즉 고객이 주문이라는 행위에 의해 관계가 형성되는 것이다.

위의 테이블은 '학생이 과목을 수강한다'라고 정의 할 수 있다. 그러므로 행위의 유형이다.

정리

• 관계는 두 테이블 사이에 존재하는 업무적인 연관성으로, 행위의 주체에 따라 부모테이블과 자식테이블이 된다.
• 관계는 유형에 따라 존재의 유형 또는 행위의 유형으로 나눠진다.

1-1. 데이터와 정보

데이터베이스를 알기에 앞서 정보란 무엇이고 데이터란 무엇일까? 이 둘은 어떻게 구분 할 수 있을까? 그것은 바로 '가공'의 차이에 있다. '짱구, 철수, 유리, 10, 11, 10, 서울, 부산, 수원'은 각각 있을때 데이터에 불과하다.

1-2. 데이터베이스란?

데이터베이스는 자료의 모음으로 데이터를 체계화 ∙ 구조화하여 통합 관리하는 정보의 집합이다. 이렇게 정리된 데이터는 검색과 갱신의 효율을 높인다.

1-3. 데이터베이스 관리 시스템(DBMS)

데이터베이스를 좀 더 효과적으로 운영하고 관리하고자 하는 목적으로 만들어진 것이 데이터베이스 관리 시스템(Database Managment system)이다. 다수의 사용자 또는 응용프로그램의 요구사항을 관리함으로써 그 데이터가 어디에 어떻게 저장되는지 몰라도 다중 사용자 환경에서 누구나 데이터를 이용할 수 있도록 해준다.

관계형 데이터베이스 시스템(RDBMS)

데이터베이스는 테이블로 구성되며 그 테이블들은 컬럼으로 연결한 것이다. 이때, 각 테이블은 낭비되는 공간 없이 효율적으로 데이터를 저장하도록 한다. 이렇게 나뉘어진 테이블들은 상위 정보를 저장하는 주 키(Primary key)와 하위 정보를 저장하는 테이블의 외래 키(Foreign key)를 이용하여 연결되고 각 테이블의 연관된 정보를 얻을 수 있도록 한다.

1-4. SQL

위의 관계형 데이터베이스 관리 시스템(RDBMS)의 데이터를 관리하기 위해 설계된 것이 SQL이다. SQL은 SQL 구문을 통해 테이블 내의 데이터를 검색하거나 조작하는 등으로 사용된다. 그 구문은 다음과 같다.

SQL 구문의 종류

• 데이터 정의 언어(DDL: Data Definition Language) 데이터를 생성(Create), 수정(Update), 삭제(Delete)하는 역할을 한다.

• 데이터 조작 언어(DML: Data Manipulation Language) 데이터베이스에 등록된 레코드를 조회(Select),수정(Update),삭제(Delete)하는 역할을 한다.

• 데이터 제어 언어(DCL: Data Control Language) 데이터의 사용, 접근에 대한 권한(Grant)을 주는 역할을 한다.

• 트렌젝션 제어 언어(TCL: Transaction Control Language) 트렌젝션을 제어할때 사용한다.

추가공부내용!

이후 추가 공부 내용

• 테이블과 칼럼
• 주 키와 외래키
• SQL구문의 종류