개요

• 웬만하면 퀵셀, 언리얼 마켓플레이스에서 완성된 에셋을 이용하여 건물을 만들어보려 했으나 생각보다 무료인 에셋들 중 맞는 것을 구하기 힘들었고 퀵셀의 타일을 이용하여 새로 만들기로 하였다.

퀵셀의 타일

• 퀵셀의 타일을 이용하면 쉽게 외벽을 만들 수 있으나 문제가 있다. 그냥 사용하면 싱크가 맞지 않는다는 점이다.

• 이를 위해 머터리얼의 타일링을 조절할 수도 있겠지만 더 좋은 방법이 있다. 모델링의 UVs에서 XFormUV를 이용하여 타일링을 내가 원하는대로 쉽게 조작할 수 있다.

• UVs의 다른 기능들을 이용하면 조금은 사실적인 묘사가 가능하다. 이것은 다음 영상을 참고하자

파괴된 에셋 생성: 언리얼 엔진과 함께한 '90일' | 튜토리얼 | 퀵셀

건물 만들기

• 나는 위의 영상에서 만든 사실적인 에셋이 아닌 간단하게 게임의 분위기와 어울리는 에셋만 만들면 된다.

에셋을 만들기 전에 기본이 되는 에셋은 변경되면 안되므로 복사해서 다른 곳에 저장시켜서 그 에셋으로 작업하도록 하자.

• 일단 원하는 기본 토대를 만들고 원하는 머터리얼을 퀵셀에서 입힌다.

• 그냥 쓰기엔 어색하니 위에서 언급한 모델링 모드 - UVs - XFormUV를 이용하여 조절해준다.

※ 한 면만 선택하는 것보다 모든 면을 선택하여 모든 면을 한번에 조절하는 것이 더 자연스럽다.

• 자신이 원하는 모양이 나올 때까지 찾아서 조절해주면 된다.

• 삼인칭 콘텐츠 팩의 캐릭터를 이용하거나 실제 플레이 뷰를 보면서 수정해준다.

• 지금까지도 나쁘진 않지만 너무 어색할 수 있기 때문에 중간에 패턴을 넣기로 하였다

• 모델링 모드의 PolyCut을 이용하여 중간에 다른 에셋이 들어갈 수 있도록 공간을 만들고 Merge로 새로운 에셋을 만들어낸다.

  병합하기 전에 어울리는 머터리얼을 넣고 병합하도록 하자.

• 다른 팀원분이 만들어주신 에셋으로 창고 안쪽에서 잠겨있는 문을 만들었다.

• 구글에 이미지를 찾아서 참고하여 제작하면 훨씬 자연스러운 건물을 완성할 수 있다.

  참고한 이미지

사실적인 콘크리트 바닥 만들기

• 퀵셀의 계단 에셋을 사용하다가 계단은 있지만 계단과 어울리는 바닥은 내가 만들어주어야 하는 경우가 발생하였다. 이로 인해 모델링 모드의 Displace모드 이용이 불가피해졌다.
• 알맞은 텍스쳐는 구했지만 이질감이 든다.

1. 먼저 UV를 생성해주어야한다. 모델링 모드 - UVs - Unwrap 을 이용하면 자동으로 생성해준다.

2. 그다음 Deform - Displace로 자신이 원하는만큼 조절해준다.

• 이렇게 울퉁불퉁하여 조금 더 사실적으로 보인다.

3. 모서리는 다른 기능을 이용하여 다듬어주어야 한다. 원하는 모서리에 복사한 에셋을 맞닿아서 놓는다.

• 깍을 에셋과 복사한 에셋을 순서대로 지정해준뒤 PolyModel - MshBool 을 실행한 후 수락해주면 복사한 에셋은 사라지고 모서리가 깍인것을 확인할 수 있다.

4. 마지막으로 이 에셋의 메모리 사용량을 줄여주는 MeshOps - Simplfy를 사용하여 필요 없는 지오메트리를 없애준다.

• 타깃 퍼센티지를 25%정도로 해도 필요한 디테일이 모두 남아있는걸 확인할 수 있다.

AOP가 필요한 상황

• AOP는 c언어의 포인터라고 불리는만큼 이해하기 어려운 내용이다.
• 그러나 AOP가 필요한 상황을 이해하면 쉬울 수 있다.

1. 모든 메소드의 호출 시간을 측정하고 싶을 때 간단하게 함수의 시작 부분과 끝 부분에 시간을 재는 방법이 있을 것이다.

2. 공통 관심 사항 vs 핵심 관심 사항

3. 회원 가입 시간, 회원 조회 시간을 측정하고 싶다면?

   

   try 구문 실행 후 finally 구문이 실행된다.

• 문제점 시간 측정 기능은 핵심 관심 사항이 아닌 공통 관심 사항이다. 핵심 비즈니스의 로직과 섞여 유지보수가 어렵다. 시간 측정 로직을 변경할 때 모든 로직을 찾아가면서 변경해야 한다.

AOP 적용

• AOP : Aspect Oriented Programming
• 공통 관심 사항과 핵심 관심 사항을 분리한다.
• aop라는 새로운 패키지에 TimeTraceAop 클래스 생성 후 다음 코드 넣기

  package hello.hellospring.aop;
  import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.annotation.Around;
  import org.aspectj.lang.annotation.Aspect;
  import org.springframework.stereotype.Component;
  

@Component @Aspect public class TimeTraceAop { @Around("execution(* hello.hellospring..*(..))") public Object execute(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.currentTimeMillis(); System.out.println("START: " + joinPoint.toString()); try { return joinPoint.proceed(); } finally { long finish = System.currentTimeMillis(); long timeMs = finish - start; System.out.println("END: " + joinPoint.toString()+ " " + timeMs + "ms"); } } }

- joinPoint.proceed()
 다음 메소드로 진행시켜주는 함수
- joinPoint.toString()
 현재 메소드의 이름을 출력해준다.
- 위 코드와 같이 @Component로 해주어도 되지만 Aop를 사용한다는 것을 가시적으로 보여주기 위해 스프링 빈에 직접 등록한다.(등록 시 @Component 제거)
 ->springconfig에 다음 코드 추가
```java
    @Bean
    public TimeTraceAop timeTraceAop(){
        return new TimeTraceAop();
    }

• @Around Aop를 적용하는 범위 지정 위 코드에서는 hello.hellospring 패키지에 있는 전범위를 포함한것

• 해결 핵심 관심사항과 공통 관심 사항을 분리하였다. 시간 측정 로직을 별도의 공통 로직으로 만들었다. 핵심 관심 사항을 깔끔하게 유지 가능하다. 원하는 적용 대상을 선택할 수 있다.(@Around)

• AOP 적용 전 의존관계

• AOP 적용 후 의존관계

• AOP가 프록시(가짜) memberService를 만들어내어 먼저 실행되도록 조작한다.

• 김영한 님의 스프링 완전 정복 로드맵의 첫번때 단계가 끝났다. 다음 강의부터는 유료강의이기 때문에 개인노트에 정리를 하겠다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

스프링 JdbcTemplate

• 스프링에서 제공하는 이 라이브러리는 JDBC API에서 본 반복적인 코드를 대부분 제거해준다.
• 그러나 SQL은 직접 작성해야 한다.
• 현재 실무에서도 종종 사용한다.
• JdbcTemplateMemberRepository 라는 새로운 repository를 만들고 다음 코드를 넣는다.

  package hello.hellospring.repository;
  import hello.hellospring.domain.Member;
  import org.springframework.jdbc.core.JdbcTemplate;
  import org.springframework.jdbc.core.RowMapper;
  import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
  import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
  import javax.sql.DataSource;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  public class JdbcTemplateMemberRepository implements MemberRepository {
  private final JdbcTemplate jdbcTemplate;
  public JdbcTemplateMemberRepository(DataSource dataSource) {
  jdbcTemplate = new JdbcTemplate(dataSource);
  }
  @Override
  public Member save(Member member) {
  SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
  jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");
  Map<String, Object> parameters = new HashMap<>();
  parameters.put("name", member.getName());
  Number key = jdbcInsert.executeAndReturnKey(new
  MapSqlParameterSource(parameters));
  member.setId(key.longValue());
  return member;
  }
  @Override
  public Optional<Member> findById(Long id) {
  List<Member> result = jdbcTemplate.query("select * from member where id 
  = ?", memberRowMapper(), id);
  return result.stream().findAny();
  }
  @Override
  public List<Member> findAll() {
  return jdbcTemplate.query("select * from member", memberRowMapper());
  }
  @Override
  public Optional<Member> findByName(String name) {
  List<Member> result = jdbcTemplate.query("select * from member where 
  name = ?", memberRowMapper(), name);
  return result.stream().findAny();
  }
  private RowMapper<Member> memberRowMapper() {
  return (rs, rowNum) -> {
  Member member = new Member();
  member.setId(rs.getLong("id"));
  member.setName(rs.getString("name"));
  return member;
  };
  }
  }

• 생성자가 한개라면 @Autowired 생략이 가능하다.(위 코드에서도 생략 가능)
• jdbcMemberRepository와 비교를 해보면 findById 함수가 memberRowMapper를 이용하여 두줄만에 짜여진 것을 볼 수 있다.
• save는 jdbcTemplate을 인자로 받는 SimpleJdbcInsert를 이용하여 query를 짤 필요 없이 쉽게 구현이 되었다.
• 현재는 자세한 설명 없이 전체적인 흐름만 보았지만 추후에 jdbcTemplate의 다양한 기능들을 배울 예정이다.

• 구현한 jdbcTemplate 연결(다음 코드 변경)

    @Bean
    public MemberRepository memberRepository(){
        //return new MemoryMemberRepository();
        //return new JdbcMemberRepository(dataSource);
        return new JdbcTemplateMemberRepository(dataSource);
    }

• 테스트 파일을 돌려보면 오류 없이 잘 작동한다.

JPA

• JPA는 기존의 반복 코드는 물론, 기본적인 SQL도 만들어주기 때문에 개발 생산성을 크게 향상시킬 수 있다.
• JPA는 Spring 만큼 기술적인 깊이도 깊고 스프링 자체 환경에서 JPA를 기본으로 하는 경우가 많기 때문에 배우면 도움이 될 것이다. (JPA 또한 굉장히 방대하다.)

• JPA를 사용하기 위해 build.gradle에 다음 이미지처럼 ---data-jpa를 추가하고 gradle refresh 버튼을 눌러준다.(코끼리 버튼)

• application.properties에 다음을 추가한다.

  spring.jpa.show-sql=true
  spring.jpa.hibernate.ddl-auto=none

• show-sql=true jpa가 날린 코드들을 볼 수 있게 해준다.

• hibernate.ddl-auto=none jpa는 회원이라는 객체를 인식하여 자동으로 테이블을 만들어주는데 우리는 만들어놓은 테이블을 이용할 것이기 때문에 위 기능을 꺼준다.

• JPA는 결국 인터페이스와 같아서 여러 업체에서 구현체를 만들어 연결을 시키는 형태라고 볼 수 있다. 우리는 JPA의 hibernate 기능을 쓸 것이다.

• 도메인 파일의 Member 클래스에 @Entity를 붙여 이 클래스는 JPA가 관리한다라는 표시를 해준다.

• DB에 insert into member(name) values('spring1'); 를 실행할 때 id값을 우리가 설정하는 것이 아닌 DB에서 자동으로 생성해주는데 이것을 IDENTITY 전략이라고 한다.

• id 위쪽에 이 기능을 추가해준다.

• JPA는 EntityManager로 모든 것을 관리한다.
• JPA를 이용한 새로운 repository JpaMemberRepository 를 생성하고 다음 코드를 넣는다.

  package hello.hellospring.repository;
  

import hello.hellospring.domain.Member;

import javax.persistence.EntityManager; import java.util.List; import java.util.Optional;

public class JpaMemberRepository implements MemberRepository{

private final EntityManager em;

public JpaMemberRepository(EntityManager em) {
    this.em = em;
}

@Override
public Member save(Member member) {
    em.persist(member);
    return member;
}

@Override
public Optional<Member> findById(Long id) {
    Member member = em.find(Member.class, id);
    return Optional.ofNullable(member);
}

@Override
public Optional<Member> findByName(String name) {
    List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
            .setParameter("name", name)
            .getResultList();

    return result.stream().findAny();
}

@Override
public List<Member> findAll() {
    return em.createQuery("select m from Member m", Member.class)
            .getResultList();
}

}

> 단축키 팁
 windows 기준 ctrl+alt+n을 누르면 하나의 라인으로 합쳐진다.
 ex) 
 ```java
 List<Member> result = parallel;
  return result
  ->
  return parallel;

※ JPA를 사용할 때 항상 @Transactional이 있어야 한다. -> MemberService에 @Transactional을 넣어준다.

• SpringConfig에 JpaMemberRepository 를 연결시켜 준다. 원래 있던 DataSource 대신 EntityManager를 만들어 넣어준다.

package hello.hellospring;

import hello.hellospring.repository.*;
import hello.hellospring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

@Configuration
public class SpringConfig {

    private EntityManager em;

    @Autowired
    public SpringConfig(EntityManager em) {
        this.em = em;
    }

    @Bean
    public MemberService memberService(){
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository(){
        //return new MemoryMemberRepository();
        //return new JdbcMemberRepository(dataSource);
        //return new JdbcTemplateMemberRepository(dataSource);
        return new JpaMemberRepository(em);
    }
}

• 확인하기 위해 MemberServiceIntegrationTest의 회원가입 부분만 실행시켜 본다.
• @Transactional은 실행 후 롤백시켜주므로 @Commit을 대신 넣어주면 DB에 값이 추가되는 것을 확인할 수 있다.

스프링 데이터 JPA

• 스프링 데이터 JPA를 사용하면 리포지토리에 구현 클래스 없이 인터ㅔ이스 만으로 개발을 할 수 있게 된다.

※ 스프링 데이터 JPA는 JPA를 편리하게 사용할 수 있도록 도와주는 도구이기 때문에 반드시 JPA 선행학습이 필요하다.

• 리포지토리에 SpringDataJpaMemberRepository 인터페이스를 생성하고 다음 코드를 넣는다.

  package hello.hellospring.repository;
  

import hello.hellospring.domain.Member; import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {

@Override
Optional<Member> findByName(String name);

}

> 인터페이스가 다른 인터페이스를 가져올 때는 implements가 아닌 extends이다.

- 스프링이 JpaRepository를 발견하면 spring bean에 자동으로 등록해준다.
 -> 구현체를 만들어서 등록해준다.

- springconfig 파일을 다음과 같이 변경해준다.
```java
package hello.hellospring;

import hello.hellospring.repository.*;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {

    private final MemberRepository memberRepository;

    public SpringConfig(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    @Bean
    public MemberService memberService()
    {
        return new MemberService(memberRepository);
    }

}

• 서비스 통합테스트를 돌려보면 정상적으로 작동이 되는 것을 확인할 수 있다.

• 기본적인 save(), findAll() 함수 등은 스프링 데이터 JPA에서 제공을 해주기 때문에 따로 짤 필요가 없다.

• 위와 같은 공통적인 부분은 쓸 수 있지만 비지니스 모델이 다른 경우 등에는 따로 써야한다. 이것은 스프링 데이터 JPA 리포지토리에 findByName을 통해 확인할 수 있다.

• 실무에서는 대부분 JPA, 스프링 데이터 JPA, Querydsl(복잡한 동적 쿼리 처리 라이브러리) 의 조합으로 사용한다.

• 이 조합으로 해결하기 어려운 쿼리는 JPA가 제공하는 네이티브 쿼리를 사용하거나, 스프링 JdbcTemplate를 사용하면 된다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

• 이전까지는 메모리에 저장해 자바를 종료하면 데이터도 날라가버렸다.
• 이번 장에서 데이터베이스를 다루는 법을 배울 것이다.
• 다음 5가지를 순차적으로 배우게 된다.

1. 데이터베이스 설치
2. 데이터베이스 SQL과 애플리케이션 서버를 연결하는데에 필요한 기술인 jdbc를 배운다. -> 순수 jdbc로 20년전 개발하기 힘들었던 환경을 경험한다.
3. 스프링에서 jdbctemplate를 제공하여 보다 편한 jdbc 개발이 가능하다.
4. SQL을 직접 짤 필요 없이 JPA를 이용하여 보다 편리하게 개발이 가능하다.
5. JPA를 더욱 편리하게 개발하기 위해 감싼 기술인 스프링 데이터 JPA를 배운다.

H2 데이터베이스 설치

• 실무로 자주 쓰이는 mysql 계열의 데이터베이스이다.
• 교육용으로 사용하기에 좋다.
• 위 화면에서 연결 버튼을 누르면 자동으로 데이터베이스가 생성되는데 나는 다음과 같은 오류가 발생하였다.

  Database "C:/Users/사용자명/test" not found, either pre-create it or allow remote database creation (not recommended in secure environments)

• 이는 해당 폴더에 test 파일이 없어서 생긴 문제로 해당 경로에 빈 텍스트 파일을 생성하고 파일명을 확장자 포함 'test.mv.db' 로 바꿔주고 다시 연결을 시도한다.
• 이후 성공적으로 데이터베이스가 접속되었다면 JDBC URL을 바꿔서 접근해주어야한다.

  jdbc:h2:tcp://localhost/~/test

• 다음 코드를 넣고 실행시켜 왼쪽에 MEMBER 파일이 생성되었는지 확인한다.

  drop table if exists member CASCADE; create table member ( id bigint generated by default as identity, name varchar(255), primary key (id) );

• 다음 코드를 넣고 or member파일을 클릭하고 한번 더 실행한다.

  SELECT * FROM MEMBER

• 확인하기 위해 다음 코드를 넣고 member 파일을 확인해본다.

  insert into member(name) values('spring2')

• 데이터베이스 또한 intelliJ를 통해 관리할 수 있다.

순수 JDBC

• 옛날에 사용하던 기술이므로 완전히 익힐 필요없이 인지 정도만 하면 된다.

• build.gradle 파일에 다음 코드를 추가한다.

  implementation 'org.springframework.boot:spring-boot-starter-jdbc'
  runtimeOnly 'com.h2database:h2'

• resources/application.properties에 데이터베이스 연결 설정을 추가한다.

  spring.datasource.url=jdbc:h2:tcp://localhost/~/test
  spring.datasource.driver-class-name=org.h2.Driver

• 이때 오류가 뜨는데 오른쪽에 코끼리 버튼을 누르거나 오른쪽 gradle탭에서 새로고침 모양을 눌러준다.

  ※ 스프링부트 2.4 버전 이상은 다음 코드를 추가로 넣어주어야 한다. spring.datasource.username=sa

• 새로운 구현체인 JdbcMemberRepository 를 만들어주고 다음 코드를 넣는다.

• 정신건강을 위해 복붙하고 참고만 하도록 하자

  package hello.hellospring.repository;
  import hello.hellospring.domain.Member;
  import org.springframework.jdbc.datasource.DataSourceUtils;
  import javax.sql.DataSource;
  import java.sql.*;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Optional;
  public class JdbcMemberRepository implements MemberRepository {
  private final DataSource dataSource;
  public JdbcMemberRepository(DataSource dataSource) {
  this.dataSource = dataSource;
  }
  @Override
  public Member save(Member member) {
  String sql = "insert into member(name) values(?)";
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
  conn = getConnection();
  pstmt = conn.prepareStatement(sql,
  Statement.RETURN_GENERATED_KEYS);
  pstmt.setString(1, member.getName());
  pstmt.executeUpdate();
  rs = pstmt.getGeneratedKeys();
  if (rs.next()) {
  member.setId(rs.getLong(1));
  } else {
  throw new SQLException("id 조회 실패");
  }
  return member;
  } catch (Exception e) {
  throw new IllegalStateException(e);
  } finally {
  close(conn, pstmt, rs);
  }
  }
  @Override
  public Optional<Member> findById(Long id) {
  String sql = "select * from member where id = ?";
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
  conn = getConnection();
  pstmt = conn.prepareStatement(sql);
  pstmt.setLong(1, id);
  rs = pstmt.executeQuery();
  if(rs.next()) {
  Member member = new Member();
  member.setId(rs.getLong("id"));
  member.setName(rs.getString("name"));
  return Optional.of(member);
  } else {
  return Optional.empty();
  }
  } catch (Exception e) {
  throw new IllegalStateException(e);
  } finally {
  close(conn, pstmt, rs);
  }
  }
  @Override
  public List<Member> findAll() {
  String sql = "select * from member";
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
  conn = getConnection();
  pstmt = conn.prepareStatement(sql);
  rs = pstmt.executeQuery();
  List<Member> members = new ArrayList<>();
  while(rs.next()) {
  Member member = new Member();
  member.setId(rs.getLong("id"));
  member.setName(rs.getString("name"));
  members.add(member);
  }
  return members;
  } catch (Exception e) {
  throw new IllegalStateException(e);
  } finally {
  close(conn, pstmt, rs);
  }
  }
  @Override
  public Optional<Member> findByName(String name) {
  String sql = "select * from member where name = ?";
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
  conn = getConnection();
  pstmt = conn.prepareStatement(sql);
  pstmt.setString(1, name);
  rs = pstmt.executeQuery();
  if(rs.next()) {
  Member member = new Member();
  member.setId(rs.getLong("id"));
  member.setName(rs.getString("name"));
  return Optional.of(member);
  }
  return Optional.empty();
  } catch (Exception e) {
  throw new IllegalStateException(e);
  } finally {
  close(conn, pstmt, rs);
  }
  }
  private Connection getConnection() {
  return DataSourceUtils.getConnection(dataSource);
  }
  private void close(Connection conn, PreparedStatement pstmt, ResultSet rs)
  {
  try {
  if (rs != null) {
  rs.close();
  }
  } catch (SQLException e) {
  e.printStackTrace();
  }
  try {
  if (pstmt != null) {
  pstmt.close();
  }
  } catch (SQLException e) {
  e.printStackTrace();
  }
  try {
  if (conn != null) {
  close(conn);
  }
  } catch (SQLException e) {
  e.printStackTrace();
  }
  }
  private void close(Connection conn) throws SQLException {
  DataSourceUtils.releaseConnection(conn, dataSource);
  }
  }

• 코드에 대한 자세한 설명은 강의를 참고하도록 하자..

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8/dashboard

• 이제 우리가 가상 시나리오를 설정하여 구현체를 따로 만들어준 이유를 알 수 있다.

• SpringConfig에서 MemberRepository에게 반환하는 값을 변경해준다.

• 또한 위쪽에 다음 코드를 추가해준다.

    private final DataSource dataSource;
  
    @Autowired
    public SpringConfig(DataSource dataSource) {
        this.dataSource = dataSource;
    }

• 이렇게 @Configuration만 만져주면 데이터베이스와 연결된다.

• 이렇게 구현체를 쉽게 바꾸는 객체지향적인 기술을 스프링이 지원해주기 때문에 스프링을 사용한다.

스프링 통합 테스트

• 아래 코드 넣기

  package hello.hellospring.service;
  import hello.hellospring.domain.Member;
  import hello.hellospring.repository.MemberRepository;
  import org.junit.jupiter.api.Test;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.transaction.annotation.Transactional;
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  @SpringBootTest
  @Transactional
  class MemberServiceIntegrationTest {
    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;
    @Test
    public void 회원가입() throws Exception {
        //Given
        Member member = new Member();
        member.setName("hello");
        //When
        Long saveId = memberService.join(member);
        //Then
        Member findMember = memberRepository.findById(saveId).get();
        assertEquals(member.getName(), findMember.getName());
    }
    @Test
    public void 중복_회원_예외() throws Exception {
        //Given
        Member member1 = new Member();
        member1.setName("spring");
        Member member2 = new Member();
        member2.setName("spring");
        //When
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class,
                () -> memberService.join(member2));//예외가 발생해야 한다.
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }
  }

• @SpringBootTest 스프링 컨테이너와 테스트를 함께 실행한다. -> 스프링 서버가 동작하면서 테스트를 실행한다.

• @Transactional 테스트 케이스에 이 애노테이션이 있으면, 테스트 시작 전에 트랜잭션을 시작하고, 테스트 완료 후에 항상 롤백한다. 이렇게 하면 DB에 데이터가 남지 않으므로 다음 테스트에 영향을 주지 않는다 -> 따로 DB를 초기화하는 코드가 필요없게 된다.

• 기존에 했던 MemberServiceTest와의 차이점 스프링 서버를 동작하지 않으므로 빠르게 실행된다. 웬만하면 스프링 서버 동작 없이(스프링 통합 테스트) 하는 것이 좋은 테스트일 가능성이 높다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8/dashboard

시작

• 실무와 가장 가까운 언어이면서 백엔드에서 군림하고 있다고 볼 수 있는 spring을 공부하기로 하였다.
• 그냥 공부하기엔 막막하고 포기할 수 있으므로 인프런 강의(김영한 님)을 통해 공부하기로 하였다.
• 김영한 님의 2가지 로드맵을 통하여 거대한 spring을 차근차근 익혀나가기로 하였다.

계획

첫번째 스프링 완전 정복 로드맵은 다음과 같다.

1. 스프링 입문
2. 스프링 핵심 원리
3. 스프링 웹 MVC
4. 스프링 DB 데이터 접근 기술
5. 실전! 스프링 부트

• 요새 개발 추이가 웹에서 하는 경우가 많기 때문에 웹 MVC가 중요하다.

첫주차 계획(간단한 웹 애플리케이션 개발)은 다음과 같다.

1. 스프링 프로젝트 생성
2. 스프링 부트로 웹 서버 실행
3. 회원 도메인 개발
4. 웹 MVC 개발
5. DB 연동 - JDBC, JPA, 스프링 데이터 JPA
6. 테스트 케이스 작성

홈 화면 추가

• 컨트롤러 파일에 HomeController 클래스 추가
• 아래 코드 삽입

  package hello.hellospring.controller;
  

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping;

@Controller public class HomeController {

@GetMapping("/")
public String home(){
    return "home";
}

}

- '/'에 대해서 @GetMapping한 것은 제일 상위 주소, 즉 **localhost:8080**에 대한 mapping이다.
- resource - templates에 home.html 파일 추가
- 아래 코드 삽입
```html
<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<body>
<div class="container">
    <div>
        <h1>Hello Spring</h1>
        <p>회원 기능</p>
        <p>
            <a href="/members/new">회원 가입</a>
            <a href="/members">회원 목록</a>
        </p>
    </div>
</div> <!-- /container -->
</body>
</html>

• 원래 static 파일인 index.html이 있었지만 컨트롤러의 우선순위가 더 높기 때문에 mapping이 되어있는 home.html이 출력되었다.

등록

• /members/new 에 대한 템플릿 작성

• member controller에 다음 코드 추가

  @GetMapping("/members/new")
    public String createFrom(){
        return "members/createMemberForm";
    }

• templates에 members디렉토리 생성, 그리고 createMemberForm.html 파일 생성

• 다음 코드 삽입

  <!DOCTYPE HTML>
  <html xmlns:th="http://www.thymeleaf.org">
  <body>
  <div class="container">
  <form action="/members/new" method="post">
  <div class="form-group">
  <label for="name">이름</label>
  <input type="text" id="name" name="name" placeholder="이름을
  입력하세요">
  </div>
  <button type="submit">등록</button>
  </form>
  </div> <!-- /container -->
  </body>
  </html>

• controller 파일에 MemberForm 클래스 생성, 다음 코드 삽입

  package hello.hellospring.controller;
  

public class MemberForm { private String name;

public String getName() {
    return name;
}

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

}

- MemberController 에 다음 코드 추가
```java
    @PostMapping("/members/new")
    public String create(MemberForm form) {
        Member member = new Member();
        member.setName(form.getName());

        memberService.join(member);

        return "redirect:/";
    }

• 정상적으로 진행하였다면 등록버튼을 눌렀을때 오류페이지가 뜨던 전과 달리 처음화면으로 돌아가는 것을 볼 수 있다.

• html 설명 placeholder는 아무것도 입력하지 않았을때 들어가는 값이다. 등록버튼을 누르면 form 태그 안에 적혀있는 것처럼 "/members/new"에 "post"방식으로 id와 name이 넘어가게 된다.

• 이어서 MemberController에서 @PostMapping("/members/new")로 mapping되어있는 create가 호출되어 실행된다.

• 이때 spring은 인자 MemberForm 에 접근하여 setname을 통해 private인 name을 설정한다.

조회

• /members 에 대한 템플릿 작성

• MemberController 에 다음 코드 추가

    @GetMapping("/members")
    public String list(Model model){
        List<Member> members = memberService.findMembers();
        model.addAttribute("members", members);
        return "members/memberList";
    }

• members파일에 memberList.html 템플릿 추가

• 다음 코드 삽입

  <!DOCTYPE HTML>
  <html xmlns:th="http://www.thymeleaf.org">
  <body>
  <div class="container">
    <div>
        <table>
            <thead>
            <tr>
                <th>#</th>
                <th>이름</th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="member : ${members}">
                <td th:text="${member.id}"></td>
                <td th:text="${member.name}"></td>
            </tr>
            </tbody>
        </table>
    </div>
  </div> <!-- /container -->
  </body>
  </html>

  

• /members 에 접속하게 되면 모든 회원(member)들을 리스트 형태로 model에 붙여주고 html 에서 each를 통해 각각의 member들에 대해 표 형태로 나타낸다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8/dashboard

컴포넌트 스캔과 자동 의존 관계 설정

• 스프링 빈을 등록하는 첫번째 방법(자동)
• 실제 html과 우리가 작업했던 서버 설정들을 이어주기 위해선 멤버 컨트롤러가 필요하다.
• controller 파일에 MemberController 클래스 생성 후 아래 코드 삽입

  package hello.hellospring.controller;
  

import hello.hellospring.service.MemberService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller;

@Controller public class MemberController {

private final MemberService memberService;

@Autowired
public MemberController(MemberService memberService) {
    this.memberService = memberService;
}

}

- 멤버 컨트롤러를 통해 멤버 서비스를 가져오는데 멤버 서비스는 다른 여러 군데에서 사용할 수 있으므로 new로 매번 생성할 필요 없이 하나만 생성해주면 된다.
- 연결 방법
1. 생성자(constructor)로 memberservice의 생성자를 만들어준다.
 (window 기준 alt+insert 단축키 이용)
 ![](https://velog.velcdn.com/images/jg-konkuk/post/273996ef-9d86-4886-b5c4-063eeeaa5899/image.png)

2. @Autowired
 스프링 컨테이너에 있는 Member Service, 즉 service파일의 MemberService와 생성자의 memberService와 연결시켜준다.

3. 이것만으로는 memberservice를 찾지 못하여 오류가 발생한다.
 컨트롤러 같은 경우는 @controller 등의 **annotation**으로 스프링이 찾을 수 있지만 memberservice는 순수한 자바 코드로 이루어진 클래스이기 때문에 스프링이 찾을 수가 없다.
 **따라서 MemberService 클래스 위에 @Service 라는 annotation을 넣어준다.**
 ![](https://velog.velcdn.com/images/jg-konkuk/post/102af4c2-a8a4-4475-9973-6f7f0a4a9af9/image.png)

4. 같은 원리로 구현체인 MemoryMemberRepository 클래스 위에 @Repository를 넣어준다.
![](https://velog.velcdn.com/images/jg-konkuk/post/f6d64e79-169d-4ba4-a470-21a8ee5f0a35/image.png)

5. MemberController와 MemberService를 이어주었으니 MemberService와 MemoryMemberRepository도 똑같이 @Autowired로 이어준다.

- 이 과정이 스프링 빈을 등록하는 2가지 방법 중에서 한가지인 **컴포넌트 스캔** 방식이다. (@Autowired와 같은 annotation 이용)
![](https://velog.velcdn.com/images/jg-konkuk/post/4306c26c-cb3f-429b-99e7-42b2d88cb1b7/image.jpeg)

- @Controller, @Service, @Repository를 살펴보면 그 속에 @Component가 붙어있는 것을 확인할 수 있다.
![](https://velog.velcdn.com/images/jg-konkuk/post/49a0d98b-99f7-44c5-ac91-c48faf382660/image.png)

※ @Component 에노테이션이 있으면 스프링 빈으로 자동 등록 된다.

---
## 자바 코드로 직접 스프링 빈 등록하기
- 스프링 빈을 등록하는 2번째 방법(수동)
- 우선 이전 방법으로 설정했던 annotation을 전부 지운다.(membercontroller 제외)
---
- hello.hellospring 패키지에 SpringConfig 클래스 생성 후 아래 코드 삽입
```java
package hello.hellospring;

import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {

    @Bean
    public MemberService memberService(){
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository(){
        return new MemoryMemberRepository();
    }
}

• 스프링이 @Configuration을 인식하면 @Bean 다음에 있는 클래스들을 스프링 빈으로 등록한다. ※ 컨트롤러는 수동이 아닌 자동으로 등록해야함.

참고

• DI에는 필드 주입, setter 주입, 생성자 주입 세가지 방법이 있다. 우리는 이 중에서 생성자 주입을 사용하였다.
• 필드 주입, setter 주입은 몇가지 문제가 있고 의존관계가 실행중에 동적으로 변하는 경우는 거의 없으므로 생성자 주입을 권장한다.
• 실무에서는 주로 정형화된 컨트롤러, 서비스, 리포지토리 같은 코드는 컴포넌트 스캔을 사용한다. 그리고 정형화 되지 않거나, 상황에 따라 구현 클래스를 변경해야 하면 설정을 통해 스프링 빈으로 등록한다.

=> 현재 가상 시나리오는 '저장소가 정해지지 않아 바뀔 수 있으므로 구현체를 통하여 추후에 바꿀 수 있도록 설계'하였기 때문에 수동으로 스프링 빈으로 등록하여 간단하게 바꿀 수 있도록 설계한다.

※ 스프링 컨테이너, DI 관련된 자세한 내용은 스프링 핵심 원리 강의에서 설명한다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8/dashboard

회원 서비스 개발

• 도메인과 리포지토리를 이용하여 비즈니스 로직 구현
• src - main - java 에 service 패키지 생성 후 MemberService 클래스 생성
• 아래 코드 붙여넣기

  package hello.hellospring.service;
  

import hello.hellospring.domain.Member; import hello.hellospring.repository.MemberRepository; import hello.hellospring.repository.MemoryMemberRepository;

import java.util.List; import java.util.Optional;

public class MemberService {

private final MemberRepository memberRepository = new MemoryMemberRepository();

/**
 * 회원 가입
 */
public Long join(Member member){
    // 조건 : 같은 이름이 있는 중복 회원X
    validateDuplicateMember(member); // 중복회원 검증
    memberRepository.save(member);
    return member.getId();
}

private void validateDuplicateMember(Member member) {
    Optional<Member> result = memberRepository.findByName(member.getName());
    result.ifPresent(m ->{
        throw new IllegalStateException("이미 존재하는 회원입니다.");
        // 같은 이름이 존재하면 위 문구 출력
    });
}

/**
 * 전체 회원 조회
 */
public List<Member> findMembers(){
    return memberRepository.findAll();
}

public Optional<Member> findOne(Long memberId){
    return memberRepository.findById(memberId);
}

}

- Optional을 쓰는 이유 : Optional을 이용하면 if(null==?) 등의 다양한 메소드들을 활용할 수 있다.
> 단축키
 shift+f6 : 단어를 한번에 바꿀 수 있다.
 ctrl+alt+shift+t : 해당 블록을 함수화 시킨다.(window)

---
## 회원 서비스 테스트
- test 파일에서 따로 package를 만들고 class를 만들 필요 없이 자동으로 만들어주는 단축키가 있다.
> ctrl + shift + t
![](https://velog.velcdn.com/images/jg-konkuk/post/46cee11f-8a9f-4795-84a4-956cc590a206/image.png)

- create new test를 누르면 창이 뜬다.
- test할 함수를 선택하면 자동으로 test 파일을 생성해준다.
- test 함수는 빌드에 포함되지 않으므로 한글사용이 가능하다.
- test는 기본적으로 다음과 같은 단계로 구분된다.
 given : 어떠한 상황이 주어진다.
 when : 이것이 실행되었을 때
 then : 이것이 나와야한다.

```java
package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemoryMemberRepository;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.assertThrows;

class MemberServiceTest {

    MemberService memberService = new MemberService();
    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach(){
        memberRepository.clearStore();
    }
    @Test
    void join() {
        // given
        Member member = new Member();
        member.setName("hello");

        // when
        Long saveId = memberService.join(member);

        // then
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    public void 중복_회원_예외(){
        // given
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        // when
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        // 2번째 인자를 실행했을 때 1번째 인자의 오류가 발생해야함
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        // 발생한 오류의 메시지 체크

        /*
        // try catch 이용하여 중복 검사가 동작하는지 체크
        try {
            memberService.join(member2);
            fail("예외가 발생해야 합니다.");
        }catch (IllegalStateException e){
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
*/

        // then
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

• 그러나 memberService에서 repository를 new로 생성하고 테스트 파일에서 따로 repository를 new로 생성하는 오류가 있다. -> static이기 때문에 결국은 같은 저장공간을 가르키지만 static이 아니라면 오류가 발생한다.

• 따라서 service의 다음 코드를 바꿔주어야한다.

private final MemberRepository memberRepository = new MemoryMemberRepository();

=>

private final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

• service test의 코드 또한 바꿔 준다.

    MemberService memberService = new MemberService();
    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

=>

    MemberService memberService;
    MemoryMemberRepository memberRepository;

    @BeforeEach // 각 테스트 실행하기 전에 실행
    public void beforeEach(){
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

비즈니스 요구사항 정리

• 데이터 : 회원ID, 이름

• 기능 : 회원 등록, 조회

• 가상의 시나리오 : 데이터 저장소가 선정되지 않음

• 웹 애플리케이션 계층 구조

• 컨트롤러 : 웹 MVC의 컨트롤러 역할

• 서비스 : 핵심 비즈니스 로직 구현(회원은 중복가입 불가 등의 로직)

• 리포지토리 : 데이터베이스에 접근, 도메인 객체를 DB에 저장하고 관리

• 도메인 : 비즈니스 도메인 객체 ex) 회원, 주문, 쿠폰 등 주로 데이터베이스에 저장하고 관리됨

• 클래스 의존관계

• 리포지토리는 interface로 설계 -> 아직 데이터 저장소가 선정되지 않았기 때문(interface는 구현체(구현 클래스)를 바꿔끼울 수 있다.)

• 구현체로 가벼운 메모리 기반의 데이터 저장소 사용

회원 도메인과 리포지토리 만들기

• hello.hellospring에 domain이라는 이름의 package 생성
• 그 안에 Member라는 class 생성
• id, name 데이터 생성, getter와 setter 생성

  package hello.hellospring.domain;
  

public class Member {

private Long id;
private String name;

public Long getId() {
    return id;
}

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

public String getName() {
    return name;
}

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

}

---
- hello.hellospring에 repository이라는 이름의 package 생성
- 그 안에 MemberRepository 라는 interface 생성
- 아래 코드 붙여넣기
```java
package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.List;
import java.util.Optional;

public interface MemberRepository {
    Member save(Member member);
    Optional<Member> findById(Long id);
    Optional<Member> findByName(String name);
    List<Member> findAll();
}

• 구현체 만들기
• repository package에 MemoryMemberRepository라는 class 생성
• 아래 코드 기입

  package hello.hellospring.repository;
  

import hello.hellospring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository{

private static Map<Long, Member> store = new HashMap<>();
private static long sequence = 0L;

@Override
public Member save(Member member) {
    member.setId(++sequence);
    store.put(member.getId(), member);
    return member;
}

@Override
public Optional<Member> findById(Long id) {
    return Optional.ofNullable(store.get(id));

}

@Override
public Optional<Member> findByName(String name) {
    return store.values().stream()
            .filter(member -> member.getName().equals(name))
            .findAny();
    // stream : store에 저장된 데이터를 loop로 쭉 훑는다.
    // filter : store에 저장된 name과 현재 들어온 name을 찾는다.
    // findAny : 한개 이상 찾았을때(중복이 있을때)
    // 중복을 찾았다면 이미 있는 데이터를 optional로 반환한다.
}

@Override
public List<Member> findAll() {
    return new ArrayList<>(store.values());
    // 반환형태가 List이므로 new로 list 생성
    // store.values() 하면 store의 모든 value 반환
}

}

---
## 회원 리포지토리 테스트 케이스 작성
- 테스트할 때 자바의 main 메서드 또는 웹 어플리케이션의 컨트롤러를 통해서 해당 기능을 실행한다.
- 이러한 방법은 오래걸리고, 여러 테스트를 한번에 실행하기 어렵다는 단점이 있다.
- 따라서 JUnit이라는 프레임워크로 테스트를 실행해서 문제를 해결한다.
- test - java - hello.hellospring에 repository 라는 package 생성
- 그 안에 MemoryMemberRepositoryTest 라는 class 생성
- 아래 코드 붙여넣기

```java
package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.assertj.core.api.Assertions.*;

class MemoryMemberRepositoryTest {

    MemoryMemberRepository repository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach(){
        repository.clearStore();
    }
    @Test
    public void save() {
        Member member = new Member();
        member.setName("spring");

        repository.save(member);

        Member result = repository.findById(member.getId()).get();
        assertThat(member).isEqualTo(result);
        // repository에 제대로 저장이 되는지 확인
        // 성공 시 아무것도 출력 x, 실패 시 경고 문구 출력
    }

    @Test
    public void findByName(){
        Member member1=new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2=new Member();
        member2.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();

        assertThat(result).isEqualTo(member1);
        // 만약 findByName에 spring2를 넣으면 member1과 다르기 때문에 오류가 뜰 것
    }

    @Test
    public void findAll(){
        Member member1=new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2=new Member();
        member2.setName("spring2");
        repository.save(member2);

        List<Member> result = repository.findAll();

        assertThat(result.size()).isEqualTo(2);
        // repository에 2개의 member가 저장되어있으므로 findAll()을 하면 2개가 나와야한다.
    }
}

• Test의 순서는 보장되지 않음 -> 객체 중복 주의, Test끼리 의존 관계가 보장되지 않는다. -> 하나의 테스트가 끝날때마다 repository를 초기화 시켜주어야한다. -> @AfterEach 사용

• MemoryMemberRepository 클래스에 다음 코드 추가

  public void clearStore(){
        store.clear();
        // store를 싹 비운다.
    }

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

웹 개발 종류

• 정적 컨텐츠 서버의 동작 없이 그대로 파일을 그대로 출력

• MVC와 템플릿 엔진 jhp, php등의 템플릿 엔진을 통해 html을 변형하여 출력 요새 개발 트렌드

• API 안드로이드 또는 아이폰 등을 개발할 때에 html이 아닌 json 데이터 구조 포맷으로 개발함 또는 html 전달이 필요없는 서버끼리의 통신 간에 사용

정적 컨텐츠 개발

https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content

• 스프링 부트 사이트에서는 정적 컨텐츠 개발 방법을 다음과 같이 안내하고 있다.
• src - main - resources - static 파일에 아무 html 파일을 넣고 내용을 작성하면 그대로 출력이 된다.
• 별도의 서버 프로그래밍을 할 수 없다.

<!DOCTYPE HTML>
<html>
<head>
    <title>static content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
정적 컨텐츠 입니다.
</body>
</html>

• 정적 컨텐츠 작동 구조

1. 웹 브라우저가 톰켓 서버에게 요청한다.
2. 톰켓 서버에서 hello-static 관련 컨트롤러가 있는지 스프링 컨테이너에게 신호를 보낸다 -> 컨트롤러가 우선순위가 더 높다.
3. 관련 컨트롤러가 없으므로 resources: static에서 해당 파일을 찾는다.
4. 그대로 반환한다.

MVC와 템플릿 엔진 개발

• MVC : Model, View, Controller

• 옛날에는 view에 모든 프로그래밍을 설계한 model1 방식이지만 지금은 MVC와 같은 model2 방식으로 개발한다.

• 분야를 분리하여 유지, 보수에 더 용이하게 하기 위함이다. -> view는 프론트(보이는 것), model과 controller는 백(내부)

• thymeleaf의 장점 : 서버 구동 없이 html을 주소창에 입력하면 바로 볼 수 있다.(view 영역)

• controller 파일의 hellocontroller 파일에 다음을 추가한다.

  @GetMapping("hello-mvc")
    public String helloMvc(@RequestParam("name") String name, Model model){
        model.addAttribute("name",name);
        return "hello-template";
    }

• resource - templates 파일에 hello-template.html을 생성하고 다음 내용을 작성한다.

  <html xmlns:th="http://www.thymeleaf.org">
  <body>
  <p th:text="'hello ' + ${name}">hello! empty</p>
  </body>

• 이때 이 템플릿은 서버 구동 없이 확인가능

• copy path - absolute path 로 주소창을 붙여넣기

• 여기서 _loalhost:8080/hello-mvc_로 접속하면 에러페이지가 뜬다.

• 이유는 name을 받아오는데 required 값이 기본적으로 true로 설정되어 있어서 주소창에 추가로 ?name=spring!을 넣어주어야한다.

• MVC, 템플릿 엔진 작동 구조

1. 웹 브라우저가 톰켓 서버에게 요청한다.
2. 톰켓 서버에서 hello-static 관련 컨트롤러가 있는지 스프링 컨테이너에게 신호를 보낸다
3. 관련 컨트롤러가 있으므로 그 컨트롤러를 따라간다.
4. return은 hello-template이고 model에는 spring!이라는 값이 들어있는 name이 담겨 전송된다.
5. 스프링은 viewResolver를 통해 템플릿으로 넘긴다.
6. model에 담긴 값에 따라 변환 후 웹 브라우저로 넘긴다.

API 엔진 개발

• controller 에 다음 코드 추가

  @GetMapping("hello-spring")
    @ResponseBody // http 의 body 부분에 아래 데이터를 직접 넣겠다는 의미, ※ html의 body 아님
    public String helloString(@RequestParam("name") String name){
        return "hello "+name;

• view 없이 바로 변환된 값이 전송된다.

• 결과는 MVC, 템플릿 방식과 같지만 소스 부분이 다르다.

• MVC, 템플릿 방식 소스

• API 방식 소스

• 위 예시는 MVC와의 차이를 보여주기 위한 코드일 뿐이다.

• 컨트롤러에 아래의 코드를 추가한다.

  @GetMapping("hello-api")
    @ResponseBody
    public Hello helloApi(@RequestParam("name") String name){
        Hello hello = new Hello();
        hello.setName(name);
        return hello;
    }
  
    static class Hello{
        private String name;
  
        public String getName() {
            return name;
        }
  
        public void setName(String name) {
            this.name = name;
        }
    }

  

• 실행하면 위와 같이 데이터 형식으로 나오는데 이것은 json형식이다. (json : key와 value로 이루어진 데이터 구조)

=> @ResponseBody를 사용하고 객체를 반환하면 json형식으로 반환하게 된다.

• API 작동 구조(@ResponseBody)

1. 웹 브라우저가 톰켓 서버에게 요청한다.
2. 톰켓 서버에서 hello-static 관련 컨트롤러가 있는지 스프링 컨테이너에게 신호를 보낸다
3. 관련 컨트롤러가 있으므로 그 컨트롤러를 따라간다.
4. @ResponseBody에 의해 HttpMessageConverter로 넘어간다.
5. 객체이므로 JsonConverter로 인해 json형식으로 변환된다. (※ 현재 spring은 객체가 들어오면 json으로 바꾸는 것이 default이다.)
6. 웹브라우저로 보내진다.

※ 기본 객체처리 라이브러리 : MappingJackson2HttpMessageConverter

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

컨셉

• 광신도들은 나무, 뿌리를 숭배하므로 제단이 나무 뿌리쪽에 위치하도록 설계하였다.

개발 진행

1. 제단 들어갈 공간 만들기

• 나무 뿌리쪽에 제단을 배치하기 위해 땅 속을 파고들어야 했다.
• 동굴을 만드는 법을 고민하다가 아예 땅을 매몰시키고 그 위를 덮기로 하였다.

2. 제단 틀 만들기

• 중간중간에 랜드스케이프를 계속 수정하면 비효율적이므로 다른 공간에 제단을 미리 만들기로 하였다.

• 제단 입구는 언뜻 보기에 평범해 보인다.

• 제단 내부는 다음과 같이 설계하였다.

• 비밀번호를 입력하고 계단을 따라 내려가면 바닥에 퍼즐이 있는 무언가가 있다.

3. 머터리일 입히기 및 위치 이동

• 게임의 엔딩을 보는곳이 제단인 만큼 엔딩을 보는 장소로 갈때에 긴장감을 느낄 수 있도록 조금 더 길게 설계하였다.

4. 메가스캔 에셋 수정

• 메가스캔의 에셋은 완성본이자 미완성본이라고 할 수 있는데 그 이유는 벽이나 계단같은 에셋들이 모든 면이 설계되어 있지 않기 때문이다.

• 따라서 내가 직접 안쪽을 설계해주어야했다.(물론 다른 편한방법이 존재할 수 있지만 나는 찾지 못하였다.)

• 메가스캔의 에셋들은 폴리그룹이 보이는 면만 설정되어 직사각형의 형태가 아니다. 문이 열리는 블루프린트를 삽입할 것이기 때문에 모든 방향에서 보이도록 만들어야했다. 따라서 완벽히 수복할 수는 없지만 최대한 직사각형으로 만들어 이질감을 없애려고 하였다.

• 모델링모드 - PolyModel - PolyEd 를 이용하였다.

• 추가로 HFill을 사용하여 비어있는 구멍들을 채워준다.

• 성공적으로 직사각형에 가깝게 변형시켰다.

• 부작용으로 앞쪽이 약간 찌그러졌다.

5. 구덩이 메꾸기

• 다른 랜드스케이프를 생성하여 구덩이를 메꾸었다.

6. 제단 횃불 에셋 만들기

• 불이 나오는 제단 횃불을 구할 수 없었고 퀵셀의 다른 에셋을 이용하여 만들기로 하였다.

• 기둥의 윗부분들 횃불을 받쳐주는 용도로 사용하기로 하였다.

• 불을 담고 있는 철조망(?)이 있으면 좋겠지만 구하기 힘들것이라 판단하여 아쉬운대로 윗부분에 불이 들어갈 공간을 동그랗게 만들어 주기로 하였다.

• 모델링 모드 - PolyModel - MshBool 을 이용할 것이다.

1. 먼저 모델링 모드로 적당한 크기의 구를 생성해준다.

2. 만들어준 구에 기둥의 머터리얼을 그대로 넣어준다.

3. 구의 위치를 조정해준 다음 기둥을 먼저 찍고 shift로 구를 찍어준다.(순서 중요)

4. 그 다음 MshBool 을 실행한다.

5. 내가 원하는 모양이 만들어졌으므로 불을 추가해준다.

6. 완성

7. 지하 2층으로 내려가는 비밀 공간 만들기

• 엔딩을 보기 위해 조각상에 빈 부분을 끼워놓으면 지하2층으로 가는 비밀 공간이 생긴다.
• 이를 위해 바닥에 구멍을 뚫고 그 구멍을 다른 에셋으로 채워넣는다.
• 이 과정에서 바닥은 울퉁불퉁하기 때문에 자연스럽게 표현하기 위해 모델링 모드의 TriEd 을 이용하여 조정해준다.

8. 지하 2층 계단 만들기

• 모델링 모드의 stair로 원하는 모양의 계단을 생성하고 XFormUV 으로 자연스러운 머터리얼 모양을 잡는다.

9. 나선 계단 만들기

• 게임의 엔딩인 만큼 가볍게 만들수 없었고 나선 계단을 만들어 긴장감을 높이기로 하였다.

• 액터 배치 - 지오메트리의 나선 계단 브러시 를 활용하였다.

• 벽은 원통형 실린더를 생성하고 모델링 모드를 이용해 안쪽은 파주고 문쪽은 뚫어주었다.

• 이때 cut through로 반대쪽도 똑같이 뚫려버리기때문에 폴리컷을 하기 전 에셋을 이름이 다른 에셋으로 복사해주고 반으로 자른다음 합쳐서 뚫린부분을 메꾸어주었다.

• 외벽까지 같은 방법으로 생성해주면 완성된다.

• 신비한 느낌을 주기 위해 고급스러운 머터리얼을 채택했다.

10. 지하 2층 제작

• 숭배의 대상이 뿌리를 표현하기 위해 바닥을 뿌리들이 얽혀있는 머터리얼을 사용했고 섬의 핵심 코어로 꽃을 배치하였다.

• 조금 더 디테일하게 작업할 수도 있겠지만 시간 부족으로 가볍게 설치만 하였다.

컨셉

• 이 게임에는 신앙을 숭배하는 악당(?)들이 있는데 이들은 나무, 뿌리를 숭배한다.
• 따라서 섬에 거대한 나무를 배치하고 이 거대한 나무를 기준으로 가까운 곳에 있는 나무일수록 큰 나무들을 배치하여 무언가 신비로운 힘이 있음을 암시하도록 설계하였다.

개발 진행

1. 감시 초소

• 숲 속에서 총을 얻을 수 있는 장소인 감시 초소를 만들었다.

2. 나무 추가

• 컨셉이 숲이기 때문에 많은 나무들을 설치해야하는데 지금 사용하는 나무는 마켓플레이스 에셋이기 때문에 많은 성능을 차지할 수 있다. 따라서 적당히 하늘을 덮는 정도로만 깔고 나머지는 퀵셀의 나무 기둥 에셋들을 가져와 깔기로 하였다.

3. 아이템 (총) 추가

• 게임의 엔딩에 영향을 주는 아이템은 총을 배치하였다.

컨셉

• 이 게임은 오픈월드로 자유롭게 돌아다닐 수 있지만 예상 플레이타임을 30분으로 설정하였기 때문에 넓으면 곤란하다.
• 따라서 스프공장을 가까운 곳에 배치하여 농장 다음으로 플레이어가 이동할 수 있도록 유도하였다.

개발 진행

• 먼저 대략적인 크기를 설정하였고 어울리는 벽 에셋들을 찾기로 하였다.
• 실사적인 방향으로 개발하기로 하였기에 외부는 배틀그라운드의 건물들을 참고하고, 내부는 실제 공장의 설계도를 참고하면 더욱 현실적으로 나타낼 수 있을 것이라 생각하였다.

1. 전체적인 틀 구성

2. 공장 천장 골조 제작

• 공장하면 떠오르는 것이 커다란 지붕을 받쳐주는 천장 골조라고 생각하여 메가스캔의 에셋을 이용해 구현해 보았다.
• 이때 이 골조는 따로 구할 수가 없어서 선반 같은 에셋을 활용하였다. 이용한 에셋은 이것이다.
• 원래는 이러한 철제 선반이였지만 모델링모드의 PlnCut, Pattern 등을 활용하여 천장 골조를 구현할 수 있었다.

3. 건물 외벽 정리 및 내부 공간 분리

• 건물에 머터리얼을 입히고 내부 공간을 분리하였다. 이제 에셋들을 적절하게 배치하는 일만 남았다.

4. 에셋 배치

• 공장은 에픽게임즈의 마켓플레이스에서 무료에셋 'FactoryEnvironmentCollect' 의 도움 덕에 좋은 에셋들을 많이 활용할 수 있었다.

• 스프공장이라는 컨셉에 맞게 에셋을 활용하고자 실제 공장 내부 사진을 참고하여 배치하였다.

<참고 사진>

• 이밖에 구글의 여러 사진들을 이용하여 에셋들을 배치하였다.

5. 공장 배경 모습

• 완성된 공장의 전체적인 모습이다

컨셉

• 플레이어는 농장에 있는 창고 안에서 갇힌 채로 시작된다.
• 이 게임은 겉보기엔 평화롭지만 실상은 약간 공포적인 분위기로 농장은 인간이 사육되는 곳(?) 같은 분위기를 연출해야한다.
• 따라서 농장은 울타리로 갇혀있으며 낮은 지형에 위치시켜 언제든 감시당할 수 있는 느낌을 표현하려 하였다.

개발 진행

• 최대한 무료, 퀵셀 콘텐츠를 사용하려 하였으나 마땅한 콘텐츠가 없어서 위와 같이 전체적인 틀만 만들었다.

1. 창고 외관 및 울타리 배치

2. 창고 안 에셋 배치

• 좋은 무료 에셋을 구했기에 어울리는 에셋들을 배치할 수 있었다.

3. 농장 에셋 배치

• 다양한 에셋들을 이용하여 농장을 꾸몄다.

1. 랜드매스 이용

• 프로젝트를 만들었다면 지형을 만들어야한다. 기본으로 생성된 지형들은 모두 지우고 랜드매스 플러그인으로 새로운 지형을 만들 것이다.

• 아래에 CG맨님의 랜드매스 영상을 올릴 것이나 주의점이 있다. ※ 랜드매스 플러그인이 언리얼4 기반이여서 그런건지 MaterialOnly 브러쉬가 제대로 동작되지 않는다. 따라서 나는 지형에 텍스쳐를 입히는 용도로만 사용하였다.

  한국어 튜토리얼! 왕초보도 10분 만에 게임 속 랜덤한 산, 강 지형 만들기! (ft. 랜드매스 플러그인)

  • 랜드스케이프 모드의 스컬프팅, 스무드, 플래튼 등을 활용하여 지형을 만들어준다.

  

2. 바다 추가

• 섬에서 탈출하는 것이 최종목표이기 때문에 가장자리 부분을 파서 섬을 표현했고 노이즈를 통하여 자연스럽게 표현되도록 시도하였다.

• 섬에서 탈출하는 컨셉이기 때문에 바다가 필요한 것은 당연하다. water 플러그인을 이용하여 Water Body Custom을 이용하여 물이 섬주변을 꽉 채우도록 설정하였다.

• 평화로운 분위기가 기반이기에 화창한 날씨와 잔잔한 물결이 잘 어울린다고 보았다.

3. 맵 콜리전 추가

• 맵 밖으로 나가지 못하도록 맵에 콜리전 영역을 설정해준다.
• 액터 배치의 BlockingVolume 을 이용하였다.

개요

• 교내 게임제작동아리를 통하여 게임개발 프로젝트에 참여하여 게임 개발은 어떨지 경험해보기로 하였다.
• 언리얼을 한번도 사용하지 않았음에도 불구하고 공부하면서 진행할 수 있다는 독려에 겁먹지 않고 시작하게 되었다.
• 총 인원은 4명이며 섬에서 퍼즐을 풀며 탈출을 해야하는 스토리탈출게임이다.
• 4개의 파트로 캐릭터와 상호작용, 맵디자인, 데이터베이스와 UI, 퍼즐제작 으로 나누어 각자 하나씩 맡기로 하였다.
• 이 중에서 나는 맵디자인을 맡았다.

공부

• 유튜브에 많은 자료가 있었는데 그 중 러셀님이 만드신 [러셀과 함께하는 시작해요 언리얼]으로 시작하였다.

  [러셀과 함께하는 시작해요 언리얼] 1주차: 언리얼 엔진 시작하기

• 맵디자인에 필요한 최소공부량은 위 영상의 1주차~3주차 까지로 부담되지 않는 학습량이다.

• 이 정도만으로도 시작하기에는 충분하지만 언리얼5가 출시된지 얼마 안되었기에 모르는 부분을 구글링해도 나오지 않을 확률이 크다.

최적화

• 유니티의 경우 대부분 2D로 제작하고 쯔꾸르적인 묘사로 최적화에 대한 걱정이 덜하지만 언리얼의 경우 사실적인 묘사에 초점이 맞춰져 있고 3D로 제작을 하다보니 최적화가 필수이다.

• 최적화를 진행하기 위해 콘솔 명령어들을 사용하였는데 다음을 사용하였다

• stat fps*

• stat gpu*

• fps로 전체적인 성능을 확인하고 stat gpu를 이용하여 어느 부분이 부하를 얼마나 걸고 있는지를 확인하였다.

• 그 결과 그림자가 가장 많은 부하를 걸고 있었고 특히 맵 중 숲에서 가장 안좋은 성능을 보였다.
• 그 이유로는 숲에서 사용한 나무 에셋이 megascan의 에셋이기에 고퀄리티, 많은 폴리곤을 사용하기 때문으로 분석하였다.
• 따라서 크게 2가지 방법으로 최적화를 진행하였다.

1. 모델링 모드 - simplify 툴을 이용하여 에셋의 폴리곤 수를 줄였다.
2. DirectionalLight 의 옵션 중 캐스케이드 섀도 맵을 조정하여 그림자의 모양이 너무 이상하지 않도록 타협하여 조정하였다.

• 이 최적화 과정을 통하여 1060ti 기준 평균 20 ~ 30 fps에서 50 ~ 60 fps로 끌어올릴 수 있었다.

느낀점

• 언리얼을 처음 사용해보면서 하드코딩이나 블루프린트를 이용하여 상호작용들을 만들어보진 않았지만 게임의 전반적인 영역인 맵 부분을 맡으면서 언리얼에 빠르게 익숙해질 수 있었고 처음임에도 불구하고 만족스러운 결과물을 만들었다는 것에 언리얼이 얼마나 편리한 도구인지를 체험할 수 있었다.
• 또한 여러 게임들을 플레이하고 보면서 실제 내가 사용했던 에셋과 비슷한 에셋들이 들어가있는 게임들을 발견하여 실제 게임 개발진들이 어떻게 게임을 구성하고 제작하는지를 경험할 수 있는 좋은 시간이였다.

intelliJ 사용

• 스프링 부트 스타터 사이트로 간편한 스프링 프로젝트 생성
• https://start.spring.io

• 접속 시 위와 같은 화면이 나올 것이다.

• project : Gradle-Groovy

• language : Java

• spring Boot는 괄호가 붙지 않은 2 버전 중 가장 최신 버전을 선택한다. 괄호가 붙은 버전들은 아직 미완성이거나 정식 릴리즈되지 않은 버전들이다.

• 위 사진에서는 2.7.7 선택

• 스프링 부트 버전 3부터는 강의와 다른 여러 가지 설정들이 필요하므로 버전 2를 사용한다.

• group명과 artifact명은 자유롭게 설정한다.

• artifact는 결과물의 이름으로 나오게 된다.

• packaging : Jar

• Java : 11

• 오른쪽 위의 버튼 ADD DEPENDENCIES를 누르고 Spring Web과 Thymeleaf를 선택하고 GENERATE 버튼을 눌러 다운을 받는다.

다운한 프로젝트 파일 열기

• 다운받은 파일의 압축을 풀고 intelliJ에서 프로젝트 열기 버튼을 누른다.
• 다운받은 파일의 gradle파일인 build.gradle을 선택하여 open as project로 열어준다.
• build.gradle 파일을 열어보면 자신이 했던 선택에 따라 자동으로 설정 코드가 입력되어있는 것을 볼 수 있다.
• git을 편리하게 이용할 수 있도록 .gitignore 파일까지 자동으로 설정된 것을 볼 수 있다.

프로젝트 환경 설정 확인

• 9번째 줄의 실행버튼을 누르고 main함수를 실행시킨다. 위와 같은 창이 나타난다면 인터넷 창을 열고 주소창에 'localhost:8080'을 입력한다.

• 다음과 같이 error page가 떴다면 성공이다.

실행속도 향상

• IntelliJ는 Gradle을 통해서 실행하는 것이 기본 설정이지만 이 경우 실행속도가 느리다.
• 다음과 같이 변경하면 자바로 바로 실행하기에 실행속도가 더 빠르다.
• file 탭의 setting창을 연 후 Gradle 검색 Build and run using : IntelliJ IDEA Run tests using : IntelliJ IDEA

라이브러리

• spring boot를 이용하여 프로젝트를 생성해보면 자동으로 수많은 라이브러리들을 가져온다.

• 웹 어플리케이션을 구동시키는데에 필수적인 것들이며 빌드 시 몇십메가씩 차지한다.

• 라이브러리들은 그 자체로 작동되지 않고 작동되기 위한 또다른 라이브러리들을 가져와서 최종적으로 'spring core' 까지 연쇄적으로 가져온다.

• 예전에는 tomcat 서버에 자바 코드를 집어넣는 등의 힘든 작업이 필요하지만 요즘에는 편리하게 라이브러리 하나만 넣어주면 자동으로 설정된다.

• system.out.println 사용보다 log에 남기는 것이 관리하는데에 편하기 때문에 log 사용은 필수적이다.

• 실무에서는 log 사용이 절대적이지만 강의에서는 println 사용

log에 대한 참고 https://velog.io/@woply/spring-SLF4J%EC%99%80-Logback%EC%9D%84-%EC%9D%B4%EC%9A%A9%ED%95%B4-%EB%A1%9C%EA%B7%B8-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0

• 크게 이러한 라이브러리들이 필요하다.

welcome page 만들기

• src - main - resources - static 파일에 index.html 파일 생성

• 아래 코드 붙여넣기

  <!DOCTYPE HTML>
  <html>
  <head>
  <title>Hello</title>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  </head>
  <body>
  Hello
  <a href="/hello">hello</a>
  </body>
  </html>

• 저장 후 서버를 동작 localhost:8080에 접속하면 에러페이지 대신 다른 화면이 등장한다.

• 이것은 별도의 프로그래밍이 아닌 넣은 그대로 동작하는 정적 페이지이다.

• thymeleaf 템플릿 엔진 사용

컨트롤러 만들기

• src - main - java - hello.hellospring 에 controller 패키지를 생성하고 거기에 HelloController를 만든다.

package hello.hellospring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("hello")
    // @GetMapping("hello")는 /hello의 접속을 hello를 호출하도록 해준다.
    public String hello(Model model){
        model.addAttribute("data","hello!!");
        // data라는 이름의 키의 value값이 hello!!이다.
        return "hello";
    }
}

• 템플릿에 hello.html 파일을 만들어준다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p th:text="'안녕하세요. ' + ${data}" >안녕하세요. 손님</p>
  <!-- 결과적으로 data 자리에 hello!!로 치환되어 화면에 출력된다. -->
</body>
</html>

• 결과 밑줄이 쳐진 hello를 누르면 아래와 같은 창이 나타난다.

빌드하고 실행하기

※ 윈도우 기준

• git bash 이용 필요

• gradlew.bat 파일이 있는 프로젝트 파일로 경로 이동

  ex) cd C:\work\intelliJ_project\hello-spring

• gradlew 입력 후 엔터하면 빌드가 된다.

• 만약 libs폴더가 생성되지 않았다면 다시 시도한다.

• ./gradlew clean build 위 명령어 입력 시 초기화하고 다시 빌드함.

• 성공적으로 빌드되었다면 libs 파일의 jar파일을 확인한다.

• java -jar hello-spring-0.0.1-SNAPSHOT.jar 입력

• 마지막으로 localhost:8080 접속하여 확인한다.

강의 사이트 https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

https://www.acmicpc.net/problem/9251

문제

LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때, 모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는 문제이다.

예를 들어, ACAYKP와 CAPCAK의 LCS는 ACAK가 된다.

입력

첫째 줄과 둘째 줄에 두 문자열이 주어진다. 문자열은 알파벳 대문자로만 이루어져 있으며, 최대 1000글자로 이루어져 있다.

출력

첫째 줄에 입력으로 주어진 두 문자열의 LCS의 길이를 출력한다.

풀이

배낭 문제의 알고리즘과 비슷한 LCS(최장 수열) 문제이다.

이차원 배열을 만들고 관행(?)에 따라 인덱스 0번자리에는 모두 0으로 빈 자리로 남겨두고 1번부터 사용한다.

ACAYKP와 CAPCAK를 예시로 들겠다. 첫번째 C와 A는 같지 않으므로 왼쪽 또는 위쪽 중 큰 값을 그대로 가져온다. 두번째 C와 AC에서 같은 부분 C가 나왔으므로 +1 을 해준다.

다음 CA와 ACA를 보겠다. 같은 부분 CA가 나왔는데 이때 C와 AC를 검사한 값에서 +1을 해주어야 한다. 이유는 중복되어 검사될 수 없기 때문이다. 마지막 A가 서로 같아서 값을 올려주는 것이기 때문에 검사에 사용된 두 A를 뺀 값에서 더해주어야한다.

따라서 왼쪽 위 인덱스의 값에서 +1 을 해준다.

다음은 예제의 결과이다.

코드

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

int letter[1001][1001];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    string a, b;
    cin >> a >> b;

    for (int i = 1; i <= b.length(); i++) {
        for (int j = 1; j <= a.length(); j++) {
            if (b[i - 1] == a[j - 1]) {
                letter[i][j] = letter[i - 1][j - 1] + 1;
            }
            else {
                letter[i][j] = max(letter[i - 1][j], letter[i][j - 1]);
            }
        }
    }
    cout << letter[b.length()][a.length()];

    return 0;
}

https://www.acmicpc.net/problem/2812

문제

N자리 숫자가 주어졌을 때, 여기서 숫자 K개를 지워서 얻을 수 있는 가장 큰 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 K가 주어진다. (1 ≤ K < N ≤ 500,000)

둘째 줄에 N자리 숫자가 주어진다. 이 수는 0으로 시작하지 않는다.

출력

입력으로 주어진 숫자에서 K개를 지웠을 때 얻을 수 있는 가장 큰 수를 출력한다.

풀이

무조건 높은자리수에 있는 숫자가 커야 가장 큰 수를 만들 수 있으므로 9가 아니라면 지울 수 있는 개수만큼 뒤의 숫자들을 검사하고 가장 큰 수를 넣는다. 넣은 수 앞의 부분은 결과에 넣지 않는다.

속도 향상을 위해 0인 경우와 9인 경우는 따로 조건문을 만들었다.

코드

#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int N, K;
    cin >> N >> K;

    string num;
    cin >> num;

    string result = "";

    for (int i = 0; i < N; i++) {
        if (result.length() == N - K)
            break;
        int x = 0;
        if (K == 0)
            result += num[i];
        else {
            if (num[i] == '9') {
                result += num[i];
            }
            else if (num[i] == '0') {
                K--;
                continue;
            }
            else {
                for (int j = 1; j <= K; j++) {
                    if (num[i + x] < num[i + j]) {
                        x = j;
                        if (num[i + j] == '9')
                            break;
                    }
                }
                if (x == 0 && i == N - 1 && K == 1)
                    break;
                result += num[i + x];
                K -= x;
                i += x;
            }
        }
    }
    cout << result;

    return 0;
}

https://www.acmicpc.net/problem/12865

문제

이 문제는 아주 평범한 배낭에 관한 문제이다.

한 달 후면 국가의 부름을 받게 되는 준서는 여행을 가려고 한다. 세상과의 단절을 슬퍼하며 최대한 즐기기 위한 여행이기 때문에, 가지고 다닐 배낭 또한 최대한 가치 있게 싸려고 한다.

준서가 여행에 필요하다고 생각하는 N개의 물건이 있다. 각 물건은 무게 W와 가치 V를 가지는데, 해당 물건을 배낭에 넣어서 가면 준서가 V만큼 즐길 수 있다. 아직 행군을 해본 적이 없는 준서는 최대 K만큼의 무게만을 넣을 수 있는 배낭만 들고 다닐 수 있다. 준서가 최대한 즐거운 여행을 하기 위해 배낭에 넣을 수 있는 물건들의 가치의 최댓값을 알려주자.

입력

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)가 주어진다.

입력으로 주어지는 모든 수는 정수이다.

출력

한 줄에 배낭에 넣을 수 있는 물건들의 가치합의 최댓값을 출력한다.

풀이

이 문제는 DP이지만 배낭문제라는 알고리즘을 이해해야 풀기 쉬운 문제였다. 배낭문제는 Knapsack Problem으로 물건을 쪼갤수 있느냐에 따라 Greedy Algorithm 또는 Dynamic Programming으로 갈린다.

이 문제는 물건을 쪼갤수 없는 DP로 푸는 배낭문제이다. 2차원 배열에 물건하나씩 검사하여 저장하는데 각각의 인덱스는 순서, 무게를 나타내고 들어있는 data값은 가치를 나타낸다.

2차원 배열의 형식은 dp[n][m]=d로 나타내겠다 물건을 하나씩 넣으면서 n번째 물건이 m의 무게보다 큰지 확인하고 크다면 전 배열의 가치 값을 가져오고 작거나 같다면 (현재 물건의 가치 + 남은 무게의 최대 가치) 와 (전 배열의 가치)를 비교하여 큰값을 넣는다.

코드

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int arr[110][100010];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int N, K;
    cin >> N >> K;

    int a, b;
    vector<pair<int, int>> v;

    for (int i = 0; i < N; i++) {
        cin >> a >> b;
        v.push_back({ a,b });
    }

    for (int i = 1; i <= N; i++) {
        int weight = v[i - 1].first;
        int value = v[i - 1].second;
        for (int j = 1; j <= K; j++) {
            if (weight <= j) {
                arr[i][j] = max(arr[i - 1][j - weight] + value, arr[i - 1][j]);
            }
            else {
                arr[i][j] = arr[i - 1][j];
            }
        }
    }

    cout << arr[N][K];


    return 0;
}