악역영애의 개발일지

Main 수정

저번 포스팅에서 만들었던 demo-main 모듈의 Main 클래스명을 변경하고 어노테이션을 달아주었다

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

해당 클래스 위치는 아래와 같다

application.yml 추가

그리고 나는 admin 과 main 모듈을 각각 실행시키고싶어서 port 설정을 추가해야하는 상황이라 application.yml을 추가해주었다

server:
  port: 8080

위치는 아래와 같이 resources 폴더를 만들고 그 안에 application.yml 을 추가하였다

Controller 생성

간단하게 테스트하기위하여 Restcontroller 로 생성하였다

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/main")
public class MainController {
    @ResponseBody
    @GetMapping("")
    public ResponseEntity index() {
        String result = "SUCCESS!!";

        return ApiResponseEntity
                .data()
                .put("result", result)
                .ok();
    }
}

위치는 아래와 같이 위치하면 된다

위 코드에 리턴타입이 ApiResponseentity 라고 되어있는데 해당 클래스는 core에 만들었다

Core 공통모듈 사용

이렇게 core 쪽에 내가 사용하고싶은 클래스를  추가하고 다른 모듈에서 자유롭게 불러서 사용가능하다

참고로 root 경로의 build.gradle 의  설정에 따라 타 모듈 -> core 연결이 가능한것이기 때문에

core -> 타 모듈 의 클래스를 import하는것은 불가능하다

spring boot 프로젝트 생성

intellij 에서 하든 spring 에서 하든.. 편한 방법으로 프로젝트를 생성한다

혹시 모르는 사람을 위하여 링크를 남겨둠

spring Initializr :  https://start.spring.io/

프로젝트 구조 수정

우선 root 경로의 src 폴더를 삭제한다

그리고 root 폴더 -> 우클릭 -> new -> Module 을 추가해준다

이때 내가 원하는 모듈갯수만큼 추가하면 된다

module name을 설정해주고

Build System 이 기본적으로 Maven 에 가있을건데 gradle로 해주자

아래 group Id 까지 설정해주면 완료

나는 총 3개의 모듈을 생성하였다

demo-main -> 사용자단 api 

demo-admin -> 관리자단 api

demo-core -> 공통 로직

전부 생성하게 되면 이런식의 구조를 확인할 수 있을것이다.

모듈 관계 설정

settings.gradle 설정

root 폴더 경로에 위치한 settings.gradle 에 모듈 설정을 추가해준다

rootProject.name = 'demo'
include 'demo-main', 'demo-admin', 'demo-core'

build.gradle 설정

모듈 별 공통 libraries 들을 설정해주고 각 모듈 별 관계성을 정리해주자

아래 내가 작업한 코드인데 눈여겨볼점은 project 설정부분이다

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.1.2'
	id 'io.spring.dependency-management' version '1.1.4'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '17'
}

configurations {
	implementation {
		extendsFrom annotationProcessor
	}
}

subprojects {
	apply plugin: 'java'
	apply plugin: 'java-library'
	apply plugin: 'org.springframework.boot'
	apply plugin: 'io.spring.dependency-management'

	configurations {
		compileOnly {
			extendsFrom annotationProcessor
		}
	}

	repositories {
		mavenCentral()
	}

	// 관리하는 모듈의 공통 dependencies
	dependencies {
		implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
		implementation 'org.springframework.boot:spring-boot-starter-web'
		compileOnly 'org.projectlombok:lombok'
		developmentOnly 'org.springframework.boot:spring-boot-devtools'
		implementation "org.mariadb.jdbc:mariadb-java-client:2.1.2"
		implementation 'org.springframework.boot:spring-boot-starter-validation'
		annotationProcessor 'org.projectlombok:lombok'
		testImplementation 'org.springframework.boot:spring-boot-starter-test'

	}

	test {
		useJUnitPlatform()
	}
}

project(':demo-main') {
	jar {
		archivesBaseName = 'demo-main'
	}
	dependencies {
		//컴파일 시 core 로드
		compileOnly project(':demo-core')
	}
}

project(':demo-admin') {
	jar {
		archivesBaseName = 'demo-admin'
	}
	dependencies {
		//컴파일 시 core 로드
		compileOnly project(':demo-core')
	}
}

project(':demo-core') {
	//bootJar로 패키징 할 필요 없음 Main() 메서드 필요없기때문
	bootJar { enabled = false }
	jar { enabled = true }
}

clean {
	delete file('src/main/generated')
}

configurations 에 compileOnly가 꼭 있어야 멀티모듈 dependencies 의 compileOnly 설정을 사용할 수 있다

subprojects {
	apply plugin: 'java'
	apply plugin: 'java-library'
	apply plugin: 'org.springframework.boot'
	apply plugin: 'io.spring.dependency-management'

	configurations {
		compileOnly {
			extendsFrom annotationProcessor
		}
	}
}

개별 모듈 build.gradle 설정

공통로직 모듈을 제외한 다른 모듈의 경우 아래와 같이 작성하면 된다

dependencies 에 core 모듈을 implementation 에 추가한다

plugins {
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation project(':demo-core')

    testImplementation platform('org.junit:junit-bom:5.9.1')
    testImplementation 'org.junit.jupiter:junit-jupiter'
}

test {
    useJUnitPlatform()
}

core 모듈은 build.gradle 없애놓고 저장!

여기까지하면 모듈간 관계설정 세팅이 완료되었다.

다음 포스팅에서 실제로 활용해보자

@Component

개발자가 직접 작성한 class 전체를 Spring Bean 으로 등록

하위로 @Controller, @Service, @Repository 어노테이션이 있다

@Component
public class MyComponent {
// 클래스 내용
}

@Configuration

스프링에게 해당 클래스가 Bean 구성 Class 임을 알리는 어노테이션이다

즉, Bean 등록용 class로 사용할 수 있고 일반 메소드 또한 만들수있지만 주로 Bean 을 보조하는 역할을 한다

@Bean

외부 라이브러리 등 반환되는 객체를 Bean 으로 등록한다

쉽게말하면 @Bean 어노테이션을 사용하면 new ~ 로  생성해서 import 하지않아도 된다

스프링 간 객체가 의존관계를 관리하도록 하는 것에 가장 큰 목적이다

new 로 생성하면 생성자를 그득그득 붙여서 변경가능성이 있는데, Bean 을 사용하면 변경이 안되겠지

@Configuration //여기는 @Bean 등록 전용 class!
public class TestConfig {

    @Bean
    public MyBean myBean() {
      return new MyBean();
    }
    
    @Bean(name="myMethod")
    public MyBean myBean() {
      return new MyBean();
    }
    
    // @Bean 어노테이션이 없는 메소드
    public SomeConfiguration someConfiguration() {
      // 구성 정보 반환
      return new SomeConfiguration();
    }
}

@RequestParam

Client 요청 URI 에서 전달되는 파라미터를 메소드 인자와 매칭
휴먼에러 방지를 위해 name 속성을 같이 쓰는게 좋음!

@GetMapping(value = "/main")
public String index(@RequestParam String nickname, 
                    @RequestParam(name="age") String age) {
        return "";
}

@RequestBody

Client 에서 서버로 요청 시 복수의 parameter 를 전달할 때 사용
json 기반의 Http Body 를 컨트롤러에서 자바객체로 변환 (Client 에서 보낸 json body를 객체형태로 매핑)

Client 에서 보내고싶은 데이터가 여러개 있을 경우 주로 사용된다.

아래와 같이 param 안에 데이터를 넣고

var param = {
      title : "1111",
      content : "hello",
      userName : "admin"
  }

해당 어노테이션을 넣으면 컨트롤러에서 해당 데이터를 객체로 자동 매핑한다

이때 유의할 점은 PostDto 에서 선언된 변수명과 param 에 들어있는 변수명이 완벽하게 같아야 한다

public class PostDto {
    private String title;
    private String content;
    private String userName;
}

/////
@PostMapping(value = "/index-request")
public String indexRequest(@RequestBody PostDto postDto) {
        return "/user/index";
}

만약 변수명이 같지 않은 경우 별도로 에러는 발생하지 않으며, 해당 변수만 해당 객체에 매핑되지 않는다

@ResponseBody

Client 로 data 반환 시 사용하며 객체 data 를 json 으로 바꿔 반환한다

해당 어노테이션의 위치는 return type 객체 앞에 써도 되지만, 나는 개인적으로 방법 2를 선호한다

// 방법 1
@GetMapping(value = "/index-rest")
public @ResponseBody ResponseEntity indexRest() {
    //json type으로 반환하기 위하여 @ResponseBody 어노테이션이 필요함
    return ApiResponseEntity
            .builder()
            .ok();
}

// 방법 2
@ResponseBody
@GetMapping(value = "/index-rest2")
public ResponseEntity indexRest2() {
    //@ResponseBody 어노테이션은 return type 앞에 위치한것보다 현재의 형태가 제일 깔끔해 보인다
    return ApiResponseEntity
            .builder()
            .ok();
}

위와 같은 코드로 컨트롤러에서 데이터를 보내면 Client 에서는 아래와 같은 형태로 받게된다

var response = {
        "data": {
            "loginId": "admin"
        },
        "status": 200
  }

자세한 코드는 아래 깃헙 주소에서 basic폴더의 README 참고

https://github.com/Daseul727/BackEnd-Skill-Up.git

@Controller

- 일반적인 Spring MVC 컨트롤러

- 주로 view 를 반환하기 위하여 사용됨

View 반환

Return Type 은 String 으로 설정한다

return 에 들어오는 경로의 화면을 View Resolver 를 통해 반환한다

@Controller
@RequestMapping("/main")
public class MainController {

    @GetMapping(value = "/index")
    public String index(){
        return "/user/index";
    }
}

요청 처리 과정

1. Client 에서 URI 형식으로 요청

2. DispatcherServlet 에서 요청을 처리할 대상 조회

3. HandlerAdapter 를 통해 요청을 Controller 로 위임

4. Controller 에서 서비스로직 실행 후 view 반환

5. DispatcherServlet 은 ViewResolver 를 통해 View 를 찾아 반환

View + Data 반환

Return Type 은 String 으로 설정한다

model 에 들어있는 data를 view와 함께 반환한다

@Controller
@RequestMapping("/main")
public class MainController {

    @GetMapping(value = "/index-model")
    public String indexModel(Model model){
        model.addAttribute("user", "");
        return "/user/index";
    }

    @GetMapping(value = "/index-param")
    public String indexParam(Model model, @RequestParam("userName") String userName){
        model.addAttribute("user", userName);
        return "/user/index";
    }

}

요청 처리 과정

1. Client 에서 URI 형식으로 요청

2. DispatcherServlet 에서 요청을 처리할 대상 조회

3. HandlerAdapter 를 통해 요청을 Controller 로 위임

4. Controller 에서 서비스로직 실행 후 view 와 Data 를 함께 반환

Data 반환

페이지 이동없이 데이터만 Json 객체로 반환한다

@Controller
@RequestMapping("/main")
public class MainController {

    @GetMapping(value = "/index-rest")
    public @ResponseBody ResponseEntity indexRest() {
        //json type으로 반환하기 위하여 @ResponseBody 어노테이션이 필요함
        return ApiResponseEntity
                .builder()
                .ok();
    }
}

하지만 이런 경우 @Controller 를 쓰기보단 아래의 @RestController 어노테이션을 사용한다

@RestController

- RestFul 웹서비스의 컨트롤러

- @Controller + @RequestBody 의 기능을 한다

- ResponseEntity 형식으로 return

   ㄴ HttpStatus, data 를 Json 객체로 반환

Data 반환

페이지이동 없이 Data 만 Json 객체로 반환한다

아래 코드의 경

@RestController
@RequestMapping("/api/main")
public class MainRestController {

    @ResponseBody
    @GetMapping("")
    public ResponseEntity index() {
        return ResponseEntity
                .ok();
    }
}

요청 처리 과정

1. Client 에서 URI 형식으로 요청

2. DispatcherServlet 이 요청을 처리

3. HandlerAdapter 를 통해 요청을 Controller로 위임

4. Controller 에서 서비스로직 실행 후 객체 반환

5. 반환 시 Json 으로 Serialize 되어 Client 로 반환

viewResolver 필요한 프로젝트는 @Controller

api기능만 사용할 프로젝트는 @RestController 사용하면 된다!