웹 MVC의 컨트롤러 역할이다. 다만 나의 경우 MVC 구조가 아니라 REST API 구조로 개발을 진행할 것 같은데, 이 경우에도 컨트롤러라는 명칭과 역할이 유효한지는 아직 모르겠다.
(2) 서비스(Service)
비즈니스 로직을 다루는 부분이다. (계좌 이체, 주문 발송 데이터 추가 등등) 아직 컨트롤러를 제외한 부분은 구현해본 적이 없기 때문에 방대한 웹 어플리케이션에서 서비스와 컨트롤러의 정확한 차이점은 잘 모르겠다. 비즈니스 로직을 구현하는 부분인 만큼 앞으로 제일 복잡해질 부분인 것 같다.
(3) 리포지토리(Repository)
DB에 직접 접근하는 부분이다. DB에 접근하는 코드를 많이 써야할 것으로 예상된다. DB에 접근해서 도메인 객체를 추가/변경/삭제하는 작업이 직접적으로 일어나는 부분이다.
(4) 도메인(Domain)
비즈니스 도메인 객체이다. 비즈니스 로직을 처리하기 위해 만드는 객체를 의미한다.
10-2. 비즈니스 요구사항 정리 with 새로웠던 부분들
(1) DB 설계
강의에서는 아주 간단한 회원가입 형식을 구현할 수 있도록 DB를 설계할 예정이라고 한다. 그러나 내가 목표로 하는 프로젝트는 주문 관리, 배송, 장바구니 등등 다양한 기능이 포함된 비즈니스 로직을 갖췄기 때문에 추후 [스프링 활용 편-1] 강좌를 생각해볼 필요가 있겠다!
+ DB 설계는 누가 하는걸까? 메인 개발자가 하나? 다음에 이 부분을 물어봐야겠다.
+ 메인 개발자가 확정되었는지, nodeJS 쓰는지 spring 쓰는지도 물어봐야지.
(2) 리포지토리 인터페이스(Repository Interface)
구현 클래스가 아니다. 어떤 DB를 사용할지 확정되지 않은 상황에서 개발을 진행하거나, 여러 개의 DB와 연결해야 하는 상황에서는 인터페이스를 사용한다고 한다. 그래야 구현체를 비교적 쉽게 변경/추가할 수 있기 때문이다.
+ 프로젝트에서는 어떤 DB를 사용할 예정인지(줌 미팅에서는 1차 개발에서는 DB를 하나만 사용할 거라고 들었다) 물어봐야겠다. 그러나 2차 개발을 한다면 어차피 여러개의 DB를 사용해야 하므로(실제로도 회원 정보 등을 여러 DB에 나눠서 저장하는 것이 꽤 흔하고, 이럴 경우 DB에서 오류 발생 시 어떤 DB/스키마에서 오류가 났는지를 쉽게 알 수 있다는 장점이 있다. <-> 단점은 복잡하다는 것), 리포지토리 인터페이스를 알아두면 언젠가는 분명 도움이 될 것 같다.
11. 회원 도메인과 리포지토리 만들기
순서는
[ 도메인 클래스 만들기 -> 리포지토리 인터페이스 만들기 -> 리포지토리 구현체(메모리ver) 만들기 ] 이 순서로 진행했다.
1) 도메인 클래스 Member.java
크게 Long(Wrapper 클래스) 타입의 id 필드와 string 타입의 name 필드로만 이뤄져 있다. (로그인이 없는 초간단 구조...)
보통 회원가입을 진행하는 경우에도, 서버에서 회원을 구분하는 목적으로 id라는 필드를 선언한다. 즉 '로그인에서 사용자가 입력하는 아이디'와 '서버에서 사용자를 분류하거나 찾기 위한 목적의 아이디'는 서로 다르다. 여기서의 id 필드는 서버에서 구분하기 위한 목적의 필드이다.
또한 실제 서비스에서는 아이디를 long이 아닌 AtomicLong 타입으로 주로 선언한다고 한다. 이유는 '동시성 문제' 때문이란다. (회원가입이 동시에 일어나는 경우 등등에서는 AtomicLong 타입이 문제를 발생시키지 않는다는 것 같다. Map의 경우에도 ConcurrentHahMap을 사용해야 동시성 문제가 발생할 가능성이 없다고 한다. )
회원 관련 정보이므로 필드들은 private 타입으로 설정하고, 대신에 getter, setter 메소드가 있다.
2) 리포지토리 인터페이스 MemoryRepository.java
객체로 DB에 접근한다고 가정할 때 필요한 기본적인 메소드를 '선언'했다. (정의는 구현체에서 한다. 인터페이스는 선언만!)
회원을 저장하는 save(), id로 회원을 찾는 findById(), name으로 회원을 찾는 findByName(), 등록된 모든 멤버를 보여주는 findAll() 메소드를 선언했다.
다만 findById(), findByName() 메소드의 경우 찾는 회원이 없으면 null 값이 반환될 수 있다. 이 경우 null은 메소드의 리턴 타입인 Member과 달라서 오류가 날 수 있다.
하지만 Java 8 이상에서는(맞나?) Optional<> 문법을 제공한다. Optional<타입>이란, 메소드가 해당 타입을 리턴할 수도 있고 null을 리턴할 수도 있을 때 사용한다. 이 경우에는 Optional<Member>를 사용해서, 주어진 정보에 해당하는 회원이 있으면 Member 타입, 없으면 null도 리턴될 수 있도록 선언했다.
3) 리포지토리 구현체 MemoryMemberRepository.java
인터페이스에서 선언만 해놓은 메소드들을 override해서 재정의한다.
강의에서는 DB가 없는 상황을 가정했기 때문에, DB 대신으로 저장소 역할을 할 store라는 private static 이면서 Map 타입인 객체를 선언한다. Map 타입인 이유는 앞서 도메인에서 사용자를 구분하기 위한 목적으로 선언한 id 필드를 key 값으로 하고, member 객체를 value로 둬서 사용자를 조회하기 편리하게 만들기 위해서이다. 다만 Map은 구현체가 아니라 인터페이스이므로, HashMap 구현체를 사용한다.
private static Map<Long, Member> store = new HashMap<>();
즉 이런 코드가 된다.
+ HashMap을 사용할 거면 앞의 Map 부분 대신에 HashMap 타입으로 필드를 만들면 되지 않을까? 왜 Map 타입으로 선언했는지는 잘 모르겠다. (이 부분이 교재에 있었는데 찾아봐야겠다.)
실제로 findById()와 findByName() 메소드는 이 store 저장소 객체를 이용해서 사용자 정보를 조회한다.
findById()의 경우 map의 key 값이므로 간단하게 get(key value) 메소드를 이용해서 조회가 가능하다.
그러나 findByName()의 경우는 매개변수로 주어지는 string name은 map의 key 값이 아니므로 바로 조회할 수 없다. 강의에서는 그래서 람다식을 사용했다. .stream(), .filter() 메소드를 통해서 매개변수로 주어진 name과 이름이 같은 멤버 객체를 조회하고 리턴하는 코드이다.
save() 메소드의 경우 보통은 저장한 객체를 다시 리턴해준다.
findAll() 메소드의 경우, 여러 객체를 한번에 리턴해야 하기 때문에 List 타입을 사용했다.
(정확히는 List 인터페이스를 받은 ArrayList 타입. 아까의 Map 경우랑 똑같다. 왜 앞 부분에도 ArrayList 타입이 아니라 List 타입으로 선언했는지를 잘 모르겠다. )
12. 회원 리포지토리 테스트 케이스 작성
앞서 스프링이 별도로 테스트를 위한 패키지와 라이브러리를 제공하는 만큼 테스트는 매우매우 중요하다고 언급했다. 따라서 11강에서 작성한 리포지토리 구현 클래스의 메소드들이 잘 작성되었는지를 테스트 해 보려고 한다.
테스트의 장점은 (1) 메인 메소드를 매번 실행할 필요가 없고, (2) 수십개의 테스트를 한 번에 돌릴 수 있으며, (3) 실제 DB에 연결된 클래스 등을 테스트할 때 DB 등의 자료가 변경될 위험이 없는 등 여러 가지가 있다.
+ 실제 DB를 연결하는 경우는 어떻게 테스트 코드를 짜는지 궁금하다. 임시 DB를 만드려나? 아니면 강의에서처럼 DB역할을 대신할 객체를 만드는 걸까?
테스트 코드는 src>test 디렉토리 내부에 작성하며, 여러 파일이 있을 경우 src>main 내부와 비슷한 구조로 작성한다. 강의에서는 리포지토리 클래스 하나만 테스트를 해 보았다. 또한 관용적으로 테스트 클래스의 이름은 테스트하려는 클래스의 이름 + Test 를 붙인다. 예를 들어, 여기서는 MemoryMemberRepositoryTest.java 파일이 작성된 셈이다.
테스트 클래스 내부에서는 우선 테스트하려는 클래스 객체를 만든다. 하나의 테스트 클래스에서 여러 테스트 메소드를 작성할 수 있다. 이때 각 테스트 메소드 위에다 반드시 @Test annotation을 붙여야 한다. 그래야 스프링이 해당 메소드를 테스트로 인식한다.
또한 테스트에서는 System.out.println() 등으로 화면에 직접 출력을 하지 않는다. 대신 Assertions 또는 assertThat 등의 외부 테스트 라이브러리의 메소드를 가져온다. 그래서 테스트를 실행해 보면 별도의 출력이 없다. 잘 실행되면 초록색 체크 표시가 뜨고, AssertThat 등의 조건과 맞지 않는 결과가 출력될 경우에는 에러가 뜬다.
+ 강의에서는 항상 테스트 메소드의 맨 마지막에 Assertions 또는 AssertThat 코드가 배치되는데, 꼭 이 코드가 마지막에 배치되어야 하는지도 궁금하다.
여러 개의 테스트 사이에는 반드시 순서나 의존관계가 없어야 한다. 스프링에서는 여러 개의 테스트가 있을 때 실행순서가 랜덤이다. 어느 순서로 테스트하던지에 상관없이, 에러가 발생하지 않아야 한다. (ex. 테스트 1의 결과에 따라서 테스트 2의 결과가 달라지는 경우 등등) 또한 DB 등 저장소 역할을 하는 객체에 접근하는 경우, 메모리를 초기화하지 않으면 이전 테스트에서 남긴 데이터/객체가 다음 테스트의 결과에 영향을 줄 수 있다. 따라서 하나의 테스트가 끝나고 나면 메모리를 비워주는 작업이 필요하다.
스프링에서는 @AfterEach annotation을 붙인 메소드를 사용하면 각 테스트가 끝날 때마다 해당 메소드를 실행시킨다. 보통 이런 메소드에는 데이터 저장소의 초기화 코드가 들어간다.
또한 예제 코드를 보니 테스트를 꼭 메소드 수 만큼 만들 필요는 없는 것 같다. 그냥 테스트하려는 부분에 초점을 맞춰서 필요한 만큼의 테스트를 만들면 될 것 같다.
그리고 테스트 메소드는 외부에서 따로 매개변수를 받지 못하므로, 기존 메소드의 리턴 타입을 쓰기보다는 매개변수도 없고 리턴 타입도 void를 사용하는 것 같다.
스프링에서 만든 뷰를 띄우려면 html 파일이 필요하다. html 파일은 resources>static 또는 resources>template 디렉토리에 저장한다. 그러나 두 디렉토리에 저장하는 것은 각각 다른 의미가 있다.
1) resources>static
정적 파일(static files)들을 모아두는 디렉토리이다. 여기에는 정적 웹페이지도 포함된다. 별도의 코딩을 거치지 않고 그대로 html 파일을 띄우는 경우가 정적 웹페이지에 해당한다. 물론 여기에 assets, css, js 등의 디렉토리를 추가해서 css, js, 기타 jpg 파일 등을 추가하여 다른 종류의 정적 파일들도 저장할 수 있다.
이 static 디렉토리를 이용하여 스프링에서 제공하는 기능이 있다. 바로 웰컴 페이지(Welcome Page) 기능이다.
웰컴 페이지란, HTTP GET 메소드를 통해(주로 url 검색) 기본 주소(127.0.0.1:8080)로 들어갔을 때 나오는 페이지를 의미한다.
웰컴 페이지를 설정하기 위해서는 resources>static 디렉토리에 index.html 파일을 추가하면 된다. HTTP GET 방법으로 기본 URL에 들어왔을 때(POST 등 다른 방식이면 웰컴 페이지 기능이 적용되지 않을 수 있다) index.html 파일이 웰컴 페이지로 사용된다.
2) resources>template
여기에도 .html 파일을 저장할 수 있지만, 정적 파일이 아닌 파일을 저장한다. 말 그대로 일정의 양식을 따르는 '템플릿'으로 사용할 파일들을 저장한다. 사실 html 파일을 정적으로 사용하지 않고 여러 변수를 외부에서 받아오는 방법은 여러 가지가 있다. 그 중의 하나가 템플릿 엔진(template engine)이다.
앞서 3강에서는 템플릿 엔진으로 사용할 Thymeleaf 라이브러리를 당겨 왔다. 파일의 기본 형식은 html과 큰 차이가 없지만, 이런 식으로 템플릿 엔진을 불러와서 'th'라는 변수로 설정하여 사용할 수 있다.
<html xmlns:th="http://www.thymeleaf.org">
2. 컨트롤러(Controller class)
템플릿의 경우, 정적 파일과 달리 어떤 데이터를 입력하는지에 따라 뷰에서 출력되는 내용이 달라질 수 있다. Spring MVC(Model-View-Controller) 패턴에서는 뷰를 다루기 위해서 '컨트롤러' 클래스를 사용한다. 컨트롤러 클래스들은 보통 src>main 디렉토리 아래에 따로 controller 디렉토리를 설치하고 그 안에서 관리한다.
컨트롤러의 특징
(1)
컨트롤러 클래스에는 반드시 @Controller 이라는 annotation(@)을 붙여 이 클래스가 컨트롤러로 사용됨을 명시해 주어야 한다. 그래야 스프링 내부에서 뷰를 처리할 때 해당 클래스의 메소드를 사용해서 사용자가 의도한 대로 뷰를 처리할 수 있다.
(2)
컨트롤러 안에는 여러 메소드가 들어갈 수 있다. 메소드 위에도 @ annotation을 붙여서 해당 메소드의 역할을 명시해 주어야 한다.
많이 사용되는 annotation 중 하나는 @GetMapping(url 주소)이다. 이게 붙은 메소드는 해당 url 주소로 HTTP GET 접근을 했을 때 어떤 식으로 뷰를 처리할지에 대한 내용을 담게 된다.
해당 메소드는 매개변수로 Model(모델)을 받는다. MVC 중 하나인 모델은 외부에서 따로 컨트롤러에 할당하는 매개변수는 아니고, 스프링에서 자동으로 컨트롤러 클래스에 매개변수로 주입하는 것 같다.
또한 모델에는 여러 메소드가 있다. 강의에서는 addAttribute() 메소드를 사용해서 모델에 속성을 부여했다. addAttribute 메소드는 '속성의 이름'과 '속성값'을 받는다.
ex) addAttribute 메소드로 "data"라는 속성 이름과 "Hello" 라는 값을 모델의 속성으로 추가했다고 해 보자.
(4)
컨트롤러는 뷰와 연결되며, 뷰를 리턴해야 한다. 이때 resource>template에 저장된 템플릿의 이름을 단순 문자열로 리턴한다면, 해당 뷰와 연결된다.
ex) resource>template에 hello.html 파일이 있다고 해 보자. 컨트롤러 클래스에서 "hello"라는 문자열을 리턴했다면, 스프링은 자동으로 resource>template 에서 "hello"라는 이름의 템플릿 파일을 찾아서 뷰로 리턴한다.
3. IDE가 아닌 환경(터미널 창)에서 스프링 프로젝트 실행하기
앞서 프로젝트는 모두 인텔리제이 IDE에서 실행되었다. 그러나 사실 자바로 작성된 프로젝트의 경우, jar 파일이 있다면 로컬 터미널(윈도우의 cmd 창)에서도 실행할 수 있다. 물론 그러기 위해서는 몇 가지 과정이 필요하다.
(1) 프로젝트 빌드
스프링 프로젝트가 설치된 디렉토리로 이동해서 프로젝트를 빌드해야 한다. 윈도우 cmd의 경우, cd 명령어를 통해 프로젝트의 디렉토리로 이동한다. 이후 gradlew.bat build 명령어를 입력하면 빌드가 실행되고, 프로젝트 내부에 build라는 새로운 디렉토리가 생긴다.
(2) jar 파일 찾아서 실행
프로젝트에서 build>libs 디렉토리로 이동해서 dir 명령어를 통해 안에 어떤 파일이 있는지 본다.
빌드가 잘 실행되었다면 .jar 으로 끝나는 파일이 두 개가 있다. (하나만 있을 수도 있다.) 이 중 우리는 -plain이 아닌 그냥 jar 파일을 실행하면 된다.
실행은 자바 환경변수를 이용해서 java -jar 프로젝트의-이름
이렇게 명령어를 입력하면 IDE 환경에서와 똑같이 스프링 시작화면이 뜬다. 그러면 성공이다. 이런 방식으로, 만약 다른 환경에서 스프링을 실행해야 할 경우가 생긴다면 jar 파일만 갖고 있으면 된다. 그러면 터미널에서 실행할 때도 필요한 라이브러리 등을 자동으로 설치해서 실행이 된다고 한다.
+ 예상하지 못한 오류
실행은 잘 되었고 정적 파일로 설정한 웰컴 페이지도 그대로 나왔다. 그러나 앞서 사용했던 템플릿 엔진을 이용한 hello.html 파일이 제대로 실행되지 않았다. cmd 창에서 템플릿 엔진이 제대로 로딩되지 않았다는 오류가 떴다. 이유를 알아봐야겠다....
인상깊은 내용
스프링에서 모르는 내용을 검색하는 방법.
스프링은 너무 방대해서 모든 걸 다 알 수가 없다고 한다. 그래서 '모든 걸 알아야지!' 라고 접근하는 대신, 모르는 것을 찾는 방법을 아는 게 중요하다고 말씀하셨다.
스프링 기본 홈(Spring | Home)화면으로 들어가서, Projects 탭에서 사용하는 스프링 라이브러리 이름을 누르면 해당 라이브러리에 대한 공식 문서 및 설명을 볼 수 있다. 이 강의에서는 Spring Boot를 사용했으므로 Projects>Spring Boot으로 들어가자. 이후 현재 사용하는 스프링 버전 옆의 'Reference Doc' 를 클릭하면 해당 버전에서 사용되는 기능들의 공식 문서들을 볼 수 있다.
그런데 스프링의 라이브러리들은 서로 의존관계가 있다. gradle은 외부 라이브러리를 당겨올 때 내가 지정한 라이브러리 뿐만 아니라, 그 라이브러리가 의존하는 다른 라이브러리까지도 모두 당겨온다. 그래야 그 라이브러리를 사용할 수 있다. 결과적으로 당겨오다 보면 spring core 라이브러리까지 모두 당겨오게 된다. 즉 처음에 선택한 라이브러리 당겨오기->그 라이브러리가 의존하는 다른 라이브러리 당겨오기-> ... 더 이상 의존하는 라이브러리가 없을 때까지 이런 방식으로 필요한 모든 라이브러리를 당겨온다. 그렇기 때문에 내가 필요하다고 지정한 라이브러리에 비해서 실제로 당겨온 라이브러리가 훨씬 많다.
그래서 어떤 라이브러리를 당겨 왔는지를 보려면 Intellij 화면 왼쪽의 프로젝트 탭에서 External Libraries를 보면 된다. 또는 화면 우측 상단에 마우스를 대면 Gradle이라는 버튼/탭이 나오는데, 그 탭을 누르면 스프링이 의존관계에 기반해서 어떤 라이브러리를 당겨 왔는지를 순차적으로 볼 수 있다.
2. gradle에서 당겨 오는 라이브러리의 종류
이 프로젝트에서는 어떤 라이브러리를 당겨 왔을까?
너무 많아서 간단하게 3가지만 다뤘다.
1) 내장형 웹 서버 Tomcat
톰캣(tomcat)은 웹 서버이다. 스프링같은 프레임워크가 발달하기 전에는 톰캣을 따로 설치하고, 그 안에 자바 코드를 밀어넣는 방식으로 웹 서비스를 만들었다고 한다. 그러나 스프링에서는 내장형 웹 서버로 톰캣을 사용할 수 있는 라이브러리를 만들었다. 따라서 이 라이브러리를 당겨오기만 하면(설치하기만 하면) 톰캣을 따로 설치하는 과정이 없이도 웹 서버를 실행할 수 있게 바뀌었다고 한다.
스프링 3강에서 웹 서버를 실행할 때, 톰캣 서버는 HelloSpringApplication.java 의 메인 메소드를 실행하면 바로 실행되었다. 즉 스프링에서 당겨오는 라이브러리와 상관 없이 내장형 톰캣 서버 라이브러리(정확한 명칭은 모른다)는 항상 설치된다는 말이다.
= 이 내장형 톰캣 서버 라이브러리는 기본적으로 당겨오는 라이브러리로, spring boot 라이브러리가 의존하고 있는 라이브러리이다.
+ 내장형 웹 서버의 개념이 생소하고 웹 서버의 개념도 생소하다... 개념을 좀 더 알아보도록 하자.
로깅이란 말 그대로 로그를 남기는 것이다. 로그는 웹 서버에서 남기는 일종의 기록이다. 개발자들은 System.out.println()을 쓰는 대신 로그를 남긴다고 한다. 그 이유는 로그의 레벨(WARN, INFO, FATAL 등등등)에 따라서 로그를 모아 보기도 쉽고, 외부 파일에 저장하기도 쉽기 때문이다. 반면 println() 메소드는 계속 사용한다면 프로그램 실행 속도를 저하시킨다는 문제도 있기 때문에 로깅 라이브러리가 사용된다.
로그 레벨은 TRACE-DEBUG-INFO-WARN-ERROR 으로 5개의 레벨이 있다. 오른쪽으로 갈수록 심각성이 크다. 로깅 라이브러리를 사용하면 원하는 레벨의 로그만 모아서 볼 수 있으며, 로그의 근원지에 따라서 다른 기준치의 로그 레벨을 사용할 수도 있다.
ex) A 클래스에서 발생하는 로그는 INFO 레벨 이상(INFO 및 INFO보다 심각성이 높은 레벨인 WARN, ERROR)만 출력하고, B 클래스에서 발생하는 로그는 ERROR 레벨만 출력하도록 구체적인 로깅 설정을 할 수 있다.
아무튼 강의에서는 크게 2가지의 로깅 라이브러리를 언급했다. 물론 이거 말고도 여러 라이브러리가 있다.
(1) slf4j
: 로그를 남길 때 어떤 구현체로 남길지를 선언한 인터페이스라고 한다. 즉 로그를 직접 남기는 라이브러리는 아니지만, 어떤 구현체를 사용해서 로그를 남길 때 어떤 방법으로 남길지를 선언한 라이브러리다. 로깅 인터페이스를 사용하면 나중에 더 좋은 로깅 구현체가 생겨서 구현체 라이브러리를 교체하더라도, 따로 코드를 변경하지 않아도 된다는 장점이 있다.
(2) logback
: 로그를 남기는 라이브러리이며, slf4j와 달리 인터페이스가 아니라 구현체이다. 또한
또한 여러 로깅 라이브러리 중에서 스프링이 기본적으로 사용하는 로깅 라이브러리가 정해져 있다. Apache의 commons-logging 라이브러리인데, 이 경우 다른 로깅 라이브러리를 당겨와도 기본 라이브러리가 있어서 사용되지 않을 수 있다. 이런 경우는 logback 라이브러리를 기본으로 사용하면서도 commons-logging 라이브러리와 똑같은 구조를 가진jcl-over-slf4j 라이브러리를 당겨오면 된다고 한다. 로깅 라이브러리를 사용할 때도 고려할 점이 많은 것 같다.
3) 테스트 라이브러리
앞서 3강에서는 프로젝트 기본 구조에서 main 디렉토리 말고 test 디렉토리가 따로 생성되어 있다고 했다. 이만큼 테스트의 중요도가 크다. 따라서 gradle에서도 기본 설정으로 테스트 라이브러리를 당겨온다. 정확한 테스트 과정은 모르지만, 대표적인 몇 개의 테스트 라이브러리를 살펴보자.
(1) jUnit
가장 많이 사용되는 테스트 라이브러리이다.
(2) mockito, assertj
테스트를 간편하게 실행할 수 있도록 도와주는 라이브러리이다.
(3) spring-test
테스트 라이브러리들을 스프링 환경에서 바로 실행할 수 있도록 스프링 환경과 연결해 주는 라이브러리이다.
+ 몰랐던 개념들 / 다음에 더 알아볼 개념들
1. 웹 서버의 개념, 내장형 웹 서버의 개념, tomcat은 구체적으로 무엇인지
2. 로깅의 실제 활용 방법, 로깅 인터페이스와 로깅 구현체 라이브러리는 구체적으로 어떻게 구성되었는지
(스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 v2021-12-01)
스프링 강의로 유명한 김영한 님의 스프링 기초 강의이다. 심지어 무료(!)
이 강의를 들으면서 스프링으로 간단한 프로젝트를 구현하며 스프링 기초를 이해해 보자.
1. 스프링 시작하기 및 기본 개념
Spring Boot:
spring 프로젝트를 쉽게 만들어주는 도구. start.spring.io 주소로 이동해서 빌드 관리 도구, spring boot 버전, 사용할 언어(여기서는 Java), 프로젝트 이름, 사용할 Dependencies(스프링이 제공하는 여러 기능, 라이브러리들)을 고르고 GENERATE 버튼을 누르면 해당 조건들을 갖춘 프로젝트를 바로 만들어 준다.
빌드 관리 도구:
maven or gradle.
Maven이 Gradle보다 먼저 나왔지만 현재는 gradle을 많이 사용한다. 여기서도 gradle으로 진행한다.
빌드 관리 도구란: 스프링 프로젝트를 만들면서 필요한 외부의 라이브러리 등의 사용을 관리해 주고, 프로젝트를 실행(빌드)하는 과정을 전반적으로 관리해주는 프로그램이다. (외부 라이브러리를 사용할 때는 gradle에 명시해 주면 프로젝트 내부에서 따로 import 과정을 거치지 않아도 되고, gradle 자체에서 build 설정이 되어 있기 때문에 사용자는 그냥 프로젝트를 실행하기만 하면 된다.)
Dependencies: 스프링에서 제공하는 여러 라이브러리(기능들) 중 어느 것을 사용할 것인지를 선택.
여기서는 (1) 웹 프로젝트이므로 Spring Web, (2) .html 파일을 만들기 위해서 필요한 템플릿 엔진(template engine) 중 하나인 thymeleaf 두 개의 라이브러리를 추가했다. (템플릿 엔진의 개념은 추후에 자세히 알 수 있을 것 같다.)
2. 프로젝트 기본 구조
프로젝트의 기본 구조는 아래 화면과 같다.
그 중에서 강의에서 짧게 설명한 부분만 정리해 보았다.
-.idea : 인텔리제이에서 프로그램을 실행할 때 사용하는 파일들
-.gradle: gradle에서 사용하는 파일들
-src: 사용자가 직접 작성하는 파일들. 이 안에 프로그램을 구성할 파일들이 들어간다.
-src>main: 스프링 프로젝트를 구성하는 파일들.
-src>main>java: 스프링 프로젝트를 구성하는 자바 파일들.
-src>main>resources: 스프링 프로젝트를 구성하는, 자바 파일이 아닌 다른 파일들(html 템플릿 등이 포함된다.)
-src>test: 스프링 프로젝트를 구성하는 테스트 코드. 별도의 디렉토리로 분류될 정도로 요새는 test의 중요성이 커졌다고 한다.
-.gitignore: git을 사용한 사람들이라면 알던데 나는 잘은 모른다. git으로 프로젝트를 업로드할 때는 소스 코드만 올리고 기본 설정 파일 등 부가적인 것들은 올리지 말아야 하는데, 이 작업을 도와주는 파일이다. 간단하게 보면 프로젝트 안의 파일들 중 업로드할 것과 그렇지 않은 것을 구분해 준다.
-build.gradle: gradle을 통해 프로젝트를 build할 때 이 파일을 참고한다. 아까 start.spring.io에서 선택한 dependencies들이 이 파일의 plugins{}과 dependencies{} 내부에 명시되어 있다.
dependencies{} 안에 명시된 라이브러리들은 repositories{} 안에 명시된 mavenCentral() 이라는 곳에서 가져온다고 한다. 이 상태는 가장 기본일 뿐, 만약 가져오고 싶은 외부 라이브러리가 있다면 mavenCentral() 외에 다른 곳을 추가할 수도 있다.
또한 스프링에서는 테스트 코드를 위한 별도의 라이브러리(JUnit)도 기본으로 설정되어 나온다. 이만큼 테스트가 중요한 것 같다.
3. 프로젝트 실행하기
실행 방법은 매우 간단하다. src>main>java>HelloSpringApplication 안의 메인 메소드를 실행하면 프로젝트가 실행된다.
이게 가능한 이유는 해당 HelloSpringApplication 클래스에는 @SpringBootApplication 이라는 Annotation(@)이 붙어 있고, 이 Annotation 내부에는 Tomcat 서버가 내장되어 있기 때문에, 메인 메소드를 실행하면 tomcat 서버가 실행되는 원리이다.
+ 처음에는 아무런 작업도 하지 않았기 때문에 Error Page가 나오는 것이 정상이라고 한다.
+ 빌드 빠르게 하는 방법
gradle은 빌드 관리 도구라서 빌드 과정이 쉽게 이뤄지도록 도와주지만, gradle을 거쳐서 빌드를 하지 않아도 된다. 오히려 Intellij에서 gradle을 거치지 않고 빌드를 할 경우 속도가 더 빠르다.
Windows의 경우, File>Setting에서 설정 창을 열고 Build, Execution, Development>Gradle 창을 연다.
그리고 'build and run using' 과 'run tests' 옵션을 gradle이 아니라 Intellij로 설정한다.
이번에는 아까와 비슷하지만, url 주소 뒤의 쿼리(query) 형식으로 받은 변수를 json 형식으로 출력하는 코드이다.
DemoApplication.java, Greeting.java, GreetingController.java 3개의 클래스를 사용한다.
Greeting.java는 모델로 사용될 객체이다. json 형식으로 출력할 때, 어떤 필드들을 출력할지를 이 클래스에 정의해 놓는다.
Greeting.java
(참고한 포스트에 있는 코드 원본을 그대로 가져왔다.)
package com.example.restservice;
public class Greeting {
private final long id;
private final String content;
public Greeting(long id, String content) {
this.id = id;
this.content = content;
}
public long getId() {return id;}
public String getContent() {return content;}
}
id와 content 필드는 모두 private, final 이므로 한 번 생성하면 변경할 수 없고, 외부에서 값을 바꾸려고 시도할 수 없다.
GreetingController.java
(참고한 포스트에 있는 코드 원본을 그대로 가져왔다.)
package com.example.restservice;
import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GreetingController {
private static final String template = "Hello, %s!";
private final AtomicLong counter = new AtomicLong();
@GetMapping("/greeting")
public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
return new Greeting(counter.incrementAndGet(), String.format(template, name));
}
}
Greeting.java 에서는 id 필드가 long 타입이었는데, GreetingController에서는 굳이 AtomicLong 타입의 래퍼 클래스(Wrapper Class)를 사용했다. long 타입을 객체로 할 이유는 없지만 아마도 AtomicLong 클래스의 incrementAndGet 메소드를 사용하려는 의도인 것 같다.
#3
서버 포트 변경
나는 이전에 사용하던 django 프로젝트에서 8080번 기본 포트를 미리 사용하고 있었기 때문에, spring을 실행해도 웹 페이지가 나오지 않았다.
이런 경우에는 본인의 프로젝트 이름을 P라고 하면, 'P>src>main>resources>application.properties' 파일에 서버 포트를 따로 변경해주면 된다.
+application.properties 파일은 서버 포트를 바꾸거나, 기본 DB 대신 다른 DB를 사용하는 등 기본으로 설정된 사항을 바꿀 때 추가적인 옵션을 입력하는 파일이다.
server.port = 1000
이렇게 한 줄만 입력하면, 다음부터 실행할 때 1000번 포트로 연결된다.
+ spring 공식 홈페이지의 accessing data with mysql 포스트를 보면서 정리한 ORM 개념
hibernate는 무엇인가 싶어 검색해보니, 'Java 환경에서 제공하는 ORM 솔루션'이라고 한다.
그럼 ORM은 뭘까?
ORM: Object Relational Mapping
ORM이 왜 필요한가?
보통 프로그램을 작성하면서 여러 객체(object)를 만든다. 그러나 DB를 사용하는 경우 이 객체와 DB 안의 테이블을 연결해야 한다. SQL을 사용하여 직접 코드를 작성할 수도 있지만, SQL 코드를 사용할 필요 없이 프로그램에서 작성한 코드가 자동으로 DB에 해당 객체와 연결될 수 있는 테이블을 만들도록 할 수 있다. ORM 개념으로 이게 가능하다. (다만 모든 DB에 해당하는 얘기는 아니고, '테이블'이라는 개념이 있는 관계형 데이터베이스(Relational Database)에 해당한다고 한다.)
영상을 다 보지 않아서 모르지만, ORM이란 아마도 객체(object)와 데이터베이스를 서로 연결지어 맵핑(relational mapping) 하는 원리 또는 개념인 것 같다. Spring, Java에서도 당연히 이 ORM 개념이 있으며, 영상에서는 hibernation 개념도 이와 관련이 있다고 한다.
get_prime 메소드는 매개변수도 없고 출력값(리턴하는 값)도 없는 메소드인데, prime이라는 배열은 어디서 가져왔나?
get_prime() 메소드 위에다가 먼저 prime이라는 정적 boolean 타입의 필드를 선언해 주었다. 이렇게!
public static boolean[] prime; // main 메소드 밖에서 선언
나는 정적 필드를 선언할 생각은 못 했는데, 생각해 보니 정적 필드를 선언하고 그 필드를 정적 메소드에 언급하면 굳이 로컬변수나 객체를 생성하지 않아도 되겠다.
이렇게 위에서 정적 필드를 선언하고, 나중에 main함수 안에서 prime 배열의 길이만 선언해 주면 된다.
N+1의 길이로 설정해서 0부터 N까지의 소수값 여부를 저장할 수 있는 배열을 만들어 준다.
(정적 필드 prime배열을 N+1의 길이로 설정한 것도, 그냥 0부터 N까지의 수들 중 소수를 다 구해버리고 나중에 M에서 N 사이에 있는 소수 값만 추출하기 위해서인 것 같다. prime배열을 M부터 N까지 선언한다면 기존 에라토스테네스의 체 알고리즘을 일부 변형해야 되서 번거로운 점도 있을 듯.)
prime = new boolean[(N+1)]; // main 메소드 안에서 설정
에라토스테네스의 체 알고리즘은 2개의 중첩 for문으로 구성된다.
1. 여기선 true이면 소수가 아니고 false면 소수라고 간주한다.
2. 이는 어떤 수의 배수는 모두 소수에서 제외한다는 원리를 이용한다.
첫 번째 for문에서의 i는 어떤 수의 역할을 한다.
두 번째 for문에서의 j는 어떤 수의 배수 역할을 한다.
좀 더 구체적으로 보면,
1. 0과 1은 소수가 아니고 2는 소수라서, i=2부터 시작한다.
2. j는 i*i이다. i*i는 i라는 약수를 갖기 때문에 소수에서 제외된다.
3. 이 j에다가 i씩 더한다. 즉 i*i, i*(i+1), i*(i+2), ... 이렇게 해서 i를 약수로 갖는 모든 값들을 제외시킨다.
4. 그 다음은 i=3, 위의 과정을 반복한다. 그런데 만약 i=4처럼 소수가 아닌 값이 i 자리에 와도 이미 i=2일 때 j의 값에 해당되어서 제외되었기 때문에 상관 없다.
5. 이렇게 N까지 반복하는 것이 아니라, N에 루트 씌운 값까지만 반복한다. 그 이후의 값은 검사할 필요가 없다.
+) 5번의 이유:
어떤 자연수 N은 1과 자신이 아닌 다른 두 수 A와 B의 곱으로 나타낼 수 있다고 해 보자. (즉 N은 소수가 아니다.)
A * B = N이다.
그런데 만약 A가 N의 제곱근보다 크다면, 나머지 B는 반드시 N의 제곱근보다 작아야 한다. 안 그러면 A*B는 N보다 큰 값을 갖게 되어서 식이 성립하지 않는다.
=> 즉 N이 소수가 아니라고 가정할 때, N의 제곱근까지만 검사하면 합성수 N을 이루는 두 수 A, B중 작은 수(여기서는 B)까지는 검사할 수 있고, 만약 여기까지 검사했을 때 N의 약수가 나오지 않는다면?
=> B가 없는 것이므로 A*B = N 이라는 가정이 깨지게 된다. 고로 이때 N은 소수가 아니라고 볼 수 있다.
=> N의 제곱근까지만 검사하면 N이 소수인지 아닌지를 알 수 있다!
아무튼 그래서 get_prime() 정적 메소드를 선언해서 N까지의 수 중에서 소수인 값만 찾아 준다.
그 다음에는 main함수에서 해결하면 되는데,
1. if문에서 최솟값인 M이 최댓값인 N보다 큰 예외 상황 및 M, N이 0과 10000 사이가 아닌 예외 경우를 따로 처리한다.
2. 초기 sum 값은 0, min값은 int 타입이 가질 수 있는 가장 큰 값으로 설정하고, 바꿔 나간다.
** 왜 min 값을 0이 아니라 최댓값으로 설정하는지는 잘 모르겠다...!
int sum = 0;
int min = Integer.MAX_VALUE;
// Integer 클래스 안에 MAX_VALUE라는 final static 필드가 선언되어 있어서 이렇게 불러올 수 있나보다.
그리고 정적 필드 prime의 각 원소를 for문을 사용해서 하나씩 해당 값이 false인지(=소수인지) 비교하는데, 만약 false라면 sum 값에다 더해 주고, min 값으로 할당해 준다.
for(int i=M; i<=N; i++) {
if(prime[i]==false) {
sum += i;
if(min==Integer.MAX_VALUE) {
min = i;
}
}
}
이때, prime의 해당 원소의 값이 false일 때 min의 값을 i로 할당해 줘야 한다.
이렇게 조건을 주면, min값이 초기에 설정한 Integer.MAX_VALUE일 때만 min 값을 i로 할당하는데,
그러면 min값은 한 번만 할당되고 여러 번 변경되지 않는다.
마지막으로, 만약 M부터 N까지의 범위에 소수가 없었을 때, 즉 sum == 0일 때의 조건만 지정해 준다.
1. 입력을 받아야 하므로 Scanner(BufferedReader를 쓰지 않아도 시간 초과가 안 되었다.)
2. N의 약수에 해당하는 수를 저장할 ArrayList. 소인수가 몇 개일지 몰라서 배열 말고 ArrayList를 사용했다.
2. 정적 필드
9-2를 풀면서 정적 필드, 메소드를 잘 활용하면 객체 생성이나 로컬변수 처리 문제를 안 겪어도 된다는 생각에 정적 필드와 메소드를 선언했다.
public static int N;
public static ArrayList<Integer> number = new ArrayList<Integer>();
public static int i = 2;
1. N : scanner로 입력받을 N을 다른 메소드에서 다시 정의하기 귀찮아서 정적 필드로 선언.
2. ArrayList도 위에서 import만 해 주면 static field로 선언할 수 있었다...!
3. i는 while문에서 하나씩 증가시키고 해당 조건에 맞으면 소인수로 ArrayList에 추가시킬 수인데, 로컬 변수로 선언했다가 괜히 처리하기 까다로워질 것 같아서 정적 필드로 선언했다.
3. 정적 메소드 선언
자연수 N이 주어지면 해당 자연수를 소인수분해하는 isDivisor() 메소드를 선언하였다.
public static void isDivisor(int N) {
if(N==1) { // 예외1 : N=1일 때
System.out.println("");
}else if(N<0 | N>10000000) { // 예외2 : N이 범위를 벗어날 때
System.out.println("Error");
}else {
while(true) {
if(N==i) { // case 1
number.add(i);
break;
}else if(N % i != 0) { // case 2
i++;
}else if(N % i == 0) { // case 3
N = N/i;
number.add(i);
}
}
for(int k=0; k<number.size(); k++) {
System.out.println(number.get(k));
}
}
}
case 1:
소인수분해가 다 완료되고 더 이상 인수(혹은 약수)가 없으면 나눠지고 남은 수인 N과 나눌 수인 i가 서로 같아진다. 이 경우에만 while문을 break하도록 했다.
case 2:
N이 i로 나눠지지 않을 때 = i가 N의 소인수가 아닐 때.
i+1을 해서 값만 변화시켰다.
case 3:
N이 i로 나눠질 때 = i가 N의 소인수일 때.
우선 N을 i로 나눠서 N 값을 변화시키고, 해당 i값을 ArrayList에 추가했다.
i값을 증가시키지 않았으므로, 만약 N이 i로 여러 번 나눠지는 수였다면 그만큼 i가 추가로 ArrayList에 추가되도록 했다.
그리고 이렇게 만들어진 number이라는 ArrayList를 0번부터 끝까지(ArrayList의 size -1까지) 출력시켰다.
4. main 메소드
앞에서 메소드와 필드로 모든 과정을 선언해서 main메소드는 짧게 작성할 수 있었다.
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
isDivisor(N); // 3번에서 작성한 isDivisor 정적 메소드 사용
sc.close(); // scanner 꼭 닫아주기!
}
Step 9-4. 소수 구하기(1929번)
이 문제도 혼자 풀었다.
<접근>
Step 9-2의 에라토스테네스의 체의 원리를 그대로 활용했다.
다만 아까는 int타입의 sum 변수를 사용한 대신, 지금은 에라토스테네스의 체로 0부터 N까지의 소수를 구한 뒤, M부터 N까지의 소수만 출력하는 방식을 사용하였다.
import java.util.Scanner;
public class Main {
// 정적 필드 선언
public static int M;
public static int N;
public static boolean[] prime;
public static void main(String[] args) {
// 정적 메소드에 사용할 값 할당하기
Scanner sc = new Scanner(System.in);
M = sc.nextInt();
N = sc.nextInt();
prime = new boolean[(N+1)];
if(M>=1 && N>=M && N<=1000000) {
get_prime(); // 정적 메소드 사용
// 정적 메소드에서는 1~N의 소수를 구했으나, M~N의 소수만 출력
for(int i=M; i<prime.length; i++) {
if(prime[i]==false) {
System.out.println(i);
}
}
}else { // 예외처리 : M과 N의 범위가 잘못되었을 때
System.out.println("ERROR");
}
sc.close();
}
// 정적 메소드 선언
public static void get_prime() {
prime[0] = true;
prime[1] = true;
for(int i=2 ; i<=Math.sqrt(N) ; i++) {
for(int j=(i*i); j<prime.length; j += i) {
prime[j] = true;
}
}
}
}
Step 9-5(4948번)
이것도 혼자 풀었다! 사실 에라토스테네스의 체 원리만 알면 쉽게 풀 수 있는 문제인 것 같다.
<원리>
9-2, 9-4와 마찬가지로 에라토스테네스의 체 알고리즘은 정적 메소드로 선언해 놓은 상태에서 시작하면 편하다.
다만 여기는 여러 개의 test case가 주어지고, 각각 한 줄씩 주어지며, 몇 개가 주어질지 모른다는 점에서 주의해야 한다.
1. N의 입력 여러 개 받기
이때 N은 몇 개가 나올지 모르고 한 줄씩 나오므로, StringTokenizer 등을 사용하지 않아도 분리가 되었다. 나는 원래 분리된 걸 분리하려고 하느라 애를 먹었는데, 원래 스캐너는 입력을 하면 한 줄 단위로 처리하는 거였다.
다만 여러 줄을 입력하고 언제 끝날지 모른다는 점에서 for문보다는 while문이 사용하기 적합했다.
-> 그래서 main메소드 영역을 이렇게 작성했다.
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
N = Integer.parseInt(sc.nextLine().trim());
if(N==0) {
break;
}
if(N<1 | N>123456) {
System.out.println("ERROR");
break;
}else {
prime = new boolean[((2*N)+1)];
get_prime();
}
}
sc.close();
}
입력의 마지막에 0이 주어진다는 말은, 0이 입력으로 주어지면 프로그램을 종료시키라는 말과 같다.
그래서 while문을 두고 break하는 조건을 N==0일 때로 지정했다.
+ 또한 N은 sc.nextLine()으로 입력을 한 줄씩 받아서 처리하도록 했다.
+ N 뒤에는 trim() 메소드를 써서, 혹시나 공백과 섞인 문자열이 들어갔을 때 숫자만 추출할 수 있도록 했다.
2. 에라토스테네스의 체 원리를 이용 + 문제에 맞게 get_prime 정적메소드 다시 정의
우선 정적 메소드에서 사용할 정적 필드를 먼저 정의했다.
public static int N; // main 메소드에서 입력 받을 때 사용
public static boolean[] prime; // 많은 숫자들 각각이 소수인지 아닌지를 저장하기 위한 배열
public static int count = 0; // 특정 범위에서 소수의 숫자를 세기 위한 int 타입 필드
public static void get_prime() {
count = 0; // N이 새로 바뀌어서 메소드가 새로 호출될 때마다 count를 0으로 초기화한다.
prime[0] = true;
prime[1] = true;
if(N==1) { // N=1이면 i=2로 시작해서 소수를 셀 수 없으므로 예외로 처리했다.
System.out.println(1);
}else if(N==0) {
System.out.println("");
}else { // 에라토스테네스의 체 알고리즘 그대로 사용
for(int i=2 ; i<=Math.sqrt((2*N)) ; i++) {
for(int j=(i*i); j<prime.length; j += i) {
prime[j] = true;
}
}
//N보다 크고 2N보다 작은 소수들만 출력
for(int i=(N+1) ; i<=(2*N) ; i++) {
if(prime[i]==false) {
count ++; // 소수 하나 나올 때마다 count + 1
}
}
System.out.println(count);
}
}
최종 코드는 이렇다.
package ml.app2;
import java.util.Scanner;
public class Main {
public static int N;
public static boolean[] prime;
public static int count = 0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
N = Integer.parseInt(sc.nextLine().trim());
if(N==0) {
break;
}
if(N<1 | N>123456) {
System.out.println("ERROR");
break;
}else {
prime = new boolean[((2*N)+1)];
get_prime();
}
}
sc.close();
}
public static void get_prime() {
count = 0;
prime[0] = true;
prime[1] = true;
if(N==1) {
System.out.println(1);
}else if(N==0) {
System.out.println("");
}else {
for(int i=2 ; i<=Math.sqrt((2*N)) ; i++) {
for(int j=(i*i); j<prime.length; j += i) {
prime[j] = true;
}
}
for(int i=(N+1) ; i<=(2*N) ; i++) {
if(prime[i]==false) {
count ++;
}
}
System.out.println(count);
}
}
}
에라토스테네스의 체 알고리즘을 알고 있었으나, 여기서는 주어진 짝수를 소수의 합으로 나타내되, '두 소수의 차가 가장 적은 쌍으로 나타내라'는 조건이 추가적으로 붙어서 그 점이 어려웠던 것 같다. 그래도 내가 생각한 범위에서의 예제 데이터는 처리할 수 있었는데, 왜 오류가 난 것인지는 잘 모르겠다ㅠㅠ
* IndexOutOfBoundsException 예외가 특히 많이 나왔는데, 어디서 나왔는지를 모르겠다...!
일단 풀이 시작>>
<보완할 점>
블로그 글을 보면서 이해하니, 내 코드가 생각보다 많이 복잡했음을 알 수 있었다.
나는 주어진 짝수가 여러 소수의 합으로 나타낼 수 있고, 그게 총 몇 쌍일지를 모르므로 ArrayList 구조를 사용해야 한다고 생각했지만, while문 하나로도 간단하게 코드를 짤 수 있는 문제였다.
<기존 나의 풀이의 개선점>
: 사용하지 않아도 될 변수 + 자료구조가 꽤 많고, 코드가 복잡했다!
import java.io.*;
import java.util.ArrayList; // 사용할 필요가 없었다
public class Main {
public static boolean[] prime = new boolean[10001];
public static int n;
public static ArrayList<Integer> goldberg; // 사용할 필요가 없었다
public static int sub_index; // 사용할 필요가 없었다
public static void main(String[] args) throws IOException {
try { // 사용할 필요가 없었다
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int T = Integer.parseInt(br.readLine().trim());
get_prime();
for (int i = 0; i < T; i++) {
n = Integer.parseInt(br.readLine().trim());
goldberg = new ArrayList<Integer>(); // 사용할 필요가 없었다
if (n > 10000 | n < 4) {
bw.write("ERROR");
break;
} else {
get_goldberg();
}
}
bw.close();
}catch(IndexOutOfBoundsException e) {
System.out.println(e);
}
}
public static void get_prime() {
prime[0] = true;
prime[1] = true;
for (int i = 2; i <= Math.sqrt(10000); i++) {
for (int j = (i * i); j < prime.length; j += i) {
prime[j] = true;
}
}
}
public static void get_goldberg() throws IOException { // 사용할 필요가 없었음. 이 긴 걸!
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
for (int i=3; i<=(n/2); i+=2) {
if( prime[i]==false && prime[(n-i)]==false) {
goldberg.add(i);
goldberg.add((n-i));
}else if(prime[i]==false && (2*i)==n) {
goldberg.add(i);
goldberg.add(i);
}
}
int min = Integer.MAX_VALUE;
int sub_index = 0;
for (int i = 0; i < goldberg.size(); i += 2) {
int sub = Math.abs(goldberg.get(i) - goldberg.get(i + 1));
if (sub < min) {
sub_index = i;
}
}
bw.write(String.valueOf(goldberg.get(sub_index)) + " ");
bw.write(String.valueOf(goldberg.get(sub_index + 1)) + "\n");
bw.flush();
}
}
<핵심>
1. 한 수의 합이 되는 두 수의 쌍 중 가장 차가 적은 것을 선택하려면, (블로그 글 보면서 배운점)
: 짝수 2N의 경우 N+N에서부터 시작하여, (N-1)+(N+1) 이런 식으로 첫 번째 수는 하나씩 감소, 두 번째 수는 하나씩 증가시킨다. 그러면 두 수의 차가 커지면서 두 수의 합은 그대로 유지된다. 이런 식으로 while문을 전개시키고, 두 수가 모두 소수가 되는 시점에 while문을 break하면 다른 변수를 생성하지 않아도 된다.
2. 주어진 짝수의 범위는 어차피 제한되어 있으니, 처음에 크기가 10001(10000+1)인 boolean 타입의 배열을 만들고 그 범위의 소수를 다 구하는 것이 매번 새로 배열을 만들고 소수를 새로 구하는 것 보다 빠르다. (당연하지만...!)
<코드 다시 작성>
import java.io.*;
public class Main {
public static boolean[] prime = new boolean[10001];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int T = Integer.parseInt(br.readLine().trim());
get_prime();
while(T>0) {
int n = Integer.parseInt(br.readLine().trim());
int firstNum = n/2;
int secondNum = n/2;
while(true) {
if(prime[firstNum]==false && prime[secondNum]==false) {
System.out.println(firstNum + " " + secondNum);
break;
}
firstNum--;
secondNum++;
}
T--;
}
bw.close();
}
public static void get_prime() {
prime[0] = true;
prime[1] = true;
for (int i = 2; i <= Math.sqrt(10000); i++) {
for (int j = (i * i); j < prime.length; j += i) {
prime[j] = true;
}
}
}
}
