saltfactory's blog

엣지있게 설명한 Ionic 수정증보판 작업을 진행 합니다.

Sun, 31 Jan 2016 00:00:00 +0000

새롭게 바뀌는 내용

엣지있게 설명한 Ionic 수정증보판에서는 전편에 수록된 v1.0 기반의 소스코드를 가장 최신 SDK가 될 v1.2.4 기반으로 변경할 예정입니다. 또한 v2.0.0 기반 개발 방법을 추가할 예정입니다. 그리고 전편이 출판되고 난 이후 가장 많은 질문을 받았던 Trenditicy 예제 소스코드를 컴퓨터 받아서 실습하는 방법을 아주 상세하고 자세하게 설명하여 추가할 예정입니다. 또한 최신 Trendicity 소소코드는 Ionic v1.0.0 기준으로 만들어져 있는데, 엣지있게 설명한 Ionic 수정증보판의 내용에 맞게 Ionic v1.2.4 기반과 모든 라이브러리를 최신으로 업데이트하여 역자의 소스코드 저장소에서 Trendicity를 배포할 예정입니다. 새롭게 추가 예정될 내용은 다음과 같습니다.

최신 Ionic v1.2.4 기반 Trendicity 예제
최신 Ionic SDK (v2.0.0) 기반 개발 방법
Windows기반 PC 에서 Ionic 프로젝트를 개발하는 방법 추가
Ionic Lab 사용 방법 추가
Ionic io 사용 방법 추가
- Ionic Package
- Ionic Push
- Ionic Update
ngCordova 사용 방법 추가
- Push Notification
- Social Sharing
- Touch ID
- In App Browser

독자(개발자) 의견

이번 수정증보판에서 추가되면 좋을 것 같은 내용을 댓글로 달아주시면 참고해서 개정판에 넣도록 하겠습니다. 참고로 블로그에 유입되는 가장 많은 토픽이 Push와 Windows 환경에서 개발하는 방법이였습니다. 이 두가지 내용은 꼭 추가하도록 하겠습니다.

역자의 말

책을 판매하는 목적이 아니라 국내에서도 Ionic을 사용하여 하이브리드 앱을 개발하는 방법이 널리 보급되길 바라는 마음으로 처음부터 준비하고 있습니다. 책에 대한 홍보를 하지 않는 이유도 이와 같은 마음 입니다. 저와 마음을 같이하시려는 커뮤니티와 모든 연구자, 개발자 그리고 학생들에게 이 책의 내용이 조금이라도 도움이 되길 바라는 마음으로 준비하겠습니다. 댓글로 달아주시는 추가되기 바라는 내용에 관해서, 만약 이번 수정증보판에 추가하지 못한 내용은 충분히 연구해서 다음 개정판에 꼭 추가할 수 있도록 힘쓰겠습니다.

그리고 역서 말고 저서를 희망하시는 메일을 주시는 분들이 많으신데, 이번에 출판사와 이야기하면서 수정증보판을 진행하기로 하였습니다. 개정판 이후, 국내 서비스에 필요한 UI, 라이브러리, 플러그인을 가지고 국내 서비스 앱 개발에 가장 적합한 내용을 알기 쉽게 풀어서 새로운 모습으로 저서를 준비할 수 있도록 하겠습니다.

책과 블로그를 통해 부족한 내용을 참고하시면서 감사의 메일과 관심을 가지고 여러가지 의견을 주시는 모든 독자와 함께 개발하고 연구하는 연구자분들께 고개숙여 감사드립니다. 대한민국에서 컴퓨터공학을 전공하는 연구원으로 여러분들과 함께 열심히 연구하며 지식을 나누는데 힘쓰도록 하겠습니다. 바쁜 일정과 연구 본업 때문에 질문에 대한 답변이 늦더라도 깊은 양해 당부드립니다. 더욱 열심히 연구하는 연구자의 길을 걷겠습니다. 감사합니다.

엣지있게 설명한 ionic 책 소개

http://blog.saltfactory.net/books/ionic-edge/

출판사 요청으로 엣지있게 설명한 Ionic (2nd) 개정판에서 => 엣지있게 설명한 수정증보판으로 표기 변경되었습니다.

이번에 새롭게 인쇄를 준비하는 책은 원서 Ionic Edge 2nd edition을 번역한 것이 아니라(아직 2nd edition이 나오지 않음) 초판의 내용을 수정 추가한 수정증보판입니다.

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Ionic 하이브리드 앱 (PhoneGap, Cordova) iOS 3D Touch 적용하기

Mon, 04 Jan 2016 00:00:00 +0000

서론

iPhone 6s의 가장 큰 특징 중에 하나가 3D Touch 이다. 새로운 SDK가 발표되면 새로운 디바이스에 설치되는 앱에는 이런 기능을 추가하고 싶어질 것이다. 3D Touch 는 마치 단축키메뉴 같은 역활을 한다. 앱을 터치하여 앱을 구동시키지 않고, 앱이 실행되고 있지 않아도 특정 메뉴에 접근하거나 특정 작업을 바로 할 수 있는 기능을 구현할 수 있다. 만약 Cordova 기반의 하이브리드 앱을 개발하고 있다면 iPhone 6s 디바이스에 어떻게 3D Touch 를 적용할 수 있을지 관심을 가져볼 수 있다. Cordova 개발자들 사이에서도 3D Touch를 사용하여 적용할 수 있는 방법에 대해서 연구하고 여러가지 플러그인을 내어 놓고 있다. 이 글에서는 Cordova 기반 Ionic 프레임워크로 하이브리드 앱에서 cordova-plugin-3dtouch Cordova 플러그인을 사용하여 간단하게 iPhone 6s 에서 3D Touch를 적용하는 방법을 소개한다.

Ionic 프로젝트 생성

Ionic은 기본적으로 Cordova 기반으로 만들어진 하이브리드 앱 개발 프레이워크이다. Corodva의 모든 명령을 사용할 수 있을 뿐만 아니다 AngularJS와 멋진 템플릿을 가지고 빠르게 앱을 개발할 수 있다. Ionic을 처음 시작한다면 http://blog.saltfactory.net/tags/ionic/ 에서 글을 참조하면 Ionic에 관해서 이해할 수 있을 것이다.

테스트를 위해서 ionic cli를 사용하여 프로젝트를 생성한다. 슬라이드 메뉴를 가지는 앱을 만들기 위해서 sidemenu 타입으로 프로젝트를 생성한다.

ionic start myApp sidemenu

ionic 으로 앱을 만들면 기본적으로 iOS 플랫폼을 추가하여 만들어진다. ionic은 cordova의 명령어를 그대로 사용할 수 있다. ionic 이나 cordova를 사용하여 설치된 플랫폼을 확인해보자.

ionic platform list

cordova platform list

앱을 빌드하고 실행시켜보자.

ionic run ios --device

다음과 같은 화면이 디바이스에서 나타날 것이다.

cordova-plugin-3dtouch

Cordova 기반의 프레임워크의 장점은 유용한 Cordova 플러그인을 사용하여 빠르게 개발할 수 있는 것이다. 3D Touch에 관한 플러그인은 이미 몇가지 개발되어 리파지토리에서 바로 설치를 할 수 있다. 다음 명령어를 실행하여 3D touch 플러그인을 설치한다. cordova 명령어도 그대로 사용할 수 있다.

ionic plugin add cordova-plugin-3dtouch

ionic 명령어로 plugin을 설치하면 package.json에 어떤 플러그인을 설치했는지 저장을 하게 된다.

{
  "name": "myapp",
  "version": "1.1.1",
  "description": "myApp: An Ionic project",
  "dependencies": {
    "gulp": "^3.5.6",
    "gulp-sass": "^2.0.4",
    "gulp-concat": "^2.2.0",
    "gulp-minify-css": "^0.3.0",
    "gulp-rename": "^1.2.0"
  },
  "devDependencies": {
    "bower": "^1.3.3",
    "gulp-util": "^2.2.14",
    "shelljs": "^0.3.0"
  },
  "cordovaPlugins": [
    "cordova-plugin-device",
    "cordova-plugin-console",
    "cordova-plugin-whitelist",
    "cordova-plugin-splashscreen",
    "cordova-plugin-statusbar",
    "ionic-plugin-keyboard",
    "cordova-plugin-3dtouch"
  ],
  "cordovaPlatforms": [
    "ios"
  ]
}

명령어로 확인하기 위해서는 다음 명령어로 확인할 수 있다.

ionic plugin list

또는

cordova plugin list

우리는 Cordova Plugin 설치로 어렵지 않게 iPhone 6s 에서 사용할 수 있는 3D Touch 기능을 JavaScript로 구현할 수 있게 되었다.

3D Touch 홈스크린 3D Touch 정의하기

플러그인 설치가 끝다면 3D Touch 설정을 하기 위해서 $ionicPlatform.ready 함수 안에 다음을 정의한다. 만약 Ionic을 사용하지 않고 Cordova 프로젝트에서 사용한다면 document.addEventListener("deviceready", yourCallbackFunction, false); 에서 deviceready의 이벤트가 발생할 때 사용되는 콜백함수 안에 정의한다. 하이브리드 앱은 WebKit 브라우저가 오픈된 이후에 JavaScript 코드가 동작하기 때문이다. 3D Touch 플러그인에서 3D Touch가 홈스크린에 나타나는 아이콘을 정의하기 위해서 ThreeDeeTouch.configureQuickActions() 메소드를 사용한다. 이 때 3D Touch Action을 정의하는 프포퍼티로는 다음과 같다.

type : 3D Touch 이벤트의 타입을 정의해서 각 이벤트를 구분할 때 사용
title : 3D Touch 할 경우 나타나는 액션들의 타이틀
subtitle : 3D Touch 할 경우 나타나는 액션들의 서브타이틀 (생략가능)
iconType : 3D Touch 할 경우 나타나는 액션의 아이콘

3D Touch의 기본 아이콘은 UIApplicationShortcutIconType에서 참조할 수 있다.

… 생략…
angular.module('starter', ['ionic', 'starter.controllers'])

.run(function($ionicPlatform) {
  $ionicPlatform.ready(function() {
    // Hide the accessory bar by default (remove this to show the accessory bar above the keyboard
    // for form inputs)
    if (window.cordova && window.cordova.plugins.Keyboard) {
      cordova.plugins.Keyboard.hideKeyboardAccessoryBar(true);
      cordova.plugins.Keyboard.disableScroll(true);

    }
    if (window.StatusBar) {
      // org.apache.cordova.statusbar required
      StatusBar.styleDefault();
    }


       ThreeDeeTouch.configureQuickActions([
        {
          type: ‘onCompose’, 
          title: '글쓰기', 
          iconType: 'Compose'
        },
        {
          type: ‘onShare',
          title: '공유',
          iconType: 'Share'
        },
        {
          type: ‘onSearch',
          title: '검색',
          iconType: 'Search'
        }
      ]);

  });
})

.config(function($stateProvider, $urlRouterProvider) {
…생략…

이제 디비이스에 코드를 빌드해서 실행해보자. 이 때 주의해야할 점은 3D Touch 테스트는 Simulator에서 가능하지 않다는 것이다. 반드시 iPhone 6s/6s plus 에 실행해서 테스트를 해야 3D Touch가 실행되는 것을 확인할 수 있다.

ionic prepare ios

ionic build ios

ionic run ios --device

디바이스에 앱이 실행되면 홈스크린에 설치된 아이콘을 꾹 눌러서 3D Touch 가 적용되었는지 살펴보자.

3D Touch 이벤트 처리하는 핸들러 정의하기

위에서 3D Touch 이벤트를 정의했다면 각 이벤트가 처리하는 핸들러를 정의해야한다. 위 3D Touch 정의 중에 type 이라는 것이 이벤트의 타입을 나타내는 ID라고 생각하면 된다. 즉 3D Touch로 Compose를 눌렀으면 onCompose라는 이벤트 타입이 발생하는 것이다. 3D Touch의 이벤트는 ThreeDeeTouch.onHomeIconPressed() 함수로 정의할 수 있다. 이 것 또한 위에서 3D Touch의 Quick Actions을 정의한 것과 동일하게 $ionicPlatform.ready() 안에서 정의한다. cordova의 경우 deviceready 이벤트에 해당한다. 간단한 테스트를 위해서 3D Touch에서 Search 액션을 선택하면 앱이 열리면서 검색화면이 열리게 하는 것이다. 화면의 페이지를 전환하기 위해서 ionic의 $state.go()를 사용한다.

...생략...
angular.module('starter', ['ionic', 'starter.controllers'])

.run(function($ionicPlatform, $state) {
  $ionicPlatform.ready(function() {
    // Hide the accessory bar by default (remove this to show the accessory bar above the keyboard
    // for form inputs)
    if (window.cordova && window.cordova.plugins.Keyboard) {
      cordova.plugins.Keyboard.hideKeyboardAccessoryBar(true);
      cordova.plugins.Keyboard.disableScroll(true);

    }
    if (window.StatusBar) {
      // org.apache.cordova.statusbar required
      StatusBar.styleDefault();
    }


       ThreeDeeTouch.configureQuickActions([
        {
          type: 'onWrite', 
          title: '글쓰기', 
          iconType: 'Compose'
        },
        {
          type: 'onShare',
          title: '공유',
          iconType: 'Share'
        },
        {
          type: 'onSearch',
          title: '검색',
          iconType: 'Search'
        }
      ]);

      ThreeDeeTouch.onHomeIconPressed = function (payload) {
      console.log("Icon pressed. Type: " + payload.type + ". Title: " + payload.title + ".");
        if (payload.type == 'onSearch') {
          $state.go('app.search');
        } else if (payload.type == 'onShare') {
          // open share page
        } else {
          // open compose page
        }
      }

  });
})

.config(function($stateProvider, $urlRouterProvider) {
...생략 ...

이벤트 핸들러를 정의하고 다시 디바이스에 빌드해서 실행해보자

ionic prepare ios

ionic build ios

ionic run ios --device

3D Touch를 시작해서 Search 액션을 선택하면 검색 화면이 열리게 될 것이다.

결론

iPhone 6s 에서 3D Touch는 꽤 유용하다. 앱을 실행시키지 않고 홈 스크린에서 빠르게 자주 사용하는 메뉴로 들어갈 수 있다. iOS에서 3D Touch 기능을 네이티브 코드로 개발을 할 수 있는데 Corodva 하이브리드 앱을 개발하고 있다면 네이티브 코드로 Corodva 플러그인을 만들어서 사용해야한다. Cordova는 이미 꽤 방대한 에코시스템이 만들어져 있다. 여러 커뮤니터들은 자신의 플러그인을 개발하여 오픈소스로 플러그인을 공유하고 있고 있다. cordova-plugin-3dtouch도 이러한 플러그인 중에 하나로 iOS 네이티브 코드를 직접 만들지 않고 이 플러그인을 사용하여 3D Touch 기능을 JavaScript로 간단하게 구현할 수 있을 것이다.

참고

https://github.com/EddyVerbruggen/cordova-plugin-3dtouch
https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIApplicationShortcutIcon_Class/#//apple_ref/c/tdef/UIApplicationShortcutIconType
https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/iPhoneOSKeys.html

소스코드

https://github.com/saltfactory/ionic-tutorial/tree/3d-touch

ionic 책

http://blog.saltfactory.net/books/ionic-edge/

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

PhoneGap(Cordova) 안드로이드 앱에서 외부 링크 새로운 브라우저 앱으로 열기

Wed, 30 Dec 2015 00:00:00 +0000

서론

PhoneGap(Cordova)으로 만든 하이브리드 앱은 WebView 안에서 동작하기 때문에 앱 내의 링크가 아닌 외부 링크를 사용하면 앱이 사라지고 외부링크 페이지가 열리게 되는 문제가 있다. 이 문제를 간단하게 해결하기 위해 외부 링크를 클릭하면 외부링크 페이지가 앱의 WebView에서 열리지 않고 브라우저 앱을 통해 열릴 수 있는 방법을 앞에서 PhoneGap(Cordova) 외부 링크(a link) 새창으로 열기 라는 글로 소개를 한적이 있다. 이 글에서 iOS와 Android의 두가지 경우를 소개하였는데 Android 에서는 최신 Cordova 업데이트 이 후 이 글의 내용을 더이상 사용하지 못한다. appView.setWebViewClient() 메소드를 더이상 사용할 수 없기 때문이다. 이 글에서는 최신 Cordova 버전에서 안드로이드 앱을 만들 때 안드로이드의 shouldOverrideUrlLoading를 사용하여 외부링크를 새로운 브라우저에 열리게 하는 방법을 소개한다.

Custom WebViewClient

가장 먼저 작업할 일은 shouldOverrideUrlLoading을 override 시킨 WebViewClient를 만드는 것이다. 우리는 외부 링크를 클릭하면 새로운 브라우저를 열어서 링크를 열리게 할 것이다. 만약 이 작업을 하지 않고 Cordova 기반 하이브리드 앱 안에서 링크를 열면 앱 자체가 사라지고 링크의 페이지가 앱 안에 열리게 되는 끔찍한 일이 벌어진다. 다시 말하지만 Cordova 기반 하이브리드 앱은 HTML을 사용하여 뷰가 만들어지기 때문이다. HTML 뷰의 앱 안에서 링크를 클릭하면 새창을 띄워야 하는데 앱 안의 WebView에서는 새 창을 띄울수가 없다. 그래서 필요한 것이 바로 shouldOverrideUrlLoading이 호출될 때 외부 링크인 경우에 새로운 브라우저 앱으로 링크를 열도록 하는 것이다.

class MyWebViewClient extends SystemWebViewClient {

    public MyWebViewClient(SystemWebViewEngine systemWebViewEngine) {
        super(systemWebViewEngine);
    }

    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        Uri uri = Uri.parse(url);

        if (uri.getScheme().equals("http") || uri.getScheme().equals("https")) {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.setData(uri);
            view.getContext().startActivity(intent);
            return true;
        } else {
            return super.shouldOverrideUrlLoading(view, url);
        }
    }
}

MainActivity

Cordova 기반으로 하이브리드 앱을 만든다면 Android Plaform을 추가할 때 자동으로 CordovaActivity를 상속받은 MainActivity를 만들어준다. MainActivity는 사용자가 임의 이름으로 변경할 수 있는데 이것을 AndroidManifest.xml에 설정을 해주면 된다. 우리는 이 파일에서 WebView를 접근해 WebView에 우리가 정의한 WebViewClient를 설정하여 외부 링크를 클릭하면 새로운 브라우저가 열리게 할 것이다.

우선 이전 코드를 살펴보자. 이전 코드에서는 다음과 같이 appView를 사용하여 WebView 접근이 가능했고, WebView에 shouldOverrideUrlLoading을 정의하여 새로운 브라우저를 열리게 할 수 있었다.

public class MainActivity extends CordovaActivity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        // Set by <content src="index.html" /> in config.xml

        super.init();

        this.appView.setWebViewClient(new CordovaWebViewClient(this, this.appView) {
@Override
            public boolean shouldOverrideUrlLoading(WebView view, String url) {

                Uri uri = Uri.parse(url);

                if (uri.getScheme().equals("http") || uri.getScheme().equals("https")){
                    Intent intent = new Intent(Intent.ACTION_VIEW);
                    intent.setData(uri);
                    startActivity(intent);
                    return true;
                } else {
                    return super.shouldOverrideUrlLoading(view, url);
                }
            }

        });


        super.loadUrl(Config.getStartUrl());
        //super.loadUrl("file:///android_asset/www/index.html");
    }

}

하지만 Cordova 5.0.0* 이상부터는 이전의 **appView를 사용하는 방법으로 WebView에 접근할 수 없고 다음과 같이 SystemWebViewEngine을 사용하여 WebView에 접근할 수 있다.

public class MainActivity extends CordovaActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Set by <content src="index.html" /> in config.xml
//        loadUrl(launchUrl);

        super.init();

        SystemWebViewEngine systemWebViewEngine = (SystemWebViewEngine) appView.getEngine();
        WebViewClient myWebViewClient = new MyWebViewClient(systemWebViewEngine);

        WebView webView = (WebView) systemWebViewEngine.getView();
        webView.setWebViewClient(myWebViewClient);

        super.loadUrl(launchUrl);

    }
}

결론

Cordova 앱에서 외부 링크를 브라우저로 열기 위한 방법은 기존의 PhoneGap(Cordova) 외부 링크(a link) 새창으로 열기 글과 동일하게 shouldOverrideUrlLoading를 정의한 WebViewClient를 만들어서 appView 의 WebView에 새롭게 정의한 WebViewClient를 사용하도록 하는 방법은 동일하다. 하지만 Cordova 5.0.0 이상부터는 기존의 appView에서 웹뷰를 전근하는 메소드를 사용할 수 없기 때문에 SystemWebViewEngine을 사용하여 웹뷰에 접근하는 방법을 사용해야한다. SDK는 보안의 문제와 성능의 문제로 이전에 사용할 수 있었던 메소드들이 Deprecated 되거나 사라지는 경우가 많다. SDK 버전이 올라갈 때 기존의 코드에 어떤 영향을 미치지는 확인하고 업데이트를 하거나 최신 SDK를 적용할 때 해결해야하는 문제를 빨리 파악하고 대처하는 것이 필요하다.

참고

http://stackoverflow.com/questions/29992669/accessing-appview-from-cordova-5-0-0
http://blog.saltfactory.net/hybridapp/solve-external-link-tag-in-phonegap.html

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Spring에서 RestTemplate을 사용하여 웹(API 서버)에 Multipart/Form-data (첨부파일 포함) 전송하기

Thu, 26 Nov 2015 00:00:00 +0000

서론

Spring에서 RestTemplate을 사용하면 간단하게 REST 서비스 요청을 쉽게 처리할 수 있다. RestTemplate 모듈이 Spring 에 포함되고 난 이후 Apache HttpClient 등 다른 외부 라이브러리를 사용하지 않고 Spring에서 제공하는 것 만으로도 훨씬 효율적으로 개발할 수 있다. RestTemplate는 이름에서도 느껴지듯 REST 요청을 하는데 최적화 되어 있는 Http Request Template이라고 생각하면된다. JSON 형태의API를 요청하여 객체로 매핑하거나, 객체를 서버로 전송할 때 객체를 쉽게 JSON 형태로 전송할 수 있는 기능을 가지고 있다. 만약 Spring 컴포넌트 안에 Http Request 요청을 하는데 JSON 타입의 API 요청이 아닐 때는 RestTemplate을 사용할 수 없을까? 만약 그렇다고하면 Spring은 너무 제한적이고 무책임하게 RestTemplate을 설계하였다고 볼 수 있다. 하지만 Spring의 기본 철학은 AOP 이다. 이런 철학은 컴폰넌트간의 의존성이 유연하고 컴포넌트간의 상호작용과 확장성이 자유로운 구조로 모듈을 설계되게 만들었다. RestTemplate 역시 단순히 JSON 형태의 데이터를 처리하는 단순한 모듈이 아니라 일반 Http Request 요청을 처리할 수 있게 설계되었을 뿐만 아니라다 사용자가 직접 기능을 수정하거 확장하여 사용할 수 있게 설계되어 있다. 이렇게 유연한 RestTemplate을 사용하여 REST 서비스가 아닌 경우의 Http Request 요청과 Multipart/Form-data를 처리하는 방법고 MultiValueMapConveter를 사용하여 POJO 객체를 바로 POST 전송할 수 있는 방법을 소개한다.

테스트를 위한 프로젝트와 컨트롤러 생성

우리는 앞에서 Spring에서 REST 서비스를 위한 컨트롤러에 FORM과 파일업로드(multipart/form-data)를 함께 사용하기와 컨트롤러 테스트하기 글에서 Spring Boot를 사용하여 Spring에서 Thymeleaf를 사용하여 Form 입력 페이지를 만들고 @ModelAttribute를 사용하여 Multipart/Form-data로 파일 업로드를 포함하여 Submit을 할 때 처리하는 컨트롤러를 만들어보았다. 그리고 Spring에서 RestTemplate을 사용하여 REST 기반 서비스 요청과 테스트하기 글에서 RestTemplate 를 사용하여 REST 서비스를 위한 컨트롤러로 HTTP GET/POST/PUT/PATCH/DELETe 요청을 보내는 것을 만들어보았다. spring-boot-resttemplate 소스코드를 다운받아서 테스트를 진행하거나 직접 Form 처리를 하기위한 컨트롤러를 직접 만들어서 진행하여도 좋다.

RestTemplate을 사용하여 GET 요청하여 HTML 문서 확인하기

우리는 앞의 글에서 RestTemplate을 사용하여 JSON 타입의 API 형태의 REST 서비를 요청하는 예제를 다루었다. 만약 GET으로 요청하면 HTML을 보여주는 컨트롤러를 만들어보자. 우리는 새로운 Article의 입력을 위해 Form을 가지고 있는 뷰를 Thymeleaf로 만들었다. 다운로드 받은 소스코드에서 Spring Boot 서버를 실행하고 http://localhost:8080/articles/new 를 요청하면 다음과 같이 입력화면이 브라우저에 나타난다.

우리는 이 화면을 위한 컨트롤르 메소드를 다음과 같이 ArticlesController 안에 newArticle() 이라는 이름으로 다음과 같이 만들었었다.

@RequestMapping(value = "/articles/new", method = RequestMethod.GET)
public String newArticle(Model model){
    Article article = new Article();
    model.addAttribute("article", article);
    return "articles/new";
}

그리고 이 메소드를 테스트하기 위해 MockMvc로 다음과 같이 테스트를 하였다. get() 요청으로 받은 HTML 뷰를 xpath()를 가지고 테스트하는 코드이다.

@Test
public void testNewArticle() throws Exception {
  MvcResult result = mockMvc.perform(get("/articles/new"))
          .andExpect(status().isOk())
          .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
          .andExpect(xpath("//input[@name='title']").exists())
          .andReturn();

  assertThat(result.getResponse().getContentAsString(), containsString("New Article"));

  logger.info(result.getResponse().getContentAsString());
}

위 테스트를 RestTemplate으로 구현하면 다음과 같다. RestTemplate.exchange()를 사용하여 ResponseEntity를 받은 후에 Header에서 Content-Type을 확인하고, XPath를 사용하여 HTML 노드가 있는지 확인하는 방법은 동일하다. 다만 MockMvc 테스트를 할 때 테스트 프레임워크 자체에 xpath() 메소드가 있지만, Hamcrest의 Matchers.assertThat()을 사용할 때의 hasXPath()는 XML 의 Document 개체에서만 테스트를 할 수 있다. 그래서 assertThat() 테스트 라이브러리에서 XHTML을 사용하여 XPath를 사용할 수 있는 라이브러리 XhtmlMatchers.hasXPath()를 사용하여 HTML 문서를 비교하면 된다.

테스트를 진행할 때 새로운 라이브러리가 필요하기 때문에 프로젝트 안의 build.gradle 파일을 열어서 dependencies에 다음 내용을 추가한다.

buildscript {
    ext {
        springBootVersion = '1.3.0.RELEASE'
    }
    repositories {
        mavenCentral()
        maven { url 'http://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
    baseName = 'spring-boot-demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    compile('org.springframework.boot:spring-boot-starter-web')
    testCompile('org.springframework.boot:spring-boot-starter-test')

    compile('org.springframework.boot:spring-boot-configuration-processor')
    compile('org.apache.httpcomponents:httpclient:4.5.1')

    testCompile('com.jcabi:jcabi-matchers:1.3')
    testCompile('com.jcabi:jcabi-xml:0.16.1')
}

compileJava.dependsOn(processResources)

configure(allprojects) {
    apply plugin: 'propdeps'
    apply plugin: 'propdeps-maven'
    apply plugin: 'propdeps-idea'
    apply plugin: 'propdeps-eclipse'
}


eclipse {
    classpath {
         containers.remove('org.eclipse.jdt.launching.JRE_CONTAINER')
         containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

gradle을 사용하여 자동으로 새로 추가한 라이브러가 다운받아지면서 테스트는 성공적으로 진행이 될 것이다. 테스트를 해보자.

@Test
public void testNewArticle() throws Exception {
  URI uri = URI.create(baseUrl + "/articles/new");

  HttpHeaders headers = new HttpHeaders();
  headers.setContentType(MediaType.TEXT_HTML);
  MediaType mediaType = new MediaType("text", "html", Charset.forName("UTF-8"));
  HttpEntity<String> entity = new HttpEntity<>(headers);


//        String responseString = restTemplate.getForObject(uri), String.class);
  ResponseEntity<String> responseEntity = restTemplate.exchange(uri, HttpMethod.GET, entity, String.class);

  assertThat(responseEntity.getStatusCode(), is(equalTo(HttpStatus.OK)));
  assertThat(responseEntity.getHeaders().getContentType(), is(equalTo(mediaType)));
  assertThat(responseEntity.getBody(), hasXPath("//input[@name='title']"));

  logger.info(responseEntity.getBody());
}

앞의 글에서 살펴본 것과 같이 RestTemplate을 사용하여 JSON 만 가져오는 것 뿐만 아니라 HTML 문서도 가져올 수 있다. 다시 말해서 모든 URI에 접근해서 HTTP Request로 요청할 수 있는 모든 일을 할 수 있는 것이다.

RestTemplate을 사용하여 POST 로 FORM 데이터 보내기

이 기능을 소개하기 위해서 앞에 여러가지 많은 컨트롤러와 RestTemplate의 기능을 소개했다.

RestTemplate은 REST 요청에 최적화 되어 있다. 다시 말해서 JSON 타입의 GET/POST/PUT/PATCH/DELETE 메소드를 사용한 HTTP Request 요청에 최적화 되어 있다고 생각하면 된다.

하지만! 기존에 Spring 프로젝트에서는 POST로 데이터를 전송하면 @ModelAttribute를 사용하여 파라미터를 객체와 매핑하였다. 이전에는 API 서비스가 많지 않았고 대부분 웹에서 Form을 사용하여 Submit을 하기 때문에 기존의 컨트롤러는 @RequestBody와 같은 JSON 파라미터를 객체로 매핑하는 컨트롤러를 만들지 않았기 때문이다. 우리는 Spring에서 REST 서비스를 위한 컨트롤러에 FORM과 파일업로드(multipart/form-data)를 함께 사용하기와 컨트롤러 테스트하기 글에서 HTML form을 사용하여 Multipart/Form-data를 전송하고 받는 컨틀롤와 뷰를 만들어보았다. Submit을 했을 때 매핑되는 컨트로러는 다음과 같다. 자세히 보면 클라이언트에서 객체의 데이터를 받는 것이 @ModelAttribute 라는 것을 살펴볼 수 있다.

@RequestMapping(value = "/articles", method = RequestMethod.POST)
@ResponseBody
public Article submit(@ModelAttribute Article article){
    return article;
}

그럼 RestTemplate을 사용하여 이 컨트롤러에 요청을 하려면 어떻게 해야할지 살펴보자.

우선 앞에서 살펴보듯 RestTemplate에서 기본적으로 POST를 요청할 때 사용했던 restTemplate.postForObject() 방법으로 테스트를 진행해보자.

 @Test
public void testSubmit() throws Exception {

  URI uri = URI.create(baseUrl + "/articles");

  Article article = new Article();
  article.setTitle("testing create article");
  article.setContent("test content");

  Comment comment = new Comment();
  comment.setContent("test comment1");
  List<Comment> comments = new ArrayList<>();
  comments.add(comment);

  article.setComments(comments);

  String responseString = restTemplate.postForObject(uri, article, String.class);
  String jsonString = jsonStringFromObject(article);

  assertThat(responseString, is(equalTo(jsonString)));

}

테스트 결과는 다음과 같다. 테스트 Fail 정보를 살펴보면 컨트롤에서 POST로 받은 Article의 객체를 JSON으로 매핑하여 반환할 때 Article의 필드에 값이 없는 것을 확인할 수 있다. 다시말해서 @ModelAttribute로 매핑되는 파라미터의 값이 하나도 들어오지 않았다는 말이 된다.

그럼 컨트롤러에 도착할 때, Request를 POST로 전송하여 컨트롤러까지 오는 객체를 알아보기 위해서 submit을 처리하는 메소드에 브레이크 포인트를 걸어서 확인해보자.

브레이크 포인트를 확인해보면 @ModelAttribute에 매핑할 객체의 값이 모두 null인 것을 확인할 수 있다. 다시 말하자면 POST로 넘겨 받은 파라미터를 객체로 매핑할 때 정보를 제대로 확인할 수 없다는 것이다. 좀 더 HTTP 요청을 처리하는 객체의 내부를 살펴보자. Spring 클래스 중에서 processRequest() 메소드 안의 request 값을 살펴보면 RestTemplate에서 요청한 Content-Type이 application/json;charset=UTF-8 이란는 것을 알 수 있다.

우리는 컨트롤러에 @ModelAttribute로 파라미터를 객체에 매핑하도록 하였는데 application/json 컨텐츠 타입의 바디 즉, @RequestBody로 객체를 매핑하는 구조가 아니기 때문에 이렇게 POST로 넘어온다면 객체에 매핑이 되지 않는다. 좀 더 구체적으로 로깅을 살펴보기 위해서 Spring 어플리케이션의 로깅 레벨을 DEBUG로 변경하고 실행해보자. src/main/resources/application.properties 열어서 다음과 같이 로깅 레벨을 지정한다.

logging.level.=DEBUG

다시 테스트를 실행해보자. 로깅 레벨을 DEBUG로 지정하고 테스트를 진행하면 서버와 클래스 내부의 객체를 보다 자세하게 로깅할 수 있다.

2015-11-26 13:48:41.123 DEBUG 54749 --- [o-auto-1-exec-1] o.a.c.http11.InternalNioInputBuffer      : Received [POST /articles HTTP/1.1
Accept: text/plain, application/json, application/*+json, */*
Content-Type: application/json;charset=UTF-8
User-Agent: Java/1.8.0_25
Host: localhost:49497
Connection: keep-alive
Content-Length: 128

{"id":0,"title":"testing create article","content":"test content","comments":[{"id":0,"articleId":0,"content":"test comment1"}]}]

위와 같이 RestTemplate.postForObject()로 보낸 객체는 JSON 타입으로 요청이 되고 있는 것을 확인할 수 있다.

MultiValueMap을 사용하여 application/x-www-form-urlencoded 전송하기

Spring의 컨트롤러에서 POST로 넘어오는 객체 파라미터를 @ModelAttribute에 매핑하기 위해서는 HTTP Request의 컨텐트타입이 application/x-www-form-urlencoded 이나 multipart/form-data 이어야만 한다. 만약 application/json 타입으로 POST 전송을 한다면 @ModelAttribute로 매핑되는 객체에는 아무런 값이 들어가지 않는다. application/json은 @RequestBody로 매핑한다. application/x-www-form-urlencoded와 multipart/form-data의 차이는 POST를 전송할 때 MultipartFile 파일을 함께 전송하는지에 따라 차이가 난다.

먼저 RestTemplate으로 application/x-www-form-urlencoded 타입으로 POST를 전송해보자. RestTemplate에서 객체를 application/x-www-form-urlencoded로 전송하기 위해서는 MultiValueMap를 사용하여 전송해야한다. 다음과 같이 Article의 객체를 MultiValueMap을 사용하여 Article을 POST 요청할 수 있도록 수정한다.

이 때 주의할 점은 객체 안에 계층 구조를 풀어서 MultiValueMap의 이름으로 지정해야한다는 것이다.

Article 객체 안에 Comment는 List 타입으로 여러개의 Comment를 한번에 보내도록 객체 관계를 가지고 전송하도록 만들었는데, 이것을 컨트롤러에서 @ModelAttribute를 통해 Article 객체를 생성하고 Comment 리스트로 매핑하기 위해서는 restTemplate에서 MulitiValueMap을 만들때 파라미터의 이름을 article.comments[0].id, article.comments[1].id 와 같이 만들어서 보내야 한다는 것이다.

 @Test
public void testSubmit() throws Exception {

  URI uri = URI.create(baseUrl + "/articles");

  Article article = new Article();
  article.setTitle("testing create article");
  article.setContent("test content");

  Comment comment = new Comment();
  comment.setContent("test comment1");
  List<Comment> comments = new ArrayList<>();
  comments.add(comment);

  article.setComments(comments);

  MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
  multiValueMap.add("title", article.getTitle());
  multiValueMap.add("content", article.getContent());
  multiValueMap.add("comments[0].content", article.getComments().get(0).getContent());

//        String responseString = restTemplate.postForObject(uri, article, String.class);
  String responseString = restTemplate.postForObject(uri, multiValueMap, String.class);
  String jsonString = jsonStringFromObject(article);

  assertThat(responseString, is(equalTo(jsonString)));
}

테스트를 실행하면 다음과 같이 HTTPMethod.POST를 요청할 때 Content-Type이 application/x-www-form-urlencoded로 전송되고 Article의 객체가 POST의 Body 로 전송되는 것을 확인할 수 있다.

MultiValueMap을 사용하여 Multipart/Form-data 전송하기

위에서 RestTemplate로 POST를 전송할 때 application/x-www-form-urlencoded로 Content-Type을 지정하였다. 하지만 만약 파일을 함께 보낼때는 이것을 사용하면 파일을 매핑할 수 없다. 파일과 함께 보내기 위해서는 multipart/form-data로 Content-Type을 지정 해야하는데, RestTemplate은 이런 경우의 수를 생각하지 않아도 된다. MultiValueMap 안에 첨부 파일이 들어 있으면 자동으로 Content-Type을 multipart/form-data로 요청하기 때문이다. 이것은 RestTemplate가 가지고 있는 MessageConverters 라는 것 때문이다.

이 때 주의할 점은 MultiValueMap에 파일을 첨부하기 위해서는 Resource 타입으로 파일을 추가해야한다.

우리는 MultiPartFile을 ByteArrayResource로 변환하여 MutliValueMap에 추가하여 전송을 하였다.

@Test
public void testSubmit() throws Exception {

  URI uri = URI.create(baseUrl + "/articles");

  Article article = new Article();
  article.setTitle("testing create article");
  article.setContent("test content");

  Comment comment = new Comment();
  comment.setContent("test comment1");
  List<Comment> comments = new ArrayList<>();
  comments.add(comment);
  article.setComments(comments);

  MockMultipartFile file = new MockMultipartFile("file", "filename.txt", "text/plain", "some xml".getBytes());
  article.setFile(file);

  MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
  multiValueMap.add("title", article.getTitle());
  multiValueMap.add("content", article.getContent());
  multiValueMap.add("comments[0].content", article.getComments().get(0).getContent());

  ByteArrayResource resource = new ByteArrayResource(article.getFile().getBytes()){
      @Override
      public String getFilename() throws IllegalStateException {
          return article.getFile().getOriginalFilename();
      }
  };
  multiValueMap.add("file", resource);

//        String responseString = restTemplate.postForObject(uri, article, String.class);
  String responseString = restTemplate.postForObject(uri, multiValueMap, String.class);
  String jsonString = jsonStringFromObject(article);

  assertThat(responseString, is(equalTo(jsonString)));
}

이렇게 RestTemplate을 사용하여 JSON 타입으로 POST를 전송하거나 Multipart/Form-data 형태로 파일을 포함한 데이터를 서버로 전송할 수 있다.

Java Reflection을 사용하여 자동으로 MultiValueMap 만들기

RestTemplate에서 Multipart/Form-data 를 전송하기 위해서는 POJO에 담겨져 있는 데이터를 MultiValueMap에 하나씩 꺼내어 다시 파라미터 이름을 만들어서 추가해야하고 그렇게 만들어진 MultiValueMap을 RestTemplate으로 POST 요청을 해야한다.

이 과정을 자동화 시키기 위해서 MultiValueMapConverter를 만들었다. 다음과 같이 POJO에 들어있는 데이터를 가지고 자동으로 MultiValueMap을 만들어 주는 것이다.

MultiValueMap multiValueMap = new MultiValueMapConverter(article).convert();

MultiValueMapConverter.java는 다음과 같이 Java Reflection을 사용하여 만들었다.

POJO를 필드명과 오브젝트를 탐색하고 계층 구조일 경우 재귀적으로 탐색하면서 계층구조와 리스트의 경우 MultiValueMap에 들어가는 이름을 자동으로 만들어주고 객체를 add하게 만들었다. 이 MultiValueMap 클래스는 완벽하지 않지만 객체에서 값을 수작업으로 꺼내어 MultiValueMap에 넣지 않고 자동으로 처리할 수 있어 꽤 유용하게 사용할 수 있다.

package net.saltfactory.tutorial;

import org.springframework.core.io.ByteArrayResource;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.multipart.MultipartFile;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.Set;

/**
 * filename : MultiValueMapConverter.java
 * author   : saltfactory<saltfactory@gmail.com>
 * license  : MIT
 * created  : 11/25/15
 */
public class MultiValueMapConverter {
    private MultiValueMap<String, Object> multiValueMap;

    private Object bean;

    public MultiValueMapConverter(Object bean) {
        this.multiValueMap = new LinkedMultiValueMap<>();
        this.bean = bean;
    }

    public MultiValueMap convert() throws Exception {
        this.addMultiValueFromBean(this.multiValueMap, "", this.bean);
        return this.multiValueMap;
    }


    private boolean isPrimitiveType(Object object) {
        if ((object instanceof String) ||
                (object instanceof Integer) ||
                (object instanceof Float) ||
                (object instanceof Void) ||
                (object instanceof Boolean) ||
                (object instanceof Long)) {
            return true;
        } else {
            return false;
        }
    }

    private MultiValueMap addMultiValueFromBean(MultiValueMap multiValueMap, String name, Object object) throws IntrospectionException, InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        MultiValueMap mvm = multiValueMap;

        Field[] fields = object.getClass().getDeclaredFields();

        for (Field field : fields) {
            String _name = (name.equals("")) ? field.getName() : name + "." + field.getName();
            Object value = new PropertyDescriptor(field.getName(), object.getClass()).getReadMethod().invoke(object);

            if (value == null) {
//                return mvm;
            } else {

//            if (!this.isPrimitiveType(value)) {
//                mvm = this.addMultiValueFromBean(mvm, _name, value);
//            } else {
                if (value instanceof Map) {
                    mvm = this.addMultiValueFromMap(multiValueMap, _name, (Map) value);
                } else if (value instanceof Iterable) {
                    mvm = this.addMultiValueFromIterable(multiValueMap, _name, (Iterable) value);
                } else if (value instanceof MultipartFile) {
                    MultipartFile multipartFile = (MultipartFile) value;
                    ByteArrayResource resource = null;
                    try {
                        resource = new ByteArrayResource(multipartFile.getBytes()){
                            @Override
                            public String getFilename() throws IllegalStateException {
                                return multipartFile.getOriginalFilename();
                            }
                        };
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    mvm.add(_name, resource);
                } else {
                    value = new PropertyDescriptor(field.getName(), object.getClass()).getReadMethod().invoke(object);
                    mvm.add(_name, value);
                }
//            }
            }
        }


        return mvm;
    }

    private MultiValueMap addMultiValueFromIterable(MultiValueMap multiValueMap, String name, Iterable iterable) throws NoSuchMethodException, IntrospectionException, IllegalAccessException, InvocationTargetException {
        MultiValueMap mvm = multiValueMap;

        int i = 0;
        for (Object object : iterable) {
            String _name = name + "[" + i + "]";
            if (object instanceof Map) {
                mvm = this.addMultiValueFromMap(mvm, _name, (Map) object);
            } else if (object instanceof Iterable) {
                mvm = this.addMultiValueFromIterable(mvm, _name, (Iterable) object);
            } else {
                mvm = this.addMultiValueFromBean(mvm, _name, object);
                i++;
            }

        }
        return mvm;
    }

    private MultiValueMap addMultiValueFromMap(MultiValueMap multiValueMap, String name, Map map) {
        MultiValueMap mvm = multiValueMap;
        Set<String> keys = map.keySet();

        for (String key : keys) {
            String _name = name + "." + key;

            Object value = map.get(key);
            if (value instanceof Map) {
                mvm = this.addMultiValueFromMap(mvm, _name, (Map) value);
            } else if (value instanceof Iterable) {
            } else {
                mvm.add(_name, value);
            }
        }

        return mvm;
    }
}

위의 RestTemplate으로 Multipart/form-data를 전송하는 코드를 다음과 같이 객체를 그대로 MultiValueMap으로 전송하게 간단하게 만들 수 있다.

@Test
public void testSubmit() throws Exception {

    URI uri = URI.create(baseUrl + "/articles");

    Article article = new Article();
    article.setTitle("testing create article");
    article.setContent("test content");

    Comment comment = new Comment();
    comment.setContent("test comment1");
    List<Comment> comments = new ArrayList<>();
    comments.add(comment);
    article.setComments(comments);

    MockMultipartFile file = new MockMultipartFile("file", "filename.txt", "text/plain", "some xml".getBytes());
    article.setFile(file);

    MultiValueMap<String, Object> multiValueMap = new MultiValueMapConverter(article).convert();

    String responseString = restTemplate.postForObject(uri, multiValueMap, String.class);
    String jsonString = jsonStringFromObject(article);

    assertThat(responseString, is(equalTo(jsonString)));

}

결론

사실 이 글을 작성하기 위해서 앞에 여러가지 REST 컨트롤러와 RestTemplate을 구현하고 테스트하는 방법을 살펴보았다. 처음 우리는 Spring 컴포넌트에서 웹 페이지에서 FORM으로 POST를 전송 받은 데이터를 API 서버로 전송하는 과정에서 RestTemplate을 가지고 컨트롤러에 받은 객체를 그대로 전송하는 방법이 필요했다. 하지만 RestTemplate로 API 서버로 객체를 전송하기 위해서는 MultiValueMap을 사용해야하는데 객체의 크기가 다양하고 계층 구조가 다양했기 때문에 하드 코딩으로 객체 안의 데이터를 빼어내는 작업을 하고 싶지 않았다. 그래서 우리는 Spring의 컨트롤러와 RestTemplate 동작 원리에 대해서 연구를 하기 시작했고 이 포스팅에서 소개하는 방법으로 문제를 해결했다. 다음은 우리가 하고 싶었던 컨트롤러 컴포넌트 내부의 모습을 간단하게 만든 모양이다.

@RequestMapping(value = "/articles", method = RequestMethod.POST)
@ResponseBody
public Article submit(@ModelAttribute Article article) throws Exception {

    URI uri = URI.create("http://API서버");
    RestTemplate restTemplate = new RestTemplate();
    MultiValueMap multiValueMap = new MultiValueMapConverter(article).convert();

    return restTemplate.postForObject(uri, multiValueMap, Article.class);

}

RestTemplate는 Spring 내부에서 다른 서버로 HTTP Request 요청을 처리하고 객체로 간단하게 매핑할 수 있기 때문에 효율적인 코드를 작성할 수 있고, MultiValueMap을 사용하여 Multipart/Form-data를 쉽게 전송하기 위해서 MultiValueMapConverter를 사용하면 특별한 코드를 추가하지 않고 객체를 바로 POST로 보내는 MultiValueMap으로 만들어서 전송할 수 있다.

소스코드

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-resttemplate/SpringBootDemo
https://github.com/saltfactory/saltfactory-java-tutorial/blob/spring-boot-resttemplate/SpringBootDemo/src/main/java/net/saltfactory/tutorial/MultiValueMapConverter.java

참조

http://www.springframework.net/rest/doc-latest/reference/html/resttemplate.html
http://blog.saltfactory.net/java/submit-multipart-form-data-and-test-in-spring.html
http://blog.peecho.com/blog/java-s3-upload-using-spring-resttemplate
http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/Matchers.html#hasXPath(java.lang.String)
http://matchers.jcabi.com/xhtml-matchers.html
http://docs.spring.io/autorepo/docs/spring-android/1.0.x/reference/html/rest-template.html
https://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary.html
https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/http/converter/FormHttpMessageConverter.html
http://stackoverflow.com/questions/4118670/sending-multipart-file-as-post-parameters-with-resttemplate-requests

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Spring에서 RestTemplate을 사용하여 REST 기반 서비스 요청과 테스트하기

Wed, 25 Nov 2015 00:00:00 +0000

서론

우리는 며칠간에 걸쳐 Spring Boot로 Spring 기반 REST 서비스와 템플릿 뷰를 사용하여 Multipart Form data를 사용하기 위한 컨트롤러를 구현하는 방법을 살펴보았다. 또한 컨트롤러를 테스트하기 위해서 MockMvc를 사용하여 짧은 코드로 간단하게 Spring 테스트 프레임워크에서 URL을 요청하여 컨트롤러를 테스트하는 방법도 살펴보았다.

Spring 기반 프로젝트를 진행하면 컴포넌트 내부에서 URL을 요청해야하는 경우가 있다. 이전에는 Apache의 HttpClient 라이브러리를 포함시켜 Http Request를 컴포넌트 내부에서 사용했지만 최근 Spring에서는 Http Request 요청을 간단하게 사용할 수 있도록 SpringTemplate라는 모듈을 포함하고 있다. 이번 포스팅에서는 RestTemplate을 사용하여 Spring 안에서 GET, POST, PUT, PATCH, DELETE REST 요청을 처리하는 방법을 살펴본다.

데모를 위한 프로젝트 생성

우리는 앞에서 spring-boot-rest 소스 코드에 REST 서비스를 위한 컨트롤러에 대한 예제 코드를 만들었다. 만약 이 글을 처음 보고 있다면 앞의 Spring에서 REST 서비스를 위한 컨트롤러 생성과 컨트롤러 단위테스트 하기 글을 참조하여 RestTemplate 테스트를 하기 위한 REST 서비스를 위한 컨트롤러를 먼저 만들자.

@WebIntegrationTest 로 RestTemplate 사용하기

우리는 앞에서 컨트롤러를 만들고 단위 테스트를 할 때 MockMvc를 사용하였다. MockMvc는 말 그대로 가짜 웹 서버와 Http request 만들어서 테스트하는 것이다. @WebIntegrationTest는 웹 서비스를 다르게 테스트할 수 있는 방법을 제시하고 있다. @WebIntegrationTest는 @WebAppConfigration과 @IntegrationTest가 통합되어 만들어진 것으로 Web Application을 설정과 실제 웹 서버를 동작하여 테스트를 하는 것과 같이 테스트를 할 수 있는 방법을 제공하고 있다.

우리는 RestTemplate에 관한 테스트를 진행할 것이기 때문에 앞에서 ArticlesControllerTests 파일을 참조하여 src/test/{패키지명}/RestTemplateTests.java 파일을 다음과 같이 만들자.

@WebIntegrationTest(“server.port=0”) : 테스트를 위해서 동작하는 웹 서버 포트 번호를 지정할 수 있는데 이 값이 0이면 랜덤으로 테스트를 할 때 지정하여 동작하게 된다. 이 때 지정된 포트번호는 @Value("{local.server.port}") int port; 형태로 injection으로 값을 가져올 수 있다. WebIntegrationTest 방법으로 테스트를 진행할 때는 실제 테스트를 위한 웹 서버가 동작하는 것이기 때문에 서버에 접근할 수 있는 URL이 필요하다. 우리는 포트번호를 랜덤하게 정하였기 때문에 기본적으로 URL을 만들기 위해서 String baseUrl변수를 만들었고 이것은 테스트가 진행할 때 @before 테스트 시작 전에 포트번호를 가지고 URL의 앞부분을 만들 것이다. 예를 들면 http://localhost:81268 와 같은 식으로 만들어지는 것이다. 그리고 우리는 웹 서버에 접근하여 Http Request를 요청하는 것을 RestTemplate으로 사용할 것이기 때문에 테스트 전에 객체를 생성하도록 하였다.

package net.saltfactory.tutorial;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.*;
import org.springframework.http.*;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsEqual.equalTo;

/**
 * filename : RestTemplateTests.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/25/15
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
@WebIntegrationTest("server.port=0")
public class RestTemplateTests {

    Logger logger = Logger.getLogger(this.getClass());

    @Value("${local.server.port}")
    int port;

    @Autowired
    ArticlesService articlesService;

    private String baseUrl;
    RestTemplate restTemplate;

    @Before
    public void setUp() {
        restTemplate = new RestTemplate();
        baseUrl = "http://localhost:" +  String.valueOf(port);
    }

    private String jsonStringFromObject(Object object) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }
}

이제 RestTemplate을 사용하여 우리가 만든 REST 웹 서비스의 컨트롤러에 Http 요청을 해보자.

GET /api/articles

MockMvc를 사용하여 테스트한 코드를 먼저 살펴보자.

@Test
public void testIndex() throws Exception {
    List<Article> articles = articlesService.getArticles();
    String jsonString = this.jsonStringFromObject(articles);

    MvcResult result = mockMvc.perform(get("/api/articles"))
            .andExpect(status().isOk())
            .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
            .andExpect(content().string(equalTo(jsonString)))
            .andReturn();

    logger.info(result.getResponse().getContentAsString());
}

이제 RestTemplate을 사용하여 실제 웹 서버로 GET 요청을 해보자. RestTemplate으로 Http GET 요청을 하는 방법는 여러가지가 있는데 크게 다음가 같다.

restTemplate.getForObject() : 기본 Http Header를 사용며 결과를 객체로 반환 받는다.
restTemplate.getForEntity() : 기본 Http Header를 사용하며 결과를 Http ResponseEntity로 반환 받는다.
restTemplate.exchange() : Http Header 를 수정할 수 있고 결과를 Http ResponseEntity로 반환 받는다.
restTemplate.execute() : Request/Response 콜백을 수정할 수 있다.

다음 예제는 http://localhost:{port}/api/articles 로 RestTemplate을 사용하여 HttpMethod.GET 요청을 하는 테스트이다. 이 때 결과 반환값을 JSON 문자열로 받고 싶어서 결과 반환 값을 String.class로 지정하였다. restTemplate.getForObject(uri,반환될 객체 타입) 으로 보면 된다. RestTemplate의 HttpMethod.GET의 결과를 확인하기 위해서 로깅을 해보았다. 만약 RestTemplate가 웹 서버에 정상적인 요청을 했다면 Articles의 List 타입이 JSON으로 만들어져 보일것이다. 컨트롤러를 요청한 결과과 맞는지 확인하기 위해서 ArticlesService.getArticles()로 가져오는 결과와 비교했다.

@Test
public void testIndex() throws Exception {

    URI uri = URI.create(baseUrl+ "/api/articles");
    String responseString = restTemplate.getForObject(uri, String.class);

    // 컨트롤러 결과를 로깅
    logger.info(responseString);

    // 컨트롤러 결과를 확인하기 위한 데이터 가져오기
    List<Article> articles = articlesService.getArticles();
    String jsonString = jsonStringFromObject(articles);

    // 컨트롤러의 결과와 JSON 문자열로 비교
    assertThat(responseString, is(equalTo(jsonString)));
}

RestTemplate.getForObject()로 HttpMethod.GET을 요청한 결과는 정상적이고 컨트롤르에서 반환한 JSON을 로깅을 통해서 확인할 수 있다.

RestTemplate을 사용하여 API 서버에서 JSON 문자열로 반환받게 되면 우리는 이것을 어플리케이션에서 객체 타입으로 다시 JSON 라이브러리를 사용하여 POJO 객체로 변환하는 작업을 할 것이다. 하지만 RestTemplate은 이런 과정을 자동으로 할 수 있다. 우리는 테스트를 위해서 반환 타입을 String.class로 지정하였지만 만약 API를 요청한 결과를 객체에 매핑한 Article 형태로 받고 싶다면 반환 타입에 객체 타입을 지정하면 자동으로 JSON 결과를 객체로 매핑해서 반환해준다.

위 테스트를 다음과 같이 수정해보자.

@Test
public void testIndex() throws Exception {

    URI uri = URI.create(baseUrl+ "/api/articles");
//  String responseString = restTemplate.getForObject(uri, String.class);
    List<Article> resultArticles = Arrays.asList(restTemplate.getForObject(uri, Article[].class));

// 컨트롤러 결과를 로깅
//  logger.info(responseString);

// 컨트롤러 결과를 확인하기 위한 데이터 가져오기
    List<Article> articles = articlesService.getArticles();
//  String jsonString = jsonStringFromObject(articles);

// 컨트롤러의 결과와 JSON 문자열로 비교
//  assertThat(responseString, is(equalTo(jsonString)));
    assertThat(resultArticles.size(), is(equalTo(articles.size())));
    assertThat(resultArticles.get(0).getId(), is(equalTo(articles.get(0).getId())));
}

브레이크 포인트를 가지고 RestTemplate가 컨트롤러에서 반환한 결과를 살펴보자.

restTemplate.getObjectFor()에 반환되는 객체의 타입을 지정하면 JSON을 자동으로 반한되는 객체로 매핑해주는 것을 확인할 수 있다.

POST /api/articles

앞에서 우리는 REST 서비스를 위한 컨트롤러에서 @RequestBody를 사용하여 객체를 JSON 타입으로 HttpMethod.POST를 보내는 것을 만들고 테스트를 통해 확인하였다. 먼저 MockMvc를 통해 테스트한 코드를 살펴보자. MockMvc 테스트를 통해서 보면 알 수 있듯 post() 요청을 할 때 content() 안에 Article 객체를 JSON 타입으로 변환해서 전송하는 것을 확인할 수 있다.

@Test
public void testCreate() throws Exception {
    Article article = new Article();
    article.setTitle("testing create article");
    article.setContent("test content");

    Comment comment = new Comment();
    comment.setContent("test comment1");
    List<Comment> comments = new ArrayList<>();
    comments.add(comment);

    article.setComments(comments);

    String jsonString = this.jsonStringFromObject(article);

    MvcResult result = mockMvc.perform(post("/api/articles")
            .contentType(MediaType.APPLICATION_JSON)
            .content(jsonString))
            .andExpect(status().isOk())
            .andExpect(content().string(equalTo(jsonString))).andReturn();

    logger.info(result.getResponse().getContentAsString());
}

이제 RestTemplate으로 실제 웹 서비스 형태로 테스트를 해보자. RestTemplate에서 POST를 요청하는 방법는 위에서 GET을 요청하는 방법과 비슷하다. 다만 getFor 로 시작하는 것을 postFor 로 바꿔주면 된다. 나머지는 동일하다.

restTemplate.postForObject()
restTemplate.postForEntity()
restTemplate.exchange()
restTemplate.execute()

MockMvc에서 가짜로 테스트하는 것과 달리 RestTemplate를 사용하여 실제 서버로 객체를 POST로 보낼 때는 Article의 객체를 그대로 넘겨주면 된다. 아주 간단하다.

@Test
public void testCreate() throws Exception {

  URI uri = URI.create(baseUrl + "/api/articles");

  Article article = new Article();
  article.setTitle("testing create article");
  article.setContent("test content");

  Comment comment = new Comment();
  comment.setContent("test comment1");
  List<Comment> comments = new ArrayList<>();
  comments.add(comment);

  article.setComments(comments);

  Article resultArticle = restTemplate.postForObject(uri, article, Article.class);

  assertThat(resultArticle.getTitle(), is(equalTo(article.getTitle())));


//        String responseString = restTemplate.postForObject(uri, article, String.class);
//        String jsonString = jsonStringFromObject(article);
//
//        assertThat(responseString, is(equalTo(jsonString)));
//        logger.info(responseString);
    }

테스트를 진행하면 성공적으로 새로운 Article이 POST로 전송되는 것을 확인할 수 있다. 하지만 한가지 중요한 조건이 있다. 이 때 웹 서버의 컨트롤러에서 이 POST 요청이 매핑되는 곳에서 Article 객체를 매핑하기 위해서는 반드시 @RequetBody 요청으로 되어 있어야 한다는 것이다. 다시 한번 서버에서 POST의 컨트롤러 코드를 살펴보자.

@RequestMapping(value = "/api/articles", method = RequestMethod.POST)
@ResponseBody
public Article create(@RequestBody Article article) {
    return article;
}

나중에 다시 설명하겠지만 POST로 Article의 새로운 값을 받기 위해서 @ModelAttribute를 사용하는 것이 아니라 @RequestBody로 POST로 들어오는 객체를 매핑해야한다.

DELETE /api/articles/{id}

다음은 HttpMethod.DELETE의 경우 RestTemplate에서 처리하는 방법을 살펴보자. 위에서 우리는 GET과 POST 요청을 할 때의 네이밍 규칙을 보고 DELETE 요청을 처리하기 위해서 restTemplate.deleteForObject() 라고 코드를 생각할지 모르지만 이것은 잘 못된 생각이다. RestTemplate에서 DELETE와 PUT에 관한 요청은 반환값을 가지지 않을 뿐만 아니라 파라미터 전송도 없다. 하지만 크게 당황하지 않아도 된다. 컨트롤러에서 반환값을 갖기 위해서는 template.exchange()를 사용하면 된다. 만약 반환값에 상관없이 단순하게 DELETE 요청을 할 때는 template.delete()을 사용하여 요청하면 된다.

restTemaplate.delete()
restTemplate.exchange()
restTemplate.execute()

relateTemplate을 사용하여 HttpMethod.DELETE 요청을 처리하는 방법은 다음과 같다. 주석이 되어 있는 부분은 요청 후 반환값이 없을 때 간단하게 사용할 수 있는 방법이다.

만약 DELETE 요청 후 반환값이 필요하면 restTemplate.exchange()로 요청하면 되는데 이 것은 앞에서 restTemplate을 사용하는 방법과 달리 HttpHeaders와 HttpEntity를 사용하여 요청을 보내는 것을 확인할 수 있다. 그리고 exchange() 메소드에서 HttpMethod.DELETE를 보낸다고 method의 타입을 지정하는 것도 알 수 있단. 이유는 exchange()는 말 그대로 사용자가 직접 전달하는 것을 정의하여서 보내는 것이기 때문에 모둔 HttpMethod에서 동일하게 사용할 수 있는 방법이다.

@Test
public void testDelete() throws Exception {

    long id = 1;
    URI uri = URI.create(baseUrl + "/api/articles/" + id);

//        Article article = articlesService.getArticle(id);
//        restTemplate.delete(uri);

    HttpHeaders headers = new HttpHeaders();
    HttpEntity entity = new HttpEntity(headers);

    ResponseEntity<String> responseEntity = restTemplate.exchange(uri, HttpMethod.DELETE, entity, String.class);

    String jsonString = jsonStringFromObject(articlesService.deleteArticle(id));

    assertThat(responseEntity.getStatusCode(), is(HttpStatus.OK));
    assertThat(responseEntity.getBody(), is(equalTo(jsonString)));

    logger.info(responseEntity.getBody());
}

PUT /api/articles/{id}

HttpMethod.PUT의 요청 또한 위의 HttpMethod.DELETE의 방법과 동일하다 단지 PUT은 데이터를 업데이트하기 위한 요청을 하기 때문에 객체를 함께 보내는 것이 다르다. 이 때 주의할 점은 객체를 보낼 때 HttpEntity에 header와 함께 보내는 것을 주의한다.

@Test
public void testPut() throws Exception {
    long id = 1;

    URI uri = URI.create(baseUrl + "/api/articles/" +id);

    Article article = articlesService.getArticle(id);
    article.setTitle("testing create article");
    article.setContent("test content");

    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);

    HttpEntity<Article> entity = new HttpEntity(article, headers);

    ResponseEntity<String> responseEntity = restTemplate.exchange(uri, HttpMethod.PUT, entity, String.class);

    String jsonString = jsonStringFromObject(article);

    assertThat(responseEntity.getStatusCode(), is(HttpStatus.OK));
    assertThat(responseEntity.getBody(), is(equalTo(jsonString)));
}

PATCH /api/articles/{id}

우리는 앞에서 컨트롤러를 만들 때 PATCH 는 PUT과 유사하다고 말했다. 그래서 RestTemplate으로 PUT을 보내는 방법고 동리하게 하며 exchange()에서 method를 HttpMethod.PATCH로 변경하면 될 것이라 생각하기 쉽다. 하지만 안타깝게 기본적으로 RestTemplate은 POST, GET, PUT, DELETE, OPTIONS 만 제공한다. 그래서 만약 이렇게 코드를 작성하면 다음과 같은 에러를 보게 된다.

@Test
public void testPatch() throws Exception {
    long id = 1;

    URI uri = URI.create(baseUrl + "/api/articles/" +id);

    Article article = articlesService.getArticle(id);
    article.setTitle("testing create article");
    article.setContent("test content");

    HttpHeaders headers = new HttpHeaders();
    HttpEntity<Article> entity = new HttpEntity(article, headers);

    ResponseEntity<String> responseEntity = restTemplate.exchange(uri, HttpMethod.PATCH, entity, String.class);

    String jsonString = jsonStringFromObject(article);

    assertThat(responseEntity.getStatusCode(), is(HttpStatus.OK));
    assertThat(responseEntity.getBody(), is(equalTo(jsonString)));
}

위 코드를 실행하면 > org.springframework.web.client.ResourceAccessException: I/O error on PATCH request for “http://localhost:56447/api/articles/1”:Invalid HTTP method: PATCH; nested exception is java.net.ProtocolException: Invalid HTTP method: PATCH

에러를 보게 된다. 이것은 RestTemplate이 기본적으로 PATCH 메소드를 지원하고 있지 않기 때문이다.

RestTemplate은 ClientHttpRequest 감싸고 있는 모듈인데 기본적으로 SimpleClientHttpRequestFactory로 만들어져 있다. 우리는 Apache HttpComponents HttpClient를 만들 때 사용하는 HttpComponentsClientHttpRequestFactory으로 ClientHttpRequest를 바꾸어서 사용할 것이다. RestTemplate를 생성할 때 ClientHttpRequestFactory를 변경하여 생성한다. HttpComponentsClientHttpRequestFactory는 Apache HttpClient 라이브러가 필요하다. guild.gradle 파일을 열어서 라이브러리를 추가한다.

buildscript {
    ext {
        springBootVersion = '1.3.0.RELEASE'
    }
    repositories {
        mavenCentral()
        maven { url 'http://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
    baseName = 'spring-boot-demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    compile('org.springframework.boot:spring-boot-starter-web')
    testCompile('org.springframework.boot:spring-boot-starter-test')

    compile('org.springframework.boot:spring-boot-configuration-processor')
    compile('org.apache.httpcomponents:httpclient:4.5.1')
}

compileJava.dependsOn(processResources)

configure(allprojects) {
    apply plugin: 'propdeps'
    apply plugin: 'propdeps-maven'
    apply plugin: 'propdeps-idea'
    apply plugin: 'propdeps-eclipse'
}


eclipse {
    classpath {
         containers.remove('org.eclipse.jdt.launching.JRE_CONTAINER')
         containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

gradle로 의존성있는 라이브러리를 자동으로 다운로드 받은 후 RestTemplate에서 PATCH을 사용하기 위해서 RestTemplate을 HttpComponentsClientHttpRequestFactory을 가지고 새롭게 생성한다.

@Test
public void testPatch() throws Exception {
    long id = 1;

    URI uri = URI.create(baseUrl + "/api/articles/" +id);

    Article article = articlesService.getArticle(id);
    article.setTitle("testing create article");
    article.setContent("test content");

    HttpHeaders headers = new HttpHeaders();
    HttpEntity<Article> entity = new HttpEntity(article, headers);

    ClientHttpRequestFactory httpRequestFactory =  new HttpComponentsClientHttpRequestFactory();
    restTemplate = new RestTemplate(httpRequestFactory);

    ResponseEntity<String> responseEntity = restTemplate.exchange(uri, HttpMethod.PATCH, entity, String.class);

    String jsonString = jsonStringFromObject(article);

    assertThat(responseEntity.getStatusCode(), is(HttpStatus.OK));
    assertThat(responseEntity.getBody(), is(equalTo(jsonString)));
}

브레이크 포인트를 사용하여 컨트롤러에서 확인하면 RestTemplate을 사용하여 요청한 PATCH 요청이 정상적으로 컨트롤러에 요청되는 것을 확인할 수 있다.

결론

실제 우리는 Spring을 사용하는 프로젝트에서 컴포넌트 내에서 API 서버로 REST 요청을 한는 작업을 RestTemplate을 사용하여 구현하였다. RestTemplate은 이전에 상요하던 Apache의 HttpClient 보다 간단하고 짧은 코드로 쉽게 API 서버로 REST 요청을 처리할 수 있다. JSON 형태의 문자열 결과만 받아오는 것 뿐만 아니라 JSON객체나 POJO 객체로 변환하는 작업 없이 컴포넌트 내에서 사용하는 객체로 바로 매핑하여 사용할 수 있다는 점에서 객체 변환 코드 상당 수를 줄일 수 있었다. RestTemplate은 크레 getForObject(), postForObject()와 같이 Object로 매핑할 수 있는 요청과 , getForEntity(), postForEntity()와 같이 Entity로 매핑할 수 있는 요청을 할 수 있다 그리고 delete()나 put()과 같이 반환 없는 요청을 할 수 있다. exchange()나 execute() 같은 함수는 모든 Http method 요청에 사용할 수 있고 사용자가 요청하는 객체를 새롭게 정의하거나 로직을 변경할 수도 있다. RestTemplate은 PATCH 메소드를 기본적으로 지원하고 있지 않기 때문에 PATCH 를 지원하기 위해서는 생성할 때 Apache HttpClient 라이브를 사용하여 만든 HttpComponentsClientHttpRequestFactory를 사용하여 생성하여 사용하면 된다.

다음에는 RestTemplate을 사용하여 FORM 객체를 컨트롤러의 @ModelAttribute 객체로 매핑하는 방법과 Multipart/Form-data를 사용하여 파일 업로드를 하는 방법에 대해서 소개할 예정이다.

소스코드

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-resttemplate/SpringBootDemo

참조

http://www.springframework.net/rest/doc-latest/reference/html/resttemplate.html
https://github.com/spring-projects/rest-shell/issues/21
https://hc.apache.org/httpcomponents-client-ga/

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Spring에서 REST 서비스를 위한 컨트롤러에 FORM과 파일업로드(multipart/form-data)를 함께 사용하기와 컨트롤러 테스트하기

Tue, 24 Nov 2015 00:00:00 +0000

서론

최근 REST 기반의 서비스가 인기를 누리고 있지만 기본적으로 웹 서비스에서 입력폼은 FORMs 기반 서비스가 많다. 우리는 앞에서 Spring에서 REST 서비스를 위한 컨트롤러 생성과 컨트롤러 단위테스트 하기 글에서 Spring Boot로 웹 서비스를 구현할 때 REST 서비스를 위한 컨트롤러를 간단히 만들어보았다. Spring Boot에서 JSON 기반의 REST 서비스를 하기 위해서 @RestController, @RequestBody 그리고 @ResponseBody 를 가지고 컨트롤러를 작성하였다. 이번 포스팅에서는 Spring 기반에서 FORMs을 다루기 위한 컨트롤러를 만들고 테스트하는 방법을 소개한다.

SpringBootDemo 만들기

우리는 앞에서 REST 서비스를 위해 간단히 만들었던 SpringBootDemo에 코드를 추가하면서 설명을 진행할 것이다. 먼저 githug에서 spring-boot-rest 예제를 clone하거나 다운로드 한다.

```` git clone https://github.com/saltfactory/saltfactory-java-tutorial.git ```

저장소를 clone 했다면 spring-boot-rest 브랜치로 브랜치 이동을 한다.

git checkout -t origin/spring-boot-rest

다운받은 디렉토리 안에 SpringBootDemo 디렉토리 안에 Gradle 기반의 Spring Boot 프로젝트가 존재한다. IntelliJ에서 build.gradle을 임포트하면 자동으로 Spring 프로젝트가 만들어지게 된다.

Thymeleaf 라이브러리 추가

앞에서 받은 REST 서비스를 위한 컨트롤러에서는 HTTP 요청의 응답으로 JSON의 결과만 받았기 때문에 뷰 템플릿이 필요하지 않았지만, FORM을 입력받는 HTML 웹 페이지 서비스를 위해서 보다 효율적인 개발을 위해서 뷰 템플릿이 필요하다. IntelliJ에서 SpringBoot 웹 프로젝트 생성하기 글에서 IntelliJ에서 Spring Boot 프로젝트를 처음 만들 때 Dependencies 를 선택하는 화면을 소개한적이 있다. 처음 프로젝트를 만들 때 Template Engines에서 Spring 프로젝트에서 사용할 수 있는 뷰 템플릿을 선택할 수 있는데 최근 많이 사용하는 뷰 템플릿이 Thymeleaf이기 때문에 이것을 선택하면 wizard가 끝나면 build.gradle 파일 안에 dependencies 안에 이 라이브러리가 자동으로 포함하게 된다.

우리는 이미 만들어진 Spring Boot 프로젝트에 뷰 템플릿을 추가할 것이다. 다운받은 소스 안에 build.gradle 파일을 열어서 다음과 같이 수정한다.

buildscript {
    ext {
        springBootVersion = '1.3.0.RELEASE'
    }
    repositories {
        mavenCentral()
        maven { url 'http://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
        classpath('org.springframework:springloaded:1.2.4.RELEASE')
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
    baseName = 'spring-boot-demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

idea {
    module {
        inheritOutputDirs = false
        outputDir = file("$buildDir/classes/main/")
    }
}

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    compile('org.springframework.boot:spring-boot-starter-web')
    testCompile('org.springframework.boot:spring-boot-starter-test')

    compile('org.springframework.boot:spring-boot-configuration-processor')
}

compileJava.dependsOn(processResources)

configure(allprojects) {
    apply plugin: 'propdeps'
    apply plugin: 'propdeps-maven'
    apply plugin: 'propdeps-idea'
    apply plugin: 'propdeps-eclipse'
}


eclipse {
    classpath {
         containers.remove('org.eclipse.jdt.launching.JRE_CONTAINER')
         containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

뷰를 개발할 때는 HTML코드 변경을 자주하는데 그 때마다 어플리케이션에 적용되는 것을 확인하는 것은 매우 불편한 일이다. 그래서 우리는 앞에서 소개한 서버 재시작 없이 Spring 웹 프로젝트 개발하기 글에서 spring-loaded을 사용한 Spring의 Hot swapping을 build.gradle 파일에 추가하였다. 뷰 템플릿이 수정한 이후 자동으로 새로 컴파일된 파일을 참조하기 위해서 뷰 템플릿의 cache를 사용하지 않기 위해서 src/resources/application.properties 파일을 열어 다음과 같이 설정한다.

spring.thymeleaf.cache = false

기본적으로 SpringBoot의 application.properties에서 뷰 템플릿의 파일 위치를 지정할 수 있는데 src/resources/templates 디렉토리 안에 위치하도록 설정되어져 있다. 만약 다른 위치에 템플릿 파일들을 위치하고 싶으면 src/main/resources/application.properties 파일에 템플릿 위치를 다음과 같이 수정하면 된다.

spring.thymeleaf.prefix=classpath:/templates/

다운받은 프로젝트 안에 src/resources/templates/articles/ 디렉토리를 만든다.

build.gradle 설정을 모두 마쳤으면 IntelliJ의 Gralde project 패널에서 새로고침 버튼을 클하면 추가한 Dependencies에 관련된 라이브러리를 저장소로부터 자동으로 다운받을 수 있다.

@RestController Vs. @Controller

Spring에서 컨트롤러 컴포넌트를 만들때 우리는 기본적으로 @Controller를 사용하여 만든다. 하지만 앞에서 REST 서비스를 위한 컨트롤러를 자세히 살펴보면 @RestController를 사용한 것을 확인할 수 있다.

Spring Framework : @RestController Vs. @Controller 글에서 @RestController는 간단한 객체를 JSON/XML 타입으로 반환하는 REST 서비스에 최적화된 간단한 컨트롤러라고 소개하고 있다. 앞에서 글 Spring에서 YAML 파일 데이터 객체에 매핑하여 로드하기 글에서 @ResponseBody를 사용하여 객체를 JSON으로 반환하였는데, @RestController라고 지정을하게 되면 @ResponseBody 없이도 컨트롤러를 통해 반환되는 Http Response가 자동으로 JSON으로 변환이 된다는 것이다.

예제를 통해서 살펴보자. 우선 기존에 다운받은 소스 안에 src/main/java/{패키지명}/ArticlesController.java 파일을 열어보자.

package net.saltfactory.tutorial;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@RestController
public class ArticlesController {
    @Autowired
    ArticlesService articlesService;

    @RequestMapping(value = "/api/articles", method = RequestMethod.GET)
    @ResponseBody
    public List<Article> index() {
        return articlesService.getArticles();
    }

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.GET)
    @ResponseBody
    public Article show(@PathVariable(value = "id") long id) {
        return articlesService.getArticle(id);
    }

    @RequestMapping(value = "/api/articles", method = RequestMethod.POST)
    @ResponseBody
    public Article create(@RequestBody Article article) {
        return article;
    }

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.PATCH)
    @ResponseBody
    public Article patch(@PathVariable(value = "id") long id,  @RequestBody Article article) {
        return article;
    }

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.PUT)
    @ResponseBody
    public Article update(@PathVariable(value = "id") long id,  @RequestBody Article article) {
        return article;
    }

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.DELETE)
    @ResponseBody
    public List<Article> destroy(@PathVariable(value = "id") long id) {
        return articlesService.deleteArticle(id);
    }
}

우리는 새롭게 입력할 HTML 파일을 보여줄 메소드를 하나 추가할 것이다. 다음 메소드를 추가한다. 이 코드는 http://localhost:8080/artlces/new로 요청이 들어면 입력 폼에 값을 담을 객체를 Model에 객체를 포함하여 src/resources/templates/articles/new.html 뷰 템플릿을 렌더링하여 반환하라는 내용이다.

    @RequestMapping(value = "/articles/new", method = RequestMethod.GET)
    public String newArticle(Model model){
        Article article = new Article();
        model.addAttribute("article", article);
        return "articles/new";
    }

간단히 뷰 템플릿에 대한 파일을 다음 내용으로 src/resources/templates/articles/new.html 생추가한다. Thymeleaf 뷰 템플릿에 관련된 자세한 내용은 다음에 소개를 하고 간단히 위 Controller에서 추한 Model 안의 객체를 th:object에 정의하고 form 안에 이름과 객체의 필드명을 매핑하기 위해서 th:field를 같은 이름으로 사용한다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>SpringBootDemo</title>
    <meta charset="utf-8"/>
</head>
<body>
<h1>New Article</h1>

<form action="#" th:action="@{/articles}"
      th:object="${article}"
      method="post">
    <p>title: <input type="text" th:field="*{title}" /></p>
    <p>content:
        <textarea th:field="*{content}"></textarea>
    </p>

    <input type="submit" value="submit" />
</form>

</body>
</html>

이제 ArticlesControllers에 추가한 HTML 뷰를 보여주기 위한 메소드를 테스트하기 위해서 src/test/java/{패키지명}/ArticlesControllerTests.java에 테스트를 추가한다. HTTP Get으로 /articles/new 를 요청하게 되면 위의 HTML 내용이 렌더링된 컨텐츠타입이 text/html인 HTML 페이지가 보여야하고 그 페이지 안에 <input type="text" id="title" name="title" /> 소스코드가 있어야하기 때문에 테스트는 다음과 같이 작성이 되었다.

한가지 테스트에서 중요한 점은 기존의 REST 서비스를 위해 뷰 템플릿 없는 컨트롤러 테스트를 진행할 때는 테스트 환경을 standardaloneSetup() 메소드로 컨트롤러의 MockMvc를 만들어서 테스를 진행하였다. 하지만 뷰 템플릿까지 모두 테스트를 진행하기 위해서는 컨트롤러 객체만 필요한 것이 아니라 Web Application 전체의 자원이 필요하기 때문에 webAppContextSetup() 메소드로 MockMvc를 만들어서 테스트를 진행해야한다. 또한 테스트에서 Web Application 모든 설정을 가져오기 위해서 테스트 클래스 레벨에 @WebAppConfiguration 어노테이션을 추가해야하고 이것을 autowired 할 WebApplicationContext 변수를 추가 해야한다.

package net.saltfactory.tutorial;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.web.context.WebApplicationContext;

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

import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.webAppContextSetup;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
@WebAppConfiguration
public class ArticlesControllerTests {

    Logger logger = Logger.getLogger(this.getClass());

    private MockMvc mockMvc;

    @Autowired
    private ArticlesController articlesController;

    @Autowired
    WebApplicationContext wac;

    @Autowired
    private ArticlesService articlesService;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
//        mockMvc = standaloneSetup(articlesController).build();
        mockMvc = webAppContextSetup(wac).build();
    }

    private String jsonStringFromObject(Object object) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }


    @Test
    public void testNewArticle() throws Exception {
        MvcResult result = mockMvc.perform(get("/articles/new"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
                .andExpect(xpath("//input[@name='title']").exists())
                .andReturn();

        assertThat(result.getResponse().getContentAsString(), containsString("New Article"));

        logger.info(result.getResponse().getContentAsString());
    }
... 생략 ...

테스트를 진행해보자. 결과는 다음과 같이 실패가 된다. 소스코드에는 문제가 없는데 왜 HTML이 HTTP의 응답이 즉, 우리가 추가한 컨트롤러의 메소드에서 반환되는 객체가 뷰 페이지(text/html)가 아니라 문자열(text/plain)이 되었을까?

이유는 바로 @RestController 때문이다. 클래스 레벨에 붙여놓은 Spring Annotation인 @RestController 는 컨트롤러 내부에서 작성한 메소드가 반환하는 모든 객체를 Document 타입으로 반환하기 때문이다. 이 문제를 해결하기 위해서는 @RestController 를 @Controller 어노테이션으로 변경을 해야한다. ArticlesController 코드를 다음과 같이 수정한다. @RestController 대신에 @Controller로 변경한다.

package net.saltfactory.tutorial;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
//@RestController
@Controller
public class ArticlesController {
    @Autowired
    ArticlesService articlesService;

    @RequestMapping(value = "/articles/new", method = RequestMethod.GET)
    public String newArticle(Model model){
        Article article = new Article();
        model.addAttribute("article", article);
        return "articles/new";
    }
... 생략 ...

여기서 @RestController에 사용한 JSON 타입을 반환하는 다른 메소드들에 영향을 주는지에 대한 궁금증이 생길 수 있는데 우리는 미리 메소드 앞에 반환 타입을 @ResponseBody로 정의하여 놓았기 때문에 컨트롤러를 @RestController가 아니고 @Controller 로 지정하더라도 메소드 레벨의 어노테이션에서 반환 타입을 JSON으로 변경하기 때문에 기존의 코드는 수정할 필요가 없다.

클래스 레벨에 @Controller로 어노테이션을 수정하고 다시 테스트를 진행한다. 테스트는 성공적인 결과가 나올 것이고 HTML 코드를 보기 위해서 뷰 결과를 로깅한 결과를 보면 Thymeleaf 뷰 템플릿을 사용하여 만든 뷰가 HTML 코드로 렌더링 될 것을 확인할 수 있다.

@RequestBody Vs. @ModelAndAttribute

앞에서 HTML Form을 보는 URL 요청을 위한 컨트롤과 뷰 템플릿을 추가하였다면 이제는 Form에 저장한 데이터를 POST로 전송할 때 처리하는 메소드를 추가해야한다. 우리는 REST 서비스를 위한 컨트롤러를 만들 때 RequestMethod.POST에 관한 메소드를 구현한 적이 있다. 이 때 코드를 다시 한번 살펴보자.

    @RequestMapping(value = "/api/articles", method = RequestMethod.POST)
    @ResponseBody
    public Article create(@RequestBody Article article) {
        return article;
    }

이 코드를 살펴보면 POST의 요청으로 함께 받는 파라미터는 @RequestBody 를 Article에 매핑하고 있다. 다시 말해서 이 REST URL을 요청할 때 Article에 데이터를 JSON 타입으로 전송하겠다는 의미가 된다. 그래서 우리는 이 컨트롤러 메소드를 다음과 같이 Article 객체를 JSON으로 serialized 하여 테스트를 진행하였다.

    @Test
    public void testCreate() throws Exception {
        Article article = new Article();
        article.setTitle("testing create article");
        article.setContent("test content");

        Comment comment = new Comment();
        comment.setContent("test comment1");
        List<Comment> comments = new ArrayList<>();
        comments.add(comment);

        article.setComments(comments);

        String jsonString = this.jsonStringFromObject(article);

        MvcResult result = mockMvc.perform(post("/api/articles")
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonString))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo(jsonString))).andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

하지만 우리가 웹 페이지에서 FORM에 들어가는 객체를 Submit으로 전송할 때는 @RequestBody 형태로 넘어가지 않는다. @RequestBody의 요청은 Content-Type이 application/json 이지만 HTML 기반의 컨텐츠 타입에서 데이터를 Submit할 때는 Content-Type이 application/x-www-form-urlencoded 방식으로 넘어가기 때문이다. 그래서 우리는 ArticlesController에 다음 메소드를 추가한다. 이 코드는 앞에서 GET으로 FORM 을 요청할 때 HTML 뷰를 렌더링할 때 사용한 Model 안에 들어간 데이터를 POST로 받게 될 때 Model 안의 Attribute에 함께 포함된 Article객체를 받아서 매핑하게 된다. 테스트를 위해서 넘겨 받은 데이터를 결과를 HTML 형태로 보여주게 한 것이 아니라 JSON 타입으로 만들어서 반환하게 했다. 다시말해 HTML 페이지에서 FORM으로 데이터를 Submit하면 결과로 넘겨 받은 데이터를 JSON으로 반환하게 만들었다. 이 때 객체를 넘겨 받는 커텐츠의 Content-Type의 형태는 application/x-www-form-urlencoded 나 multipart/form-data 의 형태가 되어야한다.

    @RequestMapping(value = "/articles", method = RequestMethod.POST)
    @ResponseBody
    public Article submit(@ModelAttribute Article article){
        return article;
    }

추가한 메소드에 관한 테스트를 진행해보자. ArticlesControllerTests 파일에 다음 코드를 추가한다.

    @Test
    public void testSubmit() throws Exception {

        MvcResult result = mockMvc.perform(post("/articles")
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .param("title", "unittest title")
                .param("content", "unittest content"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

테스트 결과는 정상적으로 진행이 될 것이다. 위에서 살펴보면 이전에 @RequestBody를 테스트하기 위해서 객체를 JSON 타입으로 변경한 것과는 달리 .param()을 통해서 Form 파라미터를 추가하는 것을 확인할 수 있다. 또한 post()를 요청할 때 contentType이 APPLICATION_FORM_URLENCODED 인것을 확인할 수 있다. 실제 파라미터 데이터가 ModelAndAttribute로 매핑되는지 확인해보기 위해서 컨트롤러에 브레이크포인트를 걸고 다시 한번 테스트를 진행해보자.

컨트롤러 안에서 RequestMethod.POST 요청이 들어오면 ModelAndAttribute의 데이터를 Article 객체에 매핑되어진 것을 확인할 수 있다.

파일 업로드

Spring 컨트롤러에서 파일 업로드를 위한 예제는 다양하게 존재하는데 대부분 MutipartFile을 컨트롤러의 인자로 받는 예제가 많다. 즉 Model 객체에 존재하는 것이 아니라 객체와 별개로 MUltipartFile을 메소드에서 인자로 받아서 처리하는 것이다. 예를 들면 다음과 같은 코드가 될 것이다.

    @RequestMapping(value = "/articles", method = RequestMethod.POST)
    @ResponseBody
    public Article submit(@ModelAttribute Article article, MultipartFile file){
        return article;
    }

우리는 Model 객체에 실제 객체를 포함을 시켜서 객체 형태의 코드를 관리하고 싶어한다. 예를 들어 Article 안에 파일을 가지고 있다고 말이다. 실제 객체 관점에서는 Article이 파일을 포함하고 있는 것이지 Article 따로 첨부파일 따로는 아니라는 개념이다. 그래서 우리는 Article 객체에 File을 속성을 추가해보자. 만약 Article이 포함하고 있는 Comment에 파일을 가질 수 있다면 Comment 객체 안에도 파일을 추가하면 된다. 또는 여러개의 파일을 가지고 있다면 List<MutlipartFile>을 추가하면 될 것이다. 우리는 JSON 타입의 결과를 받는데 MultipartFile을 JSON으로 serialization 을 할 수 없기 때문에 JSON으로 변경될 때 무시하기 위해서 @JsonIgnore 를 사용하였고 대신 fileName이라는 필드가 file이라는 JSON 프로퍼티로 첨부파일의 이름을 가지고 만들어질 수 있도록 @JsonProperty(“file”)로 추가하였다.

package net.saltfactory.tutorial;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.web.multipart.MultipartFile;

import java.io.Serializable;
import java.util.List;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */

public class Article implements Serializable {
    private long id;
    private String title;
    private String content;
    private List<Comment> comments;

    @JsonIgnore
    private MultipartFile file;

    @JsonProperty("file")
    private String fileName;

    public String getFileName() {
        return this.file.getOriginalFilename();
    }

    public long getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public List<Comment> getComments() {
        return comments;
    }

    public void setComments(List<Comment> comments) {
        this.comments = comments;
    }

    public MultipartFile getFile() {
        return file;
    }

    public void setFile(MultipartFile file) {
        this.file = file;
    }
}

다음은 브라우저에서 첨부파일을 선택할 수 있도록 HTML 코드에 <input type="file"/> 코드를 추가한다. new.html 파일을 열어서 다음 코드를 추가한다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>SpringBootDemo</title>
    <meta charset="utf-8"/>
</head>
<body>
<h1>New Article</h1>

<form action="#" th:action="@{/articles}"
      th:object="${article}"
      method="post" enctype="multipart/form-data">
    <p>title: <input type="text" th:field="*{title}" /></p>
    <p>content:
        <textarea th:field="*{content}"></textarea>
    </p>
    <p>file:
        <input type="file" th:field="*{file}"/>
    </p>

    <input type="submit" value="submit" />
</form>

</body>
</html>

마지막으로 입력 화면으로부터 첨부파일을 추가하고 Submit을 하면 파일을 받는 컨트롤러의 메소드에서 파일을 받을 수 있는지 컨트롤러 테스트를ArticlesControllerTests 파일에서 수정한다. 테스트 코드에서는 브라우저가 없기 때문에 사람이 직접 파일을 선택하여 첨부파일을 하듯 MockMultipartFile로 마치 파일을 첨부하는 것과 동일하게 만들어준다. 이 때 필드 이름이 file이고 파일은 단순히 문자열을 저장한 텍스트 파일로 가짜 파일을 만들었다. 그리고 MockMvc에서 post()로 요청했던 메소드를 fileUpload()로 변경하였다. post() 함수는 Content-Type 요청이 application/x-www-form-urlencoded 요청인데 fileUpload() 함수는 Content-Type 요청이 multipart/form-data 데이터이기 때문이다. 전자는 파라미터 전송은 가능하지만 파일 업로드를 할 수 없기 때문에 테스트를 진행할 때는 fileUpload() 함수를 사용해야한다. 나머지는 post() 메소드와 동일하게 param() 함수로 폼에 들어가는 파라미터를 추가한다. 이때 Model에 포함된 Article의 필드이름과 동일하게 입력해야한다.

  @Test
    public void testSubmit() throws Exception {

        MockMultipartFile file = new MockMultipartFile("file", "filename.txt", "text/plain", "some xml".getBytes());

        MvcResult result = mockMvc.perform(
                fileUpload("/articles").file(file)
                .param("title", "unittest title")
                .param("content", "unittest content"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

실제 파일이 전송이 되어 컨트롤러에 들어가는지 확인하기 위해서 컨트롤러 메소드에 브레이크포인트를 걸어서 확인해보자. 테스트를 진행해서 브레이크포인트를 살펴보면 다음과 같이 파일이 컨트롤러에 저장되는 것을 확인할 수 있다.

이제 FORM을 처리하기 위한 컨트롤러, 뷰 템플릿, 단위 테스트 코드가 모두 작성되고 테스트 되었다.

서버 실행

이제 서버를 직접 실행하여 브라우저에서 정상적으로 동작하는지 확인해보자. Gradle Projects 패널에서 bootRun을 실행한다. IntelliJ가 이니라면 터미널에서 다음과 같이 실행하면 된다

gradle bootRun

브라우저를 열어서 http://localhost:8080/articles/new 로 접근해보자

Form이 나타나면 입력 폼에 내용을 입력하고 첨부파일도 추가가 한 후, submit을 해보자. 결과는 정상적으로 Article 객체에 포함되어 컨트롤러에 도착하여 JSON으로 결과가 반환된 것을 확인할 수 있다.

결론

Spring은 점점 발전하여 이제 Spring Boot를 사용하면 빠르고 쉽게 REST 서비스를 만들 수 있다. 하지만 Form 입력이나 파일 업로드를 지원하기 위해서는 기존의 Spring에서 Model을 사용하여 객체에 입력한 데이터를 전송 받을 수 있어야한다. 우리는 기존의 REST 서비스를 위해서 만든 컨트롤러에 파일 업로드를 포함한 FORM 서비스를 위한 코드를 작성하고 FORM을 위한 컨트롤러와 파일 업로드를 할 때 단위 테스트를 어떻게 하는지 살펴보았다.

다음 포스팅에서는 RestTemplate을 사용하여 컨트롤러에 REST과 FORM 요청을 어떻게 하는지 살펴볼 예정이다.

소스코드

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-form/SpringBootDemo

참고

http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html
http://docs.spring.io/spring-test-htmlunit/docs/current/reference/html5/
https://youtrack.jetbrains.com/issue/IDEA-132738
https://www.genuitec.com/spring-frameworkrestcontroller-vs-controller/
http://stackoverflow.com/questions/16648549/converting-file-to-multipartfile
http://gaabbe.win/issue/4848552/multipart-file-upload-spring-boot
https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html
https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/stereotype/Controller.html

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Spring에서 YAML 파일 데이터 객체에 매핑하여 로드하기

Mon, 23 Nov 2015 00:00:00 +0000

서론

Spring 프로젝트를 진행할 때 외부에서 데이터를 로드할 경우가 종종 있다. 가장 쉽게는 Spring Boot에서 사용하는 Configuration Porperty를 로드하는 것이다. Spring Boot는 기본적으로 application.properties 파일을 추가하면 자동으로 Common application properteis 로드하여 프로퍼티 값을 적용할 수 있다. 하지만 자바의 Properties 의 파일의 사용에는 표현의 한계가 있기 때문에 최근에는 Properties를 YAML을 많이 사용하고 있다. Spring Boot에서는 SnakeYAML을 포함하고 있어서 쉽게 외부 파일을 YAML으로 작성하여 쉽게 로드하여 객체로 매핑할 수 있다. 이번 포스팅에서는 Spring Boot에서 YAML로 작성한 파일을 객체로 매핑하여 사용하는 방법을 소개한다.

테스트를 위한 데이터 YAML 파일로 만들기

테스트를 위해 간단한 데이터가 필요하다. 이 때 처음부터 JPA와 같이 ORM을 가지고 데이터를 만들어서 사용하려면 꽤 여러가지 일을 해야한다. 우리는 테스트를 위한 파일을 쉽게 가져올 수 있게하기 위해서 YAML 파일을 사용하기로 한다. Spring Boot는 application.properties 이나 application.yml 파일에 필요한 설정을 정의하면 어플리케이션에서 자동으로 읽어들일 수 있다. Spring Boot 프로젝트를 생성하면 src/main/resources/application.properties 라는 어플리케이션 프로퍼티 파일이 만들어 진다. Spring에서 복잡한 XML 설정을 Spring Boot에서는 이 파일 안에서 간단하게 설정하여 어플리케이션에 적용할 수 있다. http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html 자세한 사항은 링크를 참조하면 된다.

Spring Boot에서는 Snake YAML 라이브러리를 내장하고 있다. 이런 이유로 Spring Boot에서는 YAML 파일을 로드하여 사용할 수 있다. http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-external-config-yaml (링크를 참조). 뿐만아니라 src/main/resources/application.yml 파일에 설정을 정의하면 application.properties와 같이 Spring Boot에서 자동으로 읽어와 필요한 곳에 매핑된다.

YAML 파일은 .properties 파일과 달리 계층과 배열 구조의 데이터를 쉽게 만들 수 있고 이것을 Map, List 또는 Bean에 쉽게 편리하게 매핑할 수 있다. Ruby on Rails에서는 이미 오래전부터 YAML 파일을 사용하여 데이터베이스나 시스템 설정 파일로 사용해 왔다. YAML은 JSON과 비슷하지만 표현법이 더 간단하여 인기있기 사용되고 있다.

우리는 테스트를 위한 데모 데이터세트를 Spring Boot가 환경 설정을 읽어오는 것과 유사하게 로드하게 할 것이다. 먼저 데모 데이터를 src/main/resources/fixtures.yml 에 저장한다.

fixtures:
  articles:
    -
      id: 1
      title: title1
      content: content1
    -
      id: 2
      title: title2
      content: content2
    -
      id: 3
      title: title3
      content: content3

YAML 파일을 Map으로 매핑하기

먼저 YAML 파일을 로드하기 위해서는 외부에서 Configuration을 로드 하기 위해 Externalized Configuration (글을 참조) 설정을 해야한다. 간단하게 다시 말하자면 YAML 파일을 Spring 어플리케이션어 로드하기 위한 컴포넌트가 필요하다. 우리는 fixtures.yml 파일을 Configuration Property 파일 형태로 로드하기 위해서 src/main/java/{패캐지명}/FixturesProperty.java 파일을 만든다. 여기서 주의할 점은 앞에서 만든 fixtures.yml 파일을 로드하기 위해서 classpath 위치를 지정하는데 SpringBoot는 기본적으로 src/main/resources/ 디렉토리를 클래스 패스로 가지고 있기 때문에 아래와 같이 지정한다. 그리고 fixtures.yml 파일 안에 articles는 fixtures 라는 Key의 List value로 만들어 놓았기 때문에 YAML 파일을 읽어들일 때 prefix로 fixtures를 정의하여 이 키 값 안의 데이터를 로드하게 한다. 그리고 우리가 만든 fixtures.yml 파일은 article 내용이 YAML의 배열로 작성했기 때문에 나중에 List<Map>로 매핑될 것이다. 외부 프로퍼티 파일(.propertis 나 .yml)을 Injection 로드하기 위해서는 Spring의 컴포넌트가 되어야하기 때문에 @Component 어노테이션을 추가하고 프로퍼티 파일을 로드하기 위한 클래스라는 것을 정의하기 위해서 @ConfigurationProperties 어노테이션을 추가한다.

package net.saltfactory.tutorial;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.stereotype.Component;

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

/**
 * Filename : FixturesProperty.java
 * Author   : saltfactory<saltfactory@gmail.com>
 * Created  : 11/23/15.
 */
@Component
@ConfigurationProperties(locations = {"fixtures.yml"}, prefix = "fixtures")
public class FixturesProperty {
    @NestedConfigurationProperty
    private List<Map> articles = new ArrayList<>();

    public List<Map> getArticles() {
        return articles;
    }
}

스크린샷과 같이 Spring Boot Configuration Annoation Processor를 찾을 수 없다는 에러가 나타나면 다음과 build.gradle 파일을 열어서 다음 내용을 추가한다. 원래 Spring Boot에서 외부 프로퍼티 파일을 로드하기 위해서는 메타 정보를 파일로 만들어서 추가해야는데 propdes-plugin을 사용하면 메타 파일을 추가하지 않고 자동으로 적용할 수 있다. http://docs.spring.io/spring-boot/docs/1.3.0.RELEASE/reference/html/configuration-metadata.html#configuration-metadata-annotation-processor (글을 참조)

프로젝트 안의 build.gradle 파일을 열어서 다음과 같이 수정하고 gradle.properties 파일을 적용한다.(IntelliJ에서는 이 파일을 수정하고 Gradle projects 패널에서 새로고침 버튼을 누르면 의존성 있는 라이브러리를 자동으로 다운 받게 된다)

buildscript {
    ext {
        springBootVersion = '1.3.0.RELEASE'
    }
    repositories {
        mavenCentral()
        maven { url 'http://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'propdeps'
apply plugin: 'spring-boot'
apply plugin: 'propdeps-idea'

jar {
    baseName = 'spring-boot-demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-web')
    optional("org.springframework.boot:spring-boot-configuration-processor")

    testCompile('org.springframework.boot:spring-boot-starter-test')
}

compileJava.dependsOn(processResources)


eclipse {
    classpath {
         containers.remove('org.eclipse.jdt.launching.JRE_CONTAINER')
         containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

이제 외부 프로퍼티 파일을 로드하기 위한 설정을 모두 마쳤다. 우리가 만든 fixtures.yml 파일을 FixturesProperty 클래스가 잘 로드하는지 확인하기 위해서 Test 파일을 만들어보자. src/test/java/{패키지경로}/FixturesPropertyTest.java. 앞에서 FixtureProperty는 Spring의 @Component로 만들었기 때문에 스캐닝되고 @ConfigurationProperty 때문에 YAML 파일을 오브젝트에 매핑되어 반환하게 될 것이다. 우리는 fixtures.yml에 3개의 아이템을 리스트로 만들었기 때문에 테스트에서 리스트의 사이즈를 3이 맞는지 테스트를 진행하였다.

package net.saltfactory.tutorial;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.Map;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;

/**
 * filename : FixturespropertyTest.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class FixturesPropertyTest {
    @Autowired
    private FixturesProperty fixturesProperty;

    @Test
    public void testGetArticles() {
        List<Map> articles = fixturesProperty.getArticles();
        assertThat(articles.size(), is(3));
    }

}

테스트 파일을 만들었으면 단위 테스트를 실행해보자.

YAML 파일을 POJO로 매핑하기

위에 yaml로 만든 외부 파일을 Map으로 매핑을 할 수 있는 것을 살펴보았다. Spring 프로젝트에서는 데이터를 저장하는 객체를 POJO로 만들어서 setter/getter를 한다. YAML의 데이터를 POJO 객체로 바로 매핑하는 방법을 살펴보자. 우선 Article 객체를 fixtures.yml 파일에 정의한 key 값과 동일한 이름으로 field와 setter/getter를 만든다.

package net.saltfactory.tutorial;

import java.io.Serializable;

/**
 * filename : Article.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
public class Article implements Serializable {
    private long id;
    private String title;
    private String content;

    public long getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

앞에서 외부 Configuration Property를 로드하기 위한 FixturesProperty를 열어서 로드할 타입을 Map에서 Article로 변경한다.

package net.saltfactory.tutorial;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.stereotype.Component;

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

/**
 * Filename : FixturesProperty.java
 * Author   : saltfactory<saltfactory@gmail.com>
 * Created  : 11/23/15.
 */
@Component
@ConfigurationProperties(locations = {"fixtures.yml"}, prefix = "fixtures")
public class FixturesProperty {
    private List<Article> articles = new ArrayList<>();

    public List<Article> getArticles() {
        return articles;
    }
}

테스트를 위한 FixturesPropertyTest 파일을 수정하고 브레이크포인트를 걸어서 확인해보자.

package net.saltfactory.tutorial;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;

/**
 * filename : FixturespropertyTest.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class FixturesPropertyTest {
    @Autowired
    private FixturesProperty fixturesProperty;

    @Test
    public void testGetArticles() {
        List<Article> articles = fixturesProperty.getArticles();
        assertThat(articles.size(), is(3));
    }

}

테스트의 브레이크 포인트를 확인하면 fixtureProperty.getArticles() 에서 YAML 파일에서 로드된 데이터가 Article의 객체로 매핑되어 로드된 것을 확인할 수 있다.

계층 구조의 YAML 파일을 POJO로 매핑하기

YAML의 장점은 계층 구조의 데이터를 잘 표현할 수 있는 것이다. properties 파일은 계층 구조를 표현하기 위해서 좀 더 복잡한 방법을 사용해야하지만 YAML을 사용하면 들여쓰기 기준으로 계층 구조를 쉽게 표현할 수 있다. 또한 계층 구조로 된 POJO로 데이터를 로드하여 사용할 수 있다. 만약 Article 안에 Comment를 리스트로 가지고 있는 구조가 있다고 가정해보자. fixtures.yml 파일을 다음과 같이 수정한다.

fixtures:
  articles:
    -
      id: 1
      title: title1
      content: content1
      comments:
        -
          id: 10
          articleId: 1
          content: comment11
        -
          id: 11
          articleId: 1
          content: comment12
    -
      id: 2
      title: title2
      content: content2
      comments:
        - id: 20
          articleId: 2
          content: comment21
        - id: 21
          articleId: 2
          content: comment22
    -
      id: 3
      title: title3
      content: content3
      comments:
        - id: 30
          articleId: 3
          content: comment31
        - id: 31
          articleId: 3
          content: comment32

그리고 Comment가 매핑될 객체를 만든다.

package net.saltfactory.tutorial;

import java.io.Serializable;

/**
 * filename : Comment.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
public class Comment implements Serializable {
    private long id;
    private String content;
    private long articleId;

    public long getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public long getArticleId() {
        return articleId;
    }

    public void setArticleId(long articleId) {
        this.articleId = articleId;
    }
}

그리고 Article 안에 Comment 리스트를 추가한다.

package net.saltfactory.tutorial;

import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.List;

/**
 * filename : Article.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
public class Article implements Serializable {
    private long id;
    private String title;
    private String content;
    private List<Comment> comments;

    public long getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public List<Comment> getComments() {
        return comments;
    }

    public void setComments(List<Comment> comments) {
        this.comments = comments;
    }
}

단위 테스트를 다음과 같이 수정하자.

package net.saltfactory.tutorial;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;

/**
 * filename : FixturespropertyTest.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class FixturesPropertyTest {
    @Autowired
    private FixturesProperty fixturesProperty;

    @Test
    public void testGetArticles() {
        List<Article> articles = fixturesProperty.getArticles();
        assertThat(articles.size(), is(3));
    }

    @Test
    public void testGetCommentsByArticle() {
        List<Article> articles = fixturesProperty.getArticles();
        Article article = articles.get(0);
        List<Comment> comments = article.getComments();
        assertThat(comments.size(), is(2));
    }
}

단위 테스트를 실행시켜서 Article 객체 안에 Comment가 정상적으로 로드 되었는지 확인해보자.

브레이크 포인트를 확인해보면 Article 객체 안에 Comment가 리스트로 정상적으로 로드된 것을 확인할 수 있다.

결론

최신 Spring은 좀더 계층구조를 표현하기 쉽고 사람이 읽기 쉬운 YAML 파일을 로드할 수 있는 기능을 포함하였다. Spring Boot에서는 Spring 어플리케이션의 설정을 src/main/resources/application.properties에서 정의하면 자동으로 어플리케이션에 적용이되는데 YAML 파일을 사용하여 application.yml 파일을 만들어도 자동으로 적용을 할 수 있다. SnakeYAML 라이브러리를 포함하고 있는 Spring Boot에서는 YAML 파일을 읽어들어 Map이나 POJO에 바로 매핑하여 데이터를 로드할 수 있다. 더구나 @ConfigurationProperties를 사용하면 Spring 어플리케이션에서 YAML 파일을 Configuration Property 파일로 인식하여 특별한 자바 코드 없이도 Spring annotation 만으로도 외부의 YAML 파일을 로드할 수 있다. 만약 데이터베이스가 없는 데모 어플리케이션을 만들거나 테스트를 위한 간단한 데이터를 외부 파일에서 조작하기 위해서 YAML 파일을 사용하여 데이터를 정의하여 사용하면 매우 간단하게 처리할 수 있다.

소스코드

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-yaml/SpringBootDemo

참조

https://bitbucket.org/asomov/snakeyaml
http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html
https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

Spring에서 REST 서비스를 위한 컨트롤러 생성과 컨트롤러 단위테스트 하기

Mon, 23 Nov 2015 00:00:00 +0000

서론

Spring Boot는 Spring의 복잡한 설정을 고려하지 않고 곧바로 stand-alone Spring 어플리케이션을 개발 할 수 있도록 해준다. 복잡한 Spring 설정의 비용을 들이지 않고도 Spring 기반으로 Ruby on Rails 나 Express.js 와 같이 빠르게 REST 서비스를 만들수 있다. 이번 포스팅에서는 복잡한 설정 없이 곧바로 Spring 기반의 기본적인 REST컨트롤러를 생성하고 REST 컨트롤러를 단위테스트하는 방법을 소개한다.

IntelliJ에서 Spring Boot 프로젝트 생성하기

아마 앞으로도 Java 프로젝트를 설명할 때 IntelliJ 소개를 계속 할 것이다. IntelliJ는 Spring 개발에 훌륭한 도구이기 때문에 반드시 사용해보길 추천한다. 앞에서 IntelliJ 기반의 Spring Boot 웹 프로젝트 생성하기를 참조하여 Spring Boot 프로젝트를 생성한다. 최신 Gradle과 Java를 사용하기 위해서는 IntelliJ에서 Java와 Gradle 버전 설정하기 글을 참조하면 된다.

IntelliJ에서 SpringBoot 프로젝트를 만들어보자. 우리는 Java 8 기준으로 프로젝트를 만들 것이다. 이 포스트를 작성할 때 가장 최근 버전은 1.8.0_66 이였다.

프로젝트는 다음 설정으로 만든다.

Name : SpringBootDemo
Type : Gradle Project
Packaging : Jar
Java Version : 1.8
Language : Java
Group : net.saltfactory.tutorial
Artifact : spring-boot-demo
Version : 0.0.1-SNAPSHOT
Description : Demo project for Spring Boot
package : net.saltfactory.tutorial

Spring Boot 버전은 가장 최신 안저화 버전인 1.3.0을 선택하고 REST 서비스를 만들기 위해서 web을 체크한다.

다음은 Project가 저장될 경로를 지정한다.

다음은 Gradle 기반의 프로젝트를 선택하였기 때문에 Gradle을 설정하는 화면이 나온다. 가장 최신 Gradle과 Gravle JVM을 설정한다.

모든 설정이 끝나면 다음과 같은 구조로 Spring Boot 프로젝트가 만들어진다.

Spring Boot 프로젝트의 베이스 파일은 github에서 참조할 수 있다.

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-base/SpringBootDemo

테스트를 위한 데이터 YAML 파일 만들기

우리는 Spring에서 YAML 파일 데이터 객체에 매핑하여 로드하기 글에서 Spring에서 YAML 파일에 데이터를 정의하고 객체에 매핑하여 로드하는 방법을 살펴보았다. src/resources/fixtures.yml 파일을 다음 내용으로 생성한다.

fixtures:
  articles:
    - id: 1
      title: title1
      content: content1
      comments:
        -
          id: 10
          articleId: 1
          content: comment11
        -
          id: 11
          articleId: 1
          content: comment12
    - id: 2
      title: title2
      content: content2
      comments:
        - id: 20
          articleId: 2
          content: comment21
        - id: 21
          articleId: 2
          content: comment22
    - id: 3
      title: title3
      content: content3
      comments:
        - id: 30
          articleId: 3
          content: comment31
        - id: 31
          articleId: 3
          content: comment32

다음은 Comment와 Article 파일을 각각 생성한다.

package net.saltfactory.tutorial;

import java.io.Serializable;

/**
 * filename : Comment.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
public class Comment implements Serializable {
    private long id;
    private String content;
    private long articleId;

    public long getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public long getArticleId() {
        return articleId;
    }

    public void setArticleId(long articleId) {
        this.articleId = articleId;
    }
}

package net.saltfactory.tutorial;

import java.io.Serializable;
import java.util.List;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */

public class Article implements Serializable {
    private long id;
    private String title;
    private String content;
    private List<Comment> comments;


    public long getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public List<Comment> getComments() {
        return comments;
    }

    public void setComments(List<Comment> comments) {
        this.comments = comments;
    }
}

YAML 파일을 Article의 리스트로 로드할 FixtureProperty 클래스를 생성한다.

package net.saltfactory.tutorial;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.stereotype.Component;

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

/**
 * Filename : FixturesProperty.java
 * Author   : saltfactory<saltfactory@gmail.com>
 * Created  : 11/23/15.
 */
@Component
@ConfigurationProperties(locations = {"fixtures.yml"}, prefix = "fixtures")
public class FixturesProperty {
    private List<Article> articles = new ArrayList<>();

    public List<Article> getArticles() {
        return articles;
    }
}

FixturesProperty 클래스가 fixtures.yml 파일을 잘 로드하는지 테스트 파일을 만들어서 확인해보자.

package net.saltfactory.tutorial;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;

/**
 * filename : FixutresPropertyTest.java
 * author   : saltfactory<saltfactory@gmail.com>
 * created  : 11/23/15
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class FixutresPropertyTest {
    @Autowired
    private FixturesProperty fixturesProperty;

    @Test
    public void testGetArticles() {
        List<Article> articles = fixturesProperty.getArticles();
        assertThat(articles.size(), is(3));
    }

    @Test
    public void testGetCommentsByArticle() {
        List<Article> articles = fixturesProperty.getArticles();
        Article article = articles.get(0);
        List<Comment> comments = article.getComments();
        assertThat(comments.size(), is(2));
    }
}

@Service 객체 만들기

우리는 간단한 REST 컨트롤러가 데이터를 처리하는 ArticlesService 객체를 만들 것이다. 실제 서비스되는 어플리케이션에서는 이 객체가 Repsitory와 서로 연관되어 많은 처리를 담당하겠지만 데모를 위한 이 객체는 FixturesProperty에서 가져온 Articles의 리스트를 복사여 목록을 반환하거나 삭제하는 기능만 추가하였다. getArticle()과 deleteArticle() 메소드 안에 리스트를 탐색하여 처리하는 작업은 Java 8의 lamda 표현식을 사용하여 구현하였다.

package net.saltfactory.tutorial;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@Service
public class ArticlesService {
    @Autowired
    FixturesProperty fixturesProperty;

    public List<Article> getArticles() {
        List<Article> articles = new ArrayList<>(fixturesProperty.getArticles());
        return articles;
    }

    public Article getArticle(long id) {
        List<Article> articles = this.getArticles();
        Article article = articles.stream()
                .filter(a -> a.getId() == id)
                .collect(Collectors.toList()).get(0);
        return article;
    }

    public List<Article> deleteArticle(long id) {
        List<Article> articles = this.getArticles();
        articles.removeIf(p -> p.getId() == id);
        return articles;
    }
}

ArticlesService 객체를 만들고 난 뒤 데이터를 바로 처리하는지 테스트 클래스를 만들어서 확인해보자.

package net.saltfactory.tutorial;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class ArticlesServiceTest {

    @Autowired
    ArticlesService articlesService;

    @Autowired
    FixturesProperty fixturesProperty;

    @Before
    public void setUp() throws Exception {

    }

    @Test
    public void testGetArticles() throws Exception {
        List<Article> articles = articlesService.getArticles();
        assertThat(articles, is(notNullValue()));
        assertThat(articles.size(), is(3));
    }

    @Test
    public void testGetArticle() throws Exception{
        long id = 1;
        Article article = articlesService.getArticle(id);

        List<Article> articles = fixturesProperty.getArticles();
        Article demoArticle = articles.stream()
                .filter(a -> a.getId() == id)
                .collect(Collectors.toList()).get(0);

        assertThat(article.getId(), is(equalTo(demoArticle.getId())));
    }

    @Test
    public void testDeleteArticle() throws Exception {
        long id = 1;
        List<Article> demoArticles = new ArrayList<>(fixturesProperty.getArticles());
        List<Article> articles = articlesService.deleteArticle(id);
        assertThat(articles.size(), not(demoArticles.size()));
    }
}

테스트를 실행하면 ArticlesService의 메소드들이 모두 정상적으로 처리를 하고 있는 것을 확인할 수 있다.

REST 서비스를 위한 Controller 생성

이제 가장 중요한 Controller를 생성해보자. REST 서비스는 URL에서 리소스를 표현하면서도 기능을 처리하도록 하는 것이 중요하다.

우리는 REST 서비스 형태의 URL을 다음과 같이 정의한다.

메소드	URL 패턴	설명
GET	/api/articles/	Articles 전체 목록을 표현
GET	/api/articles/{id}	id 값을 가지는 Article을 표현
POST	/api/articles	새로운 Article을 저장
PATCH/PUT	/api/articles/{id}	id 값을 가지는 Article을 업데이트
DELETE	/api/articles/{id}	id 값을 가지는 Article을 삭제

GET /api/articles

글 목록을 가져오는 /api/articles를 처리하기 위한 메소드를 추한다. 아무런 URL 없이 단순히 /api/articles 요청을 처리하기 위해서 index()라는 메소드로 이름 붙였다. Ruby on Rails에서 REST URL이 컨트롤러의 액션(메소드) 이름을로 만들어지는 것과 달리 @RequestMapping으로 메소드 이름과 달리 URL이 들어오는 패턴을 메소드와 매핑 시킨다. @ResponseBody는 컨트롤러에서 데이터를 응답을 줄 때 객체를 HttpMessageConverter를 사용하여 ResponseBody에 자동으로 JSON 형태의 컨텐츠로 변환하여 반환한다. 예전 Spring에서는 객체를 직접 JSON으로 serialization을 해서 반환하였지만 이제 프레임워크 레벨에서 자동으로 처리할 수 있게 된 것이다. 우리는 단지 객체를 리턴하기만하면 클라이언트에서 JSON 으로 받을 수 있다.

package net.saltfactory.tutorial;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@RestController
public class ArticlesController {
    @Autowired
    ArticlesService articlesService;

    @RequestMapping(value = "/api/articles", method = RequestMethod.GET)
    @ResponseBody
    public List<Article> index() {
        return articlesService.getArticles();
    }
}

컨트롤러를 테스트하는 테스트 클래스를 만들어서 테스트를 해보자. Spring에서 다른 테스트와 달리 컨트롤러 테스트는 몇가지 설정을 해야한다. 컨트롤러는 사용자의 HTTP request를 처리하고 HTTP response를 반환하는 객체이기 때문에 이를 테스트하기 위해서는 웹 서버가 동작해야하고 요청과 반환을 담당하는 HttpServletRequest/HttpServletResspone 를 직접 구현해야한다. 실제 이전 Spring 프레임워크에서 Mock 서버를 동작해서 복잡한 코드를 추가해서 컨트롤러를 테스트를 했었던 기억이 난다. 하지만 이젠 그렇게 복잡하던 컨트롤러 테스트가 매우 간단해졌다. MockMvc를 사용하면 아주 간단하게 URL요청을 GET,POST,PUT,PATCH,DELETE와 같은 REST 형태로 요청을 테스트할 수 있다. 자세한 내용을 Unit Testing 글을 참조한다.

package net.saltfactory.tutorial;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import java.util.List;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;

/**
 * Created by saltfactory<saltfactory@gmail.com> on 11/21/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootDemoApplication.class)
public class ArticlesControllerTest {

    Logger logger = Logger.getLogger(this.getClass());

    private MockMvc mockMvc;

    @Autowired
    private ArticlesController articlesController;

    @Autowired
    private ArticlesService articlesService;

    @Before
    public void setUp() throws Exception {
        mockMvc = standaloneSetup(articlesController).build();
    }

    private String jsonStringFromObject(Object object) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }

    @Test
    public void testIndex() throws Exception {
        List<Article> articles = articlesService.getArticles();
        String jsonString = this.jsonStringFromObject(articles);

        mockMvc.perform(get("/api/articles"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andExpect(content().string(equalTo(jsonString)));
    }
}

위 테스트를 진행하면 마치 Spring 어플리케이션에 /api/articles Http 요청을 한 것과 동일한 테스트를 진행하게 된다. 만약 정상적으로 컨트롤러가 요청을 받아서 처리하고 다시 Http 응답을 돌려준다면 status().isOk()가 나올 것이다. 또한 response의 컨텐트 타입은 컨트롤러에서 @ResponseBody를 사용하여 만들어진 리턴객체를 포함하고 있기 때문에 JSON 타입으로 응답이 온다. 컨텐츠 내용을 확인할 때는 JSON 문자열로 결과가 올 것이기 때문에 JSON Mapper를 사용하여 객체를 JSON 문자열로 만들어서 response의 컨텐츠 문자열과 비교한다.

만약 response의 문자열을 로깅하고 싶을 경우는 MvcResult를 사용하여 로깅을 할 수 있다.

    @Test
    public void testIndex() throws Exception {
        List<Article> articles = articlesService.getArticles();
        String jsonString = this.jsonStringFromObject(articles);

        MvcResult result = mockMvc.perform(get("/api/articles"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andExpect(content().string(equalTo(jsonString)))
                .andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

테스트를 실행하면 결과로 컨트롤러로 부터 받은 response의 content 의 JSON 문자열을 로깅으로 확인할 수 있다.

GET /api/articles/{id}

REST 서비스에서 리소스의 단일 정보를 표현하는 URL 패턴으로 리소스 뒤에 {id}를 가지고 처리하는 패턴을 사용한다. ArticlesController에서 다음 메소드를 추가한다. 위에서 /api/articles 요청을 처리하기 위한 index() 메소드와 거의 동일하다. 실제 서비스에서는 메소드 내 복잡한 로직이 서로 다르겠지만 Http Request를 받아들이고 결과를 @ResponseBody로 리턴하는 것은 동일하다. 한가지 다른 것은 하나의 리소스의 아이템을 지정하기 위해서 @PathVariable을 인자값으로 받아 들이고 있다는 것이다. 이것은 URL 패턴에 정의한 {id} 인터폴레이션의 값을 URL의 변수로 판단하여 지정한 타입으로 매핑하는 것이다.

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.GET)
    @ResponseBody
    public Article show(@PathVariable(value = "id") long id) {
        return articlesService.getArticle(id);
    }

테스트 컨트롤러에 testShow() 메소드를 추가하여 테스트를 진행해보자. 우리는 테스트를 위해 fixtures.yml 파일에 준비한 데이터 중에서 id 값이 1인 Article을 조회하는 요청을 테스트로 진행한다.

    @Test
    public void testShow() throws Exception {
        long id = 1;
        Article article = articlesService.getArticle(id);
        String jsonString = this.jsonStringFromObject(article);

        mockMvc.perform(get("/api/articles/{id}", id))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
                .andExpect(content().string(equalTo(jsonString)));
    }

테스트를 실행 후 결과를 살펴보면 녹색으로 정상적으로 처리된 것을 확인할 수 있다. 필요에 따라서 로깅을 하여 응답 결과를 로깅으로 확인할 수도 있다.

POST /api/articles

REST에서 POST 메소드를 지원하는 것은 대부분 write 기능을 서비스하는 것이다. 여기에는 중요한 보안 이슈가 있기 때문에 OAuth2와 같은 인증을 같이 처리하는 것이 좋다. 하지만 이 글에서는 단순하게 새로운 Article의 내용을 POST로 전송하여 서버에 정상적으로 전송이 되는 것만을 확인한다. POST로 받은 객체를 POJO에 매팽하고 그것을 다시 @ResponseBody로 응답해주는 간단한 코드이다. 이후에 인증을 처리하는 것을 다시 소개할 예정이다. ArticlesController에 다음 메소드를 추가한다. 앞에서 추가한 메소드와 달리 이 메소드는 RequestMethod.POST를 매핑하고 있다. 앞에서 index() 메소드와 URL 패턴을 동일하지만 RequestMethod.GET과 RequestMethod.POST의 차이로 기능을 다르게 처리할 수 있다. 이런 부분이 바로 REST 서비스의 특징이다. 한가지 주의해서 볼 것은 @ReqestBody라는 것이다. API를 살펴보면 @RequestBody는 @ResponseBody와 동일한 형태의 어노테이션을 가지고 있고 HttpMessageConverter 를 사용하여 JSON을 처리한다. 즉, 클라이언트에서 이 REST URL로 Article을 저장하기 위해서 새로운 Article을 전송할 때 Http Request의 Body에 JSON 타입으로 데이터가 넘어오게 되는 것이고, 컨트롤러에서 @RequestBody를 사용하여 JSON을 객체로 매핑하게 되는 것이다.

    @RequestMapping(value = "/api/articles", method = RequestMethod.POST)
    @ResponseBody
    public Article create(@RequestBody Article article) {
        return article;
    }

POST를 처리하기 위한 컨트롤르를 테스트하기 위해서 다음과 같이 ArticlesControllerTest에 testCreate() 메소드를 추가한다. 새로운 Article을 서버로 POST로 요청하는 것이다. 이 때 Comment리스트 구조를 초함하고 있는 Article 의 데이터가 서버로 바르게 전송되는지 테스트를 하기 위해서 새로운 Article에 새로운 Comment를 포함한 List를 추가하한다.

    @Test
    public void testCreate() throws Exception {
        Article article = new Article();
        article.setTitle("testing create article");
        article.setContent("test content");

        Comment comment = new Comment();
        comment.setContent("test comment1");
        List<Comment> comments = new ArrayList<>();
        comments.add(comment);

        article.setComments(comments);

        String jsonString = this.jsonStringFromObject(article);

        MvcResult result = mockMvc.perform(post("/api/articles")
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonString))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo(jsonString))).andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

JSON 타입으로 데이터를 POST로 REST 요청을 할 때 서버에 제대로 전송이 되어 지정한 Article 타입에 매핑되는지 확인하기 위해서 컨트롤러에서 브레이크 포인트를 지정하여 요청 중 클래스 내부를 살펴보자.

컨트롤러에서 JSON 타입의 Http Request가 요청이 들어올 대 @RequestBody를 사용하여 객체로 바로 매핑을 되는 것을 확인할 수 있다.

PATCH /api/articles/{id}

이전에는 REST 서비스에서 리소스 업데이트 요청을 하기 위해서 PUT 메소드를 사용하였는데, 최근에는 부분 업데이트 개념으로 PATCH를 많이 사용한다. PUT은 전체 리소스를 변경할 때 사용하는 것이고 PATCH는 부분 변경을 사용할 때 사용( https://restful-api-design.readthedocs.org/en/latest/methods.html#patch-vs-put )한다고 정의하지만 PATCH가 PUT을 포함하고 있기 때문에 Ruby on Rails에서도 정식으로 PATCH를 사용하여 업데이트가 이루어지고 있고, Spring에서도 RequestMethod.Patch를 사용하여 REST 요청을 받을 수 있다. ArticlesController에 PATCH와 PUT의 요청을 처리하는 메소드를 다음과 같이 추가한다. 두 메소드 모두 해당하는 Article id를 @PathVariable로 URL에서 받아오며 @RequestBody로 JSON 형태로 업데이트된 내용을 객체로 매핑하게 된다.

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.PATCH)
    @ResponseBody
    public Article patch(@PathVariable(value = "id") long id,  @RequestBody Article article) {
        return article;
    }

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.PUT)
    @ResponseBody
    public Article update(@PathVariable(value = "id") long id,  @RequestBody Article article) {
        return article;
    }

테스트를 위해 ArticlesControllerTest에 테스트 메소드를 추가한다.

    @Test
    public void testPatch() throws Exception {
        long id = 1;
        Article article = articlesService.getArticle(id);
        article.setTitle("testing create article");
        article.setContent("test content");

        String jsonString = this.jsonStringFromObject(article);

        MvcResult result = mockMvc.perform(patch("/api/articles/{id}", id)
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonString))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo(jsonString))).andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

    @Test
    public void testUpdate() throws Exception {
        long id = 1;
        Article article = articlesService.getArticle(id);
        article.setTitle("testing create article");
        article.setContent("test content");

        String jsonString = this.jsonStringFromObject(article);

        MvcResult result = mockMvc.perform(put("/api/articles/{id}", id)
                .contentType(MediaType.APPLICATION_JSON)
                .content(jsonString))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo(jsonString))).andReturn();

        logger.info(result.getResponse().getContentAsString());
    }

테스트를 진행할 때 ArticlesController의 patch() 메소드 안에 브레이크 포인트를 추가하여 PATCH 요청을 처리할 때의 객체를 탐색해보기로 한다. 테스트를 위해서 Article id가 1인 객체를 JSON body로 Patch 요청을 하였고 컨트롤러에서 @RequestBody로 요청한 JSON을 해당 객체로 매핑한 것을 살펴볼 수 있다.

우리는 테스트에서 Http Request를 요청할 때 REST 요청으로 PATCH 를 정상적으로 요청했는지 살펴보기 위해서 컨트롤의 브레이크포인트 시점에서 클래스 내부를 좀 더 탐색하기로 한다. NativeMethodAccessoryImpl에서 HTTP Request PATCH의 요청을 Spring 내부에서 “method”를 “patch”로 매핑한 것을 살펴볼 수 있다.

PUT에 관련된 테스트를 진행하여도 동일하게 처리되는 것을 확인할 수 있을 것이다.

DELETE /api/articles/{id}

REST에서 DELETE의 요청은 해당하는 리소스를 삭제하는 요청이다. ArticlesController에 RequestMethod.DELETE 요청을 처리하기 위한 메소드를 추가한다. 예제는 간단하다. 해당하는 id를 가지고 articlesService.deleteArticle() 메소드를 통해 리스트에서 해당 Article을 삭제하고 나머지 List를 다시 @ResponseBody를 통해 JSON으로 결과를 반환하는 내용을 포함하고 있다.

    @RequestMapping(value = "/api/articles/{id}", method = RequestMethod.DELETE)
    @ResponseBody
    public List<Article> destroy(@PathVariable(value = "id") long id) {
        return articlesService.deleteArticle(id);
    }

테스트를 위해 ArticlesControllerTest에 테스트 메소드를 추가한다. HTTP로 DELETE 요청을 처리하고 반환되는 JSON이 Article List의 해당 article을 삭제한 이후의 List와 JSON의 내용이 같은지 테스트를 한다.

    @Test
    public void testDestroy() throws Exception {
        long id = 1;
        List<Article> articles = articlesService.deleteArticle(id);
        String jsonString = this.jsonStringFromObject(articles);

        mockMvc.perform(delete("/api/articles/{id}", id)
                .content(jsonString))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo(jsonString)));
    }

테스트를 진행한 이후 실제 List에서 article을 삭제한 결과와 JSON이 일치하면 테스트가 성공적으로 끝나게 될 것이다.

단위 테스트 일괄적으로 테스트

단위 테스트는 하나의 메소드로 작은 테스트부터 시작해서 클래스 테스트 전체 테스트로 Test Suit로 만들어서 테스트를 진행할 수도 있다. 또는 Gradle을 사용하여 모든 테스트를 진행할 수도 있다. IntelliJ를 사용한다면 Gradle projects 패널을 열어서 build setup > init을 실행한 뒤 verfication > test를 선택하게 되면 모든 테스트를 일괄적으로 진행한다.

결론

Spring으로 REST 서비스를 만들 때는 Ruby on Rails 만큼의 빠르게 자동으로 라우팅과 컨트롤러, 테스트를 만들 수 없지만 Spring Boot를 사용하면 일반적인 Spring으로 컨트롤러를 만들어서 테스트하는 것보다 빠르게 REST 서비스를 만들 수 있다. 컨트롤를 개발해서 만들 때는 단위테스트를 어떻게 진행해야할지 몰라서 컨트로러를 만든 후 Spring 어플리케이션을 서버로 실행해서 브라우저에서 HTTP 요청을 처리하는 일은 하지말자. 물론 이런 테스트도 진행해야 하지만 개발 단계에서는 MockMvc로 이런 작업과 동일하게 할 수 있다. 모든 단위 테스트가 끝나면 서버에 배포하기 전에 실제 브라우저나 클라이언트 프로그램으로 REST 요청이 잘 처리되는지 한번만 확인을 하면된다. 컨트롤러를 개발할 때 서버를 실행시키고 브라우저에서 URL을 요청한뒤 컨트롤러 내부에 System.out.println를 찍어가면서 디버깅을 한다면 개발 속도는 느릴 뿐만 아니라 완벽한 디버깅을 할 수 없어서 오류가 발생하기 마련다. IntelliJ를 사용하다면 IDE가 제공하는 편리한 툴을 기능을 익히면 좋다. gradle의 빌드나 breakpoint가 그런 것이다. 버튼 하나를 눌리면 여러가지 복잡한 일을 한번에 처리할 수 도 있다. REST 서비스를 만들기 위해서 더 복잡하고 더 다양한 일을 처리해야한데 기본적으로 REST 컨트롤러를 만들 줄 알아야하고, 이것을 어떻게 단위테스르로 확인할 수 있는지 선행학습을 해야 복잡하고 다양한 REST 요청을 처리할 수 있을 것이다.

다음 글에서는 Spring의 RestTemplate을 사용하여 REST 요청을 처리하는 것과 Form 요청을 처리한는 것에서 살펴볼 예정이다.

소소코드

https://github.com/saltfactory/saltfactory-java-tutorial/tree/spring-boot-rest/SpringBootDemo

참조

http://blog.saltfactory.net/java/load-yaml-file-in-spring.html
http://docs.spring.io/spring/docs/current/spring-framework-reference/html/integration-testing.html
https://spring.io/guides/gs/serving-web-content/
http://thswave.github.io/java/2015/03/02/spring-mvc-test.html
http://flystone.tistory.com/196
http://zeroturnaround.com/rebellabs/java-8-explained-applying-lambdas-to-java-collections/
http://apieceofmycode.blogspot.kr/2014/07/spring-integration-testing-under-spring.html

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

IntelliJ에서 Java와 Gradle 버전 설정하기 (Spring Boot)

Fri, 20 Nov 2015 00:00:00 +0000

서론

IntelliJ는 Java 어플리케이션 개발 도구로는 가장 좋은 IDE가 아닌가 생각된다. 학생 때는 Eclipse가 없으면 Java 어플리케이션을 어떻게 개발할 수 있을까 생각하면서 Eclipse가 제일 좋은 IDE라고 생각했는데, IntelliJ를 경험하고 나서는 Eclipse를 아예 지워버렸다. 빠르고 안정적이라서 개발 속도를 높여주는 IntelliJ를 정말 좋아하고 있다. 이런 이유로 IntelliJ를 만든 JetBRAINS의 개발 툴을 대부분 사용하고 있다. 꽤 높은 돈을 지불하고도 아깝지 않은 개발 툴이다.

IntelliJ는 시스템에 설치되어 있는 Java 버전을 자동으로 인식하기도 하고, 자체적으로 내장한 SDK를 사용하기도 한다. 또한 Gradle 프로젝트를 만들면 필요한 라이브러리들을 자동으로 다운받거나 찾아서 개발 환경 변수에 자동으로 등록을 해준다. Spring Boot 예제를 만들기 위해서 시스템에 최신 Gradle을 설치하고 IntelliJ로 프로젝트를 생성하고 난 뒤 gradle build를 하는데 다음과 같은 에러가 발생하면서 빌드가 되지 않는 문제를 만나게 되었다.

FAILURE: Build failed with an exception.

* What went wrong:

Execution failed for task ‘:compileJava’.

invalid source release: 1.8

이 글에서는 IntelliJ에서 최신 Java와 Gradle 설정이 맞지 않았을 경우 발생하는 문제를 소개하고 이 두가지 버전을 설정하는 방법을 소개한다.

IntelliJ 에서 Gradle 빌드 Java 버전 문제

IntelliJ에서 Gradle 프로젝트를 생성하거나 Spring Boot 프로젝트를 생성할 때 Gradle의 버전과 Java 버전을 선택하는 화면들이 나오는데 정확하게 버전을 추가 했다고 생각하더라도 가끔 IDE에서 버전이 맞지 않아 컴파일이 되지 않거나 빌드가 되지 않는 문제를 만날 수 도 있다. 이것은 사실은 사용자가 정확한 버전을 프로젝트 개발하는 변수에 설정을 잘못해서 일어나는 문제이다. 우리는 Gradle을 최신 버전으로 업그레이드하고 Gradle 프로젝트를 빌드하였는데 다음과 같이 compileJava FAILED 에러를 보게 되었다. 이것은 프로젝트에서 Gradle을 빌드할 때 사용하는 Java의 버전이 맞지 않아서 발생하는 문제이다.

IntelliJ은 앞서 말한것 같이 시스템에 자바가 설치되어 있지 않더라도 자체적으로 포함하고 있는 JDK를 사용하여 개발을 할 수 있도록 만들어져있다. 그래서 현재 개발하고 있는 IDE가 사용하고 있는 JDK 버전이 무엇인지 꼭 알고 있어야한다. 예를 들어 IDE가 내장하고 있는 1.7 자바 버전이 설정되어 있는지도 모르고, 시스템 환경변수에 1.8 버전을 등록했다고 개발할 때 1.8에 의존적인 코드를 작성하면 IDE에서는 컴파일이 되지 않는 문제가 발생한다.

IntelliJ에서 Java 버전 설정

그럼 Java 프로젝트를 진행할 때 Java 버전을 설정하는 곳을 살펴보자.

먼저 프로젝트 디렉토리에서 오른쪽 마우스를 클릭하여 Open Module Settings을 열어보자.

그러면 Modules에서 사용하고 있는 Dependencies 가 보이게 될 것이고 현재 이 프로젝트에서 사용하고 있는 Module SDK를 다음과 같이 확인할 수 있다. 현재 1.8 버전으로 개발하고 있는 것을 확인할 수 있다.

다음은 열린 다이얼로그 왼쪽에서 Project Settings 중에 Project를 클릭해보자. 다음과 같이 Project SDK와 Project language level을 선택하여 개발하고 싶은 Java 버전과 문법의 레벨을 설정할 수 있다.

다음은 열린 다이얼로그 왼쪽에서 Platform Settings 중에 SDKs를 클릭해보자. 플랫폼에 적용될 수 있는 SDK 버전들을 볼 수 있다. IntelliJ는 통함 IDE이기 때문에 안드로이드와 Ruby 개발을위한 SDK들도 보여지고 있는데 보통은 Java 버전들만 보일 것이다.

다음은 IntelliJ Preferences를 열어서 Build, Execution, Development 의 Compiler 중에 Java Compiler를 선택하면 다음과 같이 컴파일러를 선택하는 화면이 나타난다. 우리는 앞에서 Java SDK와 Language Level을 선택하는 화면을 봤을 것이다. Project bytecode version(leave blank for JDK default)를 살펴보면 앞에서 설정한 Language Level과 동일한 버전을 사용하는 것을 살펴볼 수 있다.

만약 우리가 Java 1.8 버전으로 프로젝트 개발을 한다면 위에서 살펴본 SDK 버전을 모두 동일하게 적용해줘야한다.

IntelliJ에서 Gradle 버전 설정

앞에서 Java 버전을 설정하는 것을 살펴보았고 이제 Gradle 버전을 설정하는 것을 살펴보자. Gradle은 Groovy 기반으로 JVM에서 동작을 한다. 그래서 Java 버전과 밀접한 관계를 가진다. IntelliJ의 Preferences를 열어서 gradle이라 검색을 해보자. Build, Execution, Deployment 안의 Build Tools 중에 Gradle을 선택하면 다음과 같은 화면을 볼 수 있다.

Project-level settings를 살펴보면 프로젝트에서 사용하는 Gradle을 설정하는 것이 보인다. Gradle home은 프로젝트에서 사용할 Gradle의 경로를 지정할 수 있다. Homebrew로 사용하여 Gradle을 설치하였기 때문에 /usr/local/Cellar/gradle/2.9/libexec로 지정을 했다. 다음은 중요한 Gradle JVM이다. 이것이 이 프로젝트에서 Gradle이 사용할 Java 버전인 것이다. 우리가 프로젝트에서 설정한 Gradle 빌드 파일 build.gradle 은 다음과 같다.

buildscript {
    ext {
        springBootVersion = '1.3.0.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
    baseName = 'spring-boot-demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    compile('org.springframework.boot:spring-boot-starter-web')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}


eclipse {
    classpath {
         containers.remove('org.eclipse.jdt.launching.JRE_CONTAINER')
         containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8'
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

여기서 sourceCompatibility와 targetCompatibility를 설정한 것을 보면 Java 버전을 8버전을 사용하는 것을 살펴볼 수 있다. 하지만 위 스크린샷을 보면 Gradle JVM에서는 Java 7 버전이 설정이 되어 있다. 프로젝트에서 지정한 build.gradle의 버전과 IntelliJ의 Gradle JVM이 맞지 않아서 발생하는 문제이다. 이 버전은 8 버전으로 변경을 한다.

다시 Gradle을 빌드해보자. 이제 프로젝트의 Gradle과 IntelliJ의 Java와 Gradle 설정이 맞아서 문제 없이 빌드가 성공되는 것을 확인할 수 있다.

결론

Spring에서 Gradle을 지원하면서 Gradle의 사용이 많아졌다. Java 프로젝트를 개발할 때 IntelliJ라는 아주 좋은 IDE에서 Gradle 프로젝트를 효율적으로 사용할 수 있게 해준다. Gradle은 Java 버전과 관계가 있으며 프로젝트에 설정한 Java 버전과 IntelliJ의 Java 버전이 일치해야한다. 이 설정부분을 맞지 않아 Java 버전에 관한 에러가 발생하면 당황하지 말고 IntelliJ의 Java 설정 부분을 차근차근 살펴보면 해결할 수 있을 것이라 기대된다.

참조

http://stackoverflow.com/questions/24766591/javac-invalid-target-release-1-8
https://spring.io/guides/gs/gradle/#_build_your_project_with_gradle_wrapper

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

서버 재시작 없이 Spring 웹 프로젝트 개발하기 (Spring Boot, IntelliJ, spring-loaded)

Thu, 19 Nov 2015 00:00:00 +0000

서론

Java 기반 웹 어플리케이션의 가장 큰 단점은 클래스나 정적파일(html, javascript, css)을 수정하고 난 이후 반드시 서버를 재시작해야 한다는 것이다. Node.js 나 Ruby on Rails로 웹 어플리케이션을 개발해본 경험이 있다면 Spring 프로젝트에서 라인 하나 수정하였다고 엄청난 클래스 파일과 정적 파일을 포함한 프로젝트를 모두 재시작 해야하는 것을 보고 놀라지 않을 수 없다. 하지만 Java 개발자들이 이런 불편함을 감수하면서 개발을 하지 않을 것이다. 불편함을 해소하기 위해서 다양한 방법들이 존재하고 빠른 Spring 프로젝트 개발을 위한 Spring Boot와 Idea의 IntelliJ를 사용하여 개발한다면 이런 불편함을 해소할 수 있다. 다시말해서

Spring 프로젝트를 개발하면서 정적파일이나 클래스파일 변경 이후 서버 재시작 없이 변경된 사항을 바로 적용하여 확인할 수 있다.

이 포스팅에서는 Spring 프로젝트에서 정적파일이나 클래스 파일 수정 이후 서버 재시작 없이 개발을 할 수 있는 방법을 소개한다.

Spring Boot

Spring framework의 복잡한 XML 설정 파일에 대한 불편함이나 거부감이 있다면 Spring Boot로 시작하면 Spring을 Ruby on Rails 만큼 빠르게 개발할 수 있다. 기본적인 설정 없이 바로 MVC 기반의 웹 프로젝트를 생성할 수 있기 때문이다. 우리는 앞에서 IntelliJ에서 SpringBoot 웹 프로젝트 생성하기 라는 글을 소개한 적이 있다. 이 글을 참조해서 Spring 웹 프로젝트를 생성한다.

Hot swapping

Spring Boot 공식 문서에서도 파일 수정 이후 서버 재시작 없이 서비스에 바로 적용하는 방법으로 Hot swapping을 소개하고 있다.

Hot swapping은 크게 두가지 리로드를 생각해야한다. 하나는 정적 파일이 수정 되었을 때 이고, 다른 하나는 클래스 파일이 수정되었을 때 이다.

spring-loaded

만약 IntelliJ를 사용하여 Spring Boot를 개발한다면 spring-loaded라는 Java Agent를 사용하여 아주 쉽게 reload 메카니즘을 적용할 수 있다. 프로젝트 디렉토이 안의 build.gradle 파을 열어서 다음 내용을 추가한다. 이 글을 작성할 때 springloaded의 최신 버전은 1.2.4.RELEASE 이다.

buildscript {
    repositories { jcenter() }
    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.3.0.RELEASE"
        classpath 'org.springframework:springloaded:1.2.4.RELEASE'
    }
}

apply plugin: 'idea'

idea {
    module {
        inheritOutputDirs = false
        outputDir = file("$buildDir/classes/main/")
    }
}

만약 템플릿을 사용한다면 다음과 같에 src/main/resources/application.properties 파일을 열어서 템플릿 캐시를 꺼둔다.

spring.thymeleaf.cache=false

이제 Spring 프로젝트의 리로드 설정이 모두 끝났다. 정말 간단하지 않는가? 단 몇줄을 스크립트를 추가하는 것만으로 복잡한 리로드 메카니즘을 구현한 것이다. 이것인 Spring Boot와 gradle의 장점이라고 생각한다.

서버 시작

위의 build.gradle 수정이 끝나면 Gradle 패널에서 리로드 아이콘을 클릭하여 필요한 클래스가 자동으로 프로젝트에 설치될 수 있도록 적용한다. 그리고 Tasks 중에서 application 하위에 있는 bootRun으로 프로젝트를 실행한다. 중요한 부분이다. 그냥 run으로 실행하면 리로드가 되지 않는다. 반드시 bootRun으로 실행하여야 한다.

정적파일 수정

우리는 서버가 실행된 상태에서 정적 파일 수정이 적용되는지 알아보자. 앞에서 생성한 프로젝트에서 HTML 파일을 수정하자. 기존 예제에서는 style.css 파일을 포함하고 있지 않았는데 스타일을 적용하기 위해서 src/main/resources/static/css/style.css 파일을 추가한다.

body {
    background-color: red;
}

다음은 new.html 파일을 열어서 정적파일을 추가한다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>RestTemplate Demo</title>
    <meta charset="utf-8"/>
    <link href="/css/style.css" rel="stylesheet"/>
</head>
<body>
<h1>New</h1>

<form action="#" th:action="@{/templates/posts}" th:object="${post}" method="post">
    <p>title: <input type="text" th:field="*{title}" /></p>
    <p>content: </p>
    <p><textarea th:field="*{content}" /></p>
    <p><input type="submit" value="Submit" /> <input type="reset" value="Reset" /></p>
</form>
</body>
</html>

수정한 결과가 서버 재시작 없이 반영되는지 브라우저를 리로드해보자.

style.css 파일의 background-color를 수정해보자.

body {
    background-color: blue;
}

HTML 파일(Thymleaf) 수정, CSS 정적 파일 수정을 했을 경우 서버 재시작 없이 바로 적용되는 것을 확인할 수 있다.

클래스 파일 수정

이제 클래스 파일을 수정해보자. 우리는 기존의 예제 코드를 사용하여 PostController 에 JSON을 반환하는 http://localhost:8080/posts 컨트롤러를 추가하였다. 서버 재시작 없이 진행하였다.

@Controller
@EnableAutoConfiguration
public class PostsController {

    @RequestMapping(value="/posts", method = RequestMethod.GET)
    public @ResponseBody List<Post> list(){
        List posts = Arrays.asList(new Post(),  new Post());
        return posts;
    }
… 생략…

컨트롤러 파일 수정 이후 정적파일과 동일하게 브라우저를 새로 고침하면 다음과 같이 찾을 수 없는 페이지로 나올 것이다. 컨트롤러에 URL을 매핑하는 것을 추가하였는데 왜 수정 사항이 적용되지 않았을까?

이유는 자바는 클래스로 컴파일이 되어야한다. 이런 이유로 서버는 재시작하지 않지만 파일은 컴파일하여 위에 build.gradle 파일에서 spring-loaded의 Java Agent가 참조하고 있는 빌드 타겟에 클래스 파일이 변경되어야 하기 때문이다. 그래서 클래스 파일은 수정후 IntelliJ의 빌드 메뉴에서 컴파일 파일 메뉴를 선택한다.

이제 다시 브라우저를 새로 고침해보자. 다음과 같이 컨트롤 클래스에 변경된 사항이 적용되어 찾을 수 없는 URL 매핑이 이젠 JSON을 반환할 수 있게 되었다.

결론

Spring은 훌륭하고 매우 안정적인 웹 프레임워크를 만들 수 있다. Java 프레임워크 특징상 정적파일과 클래스 파일 변경후 서버를 재시작해야하는 불편함이 있는데, Spring Boot와 IntelliJ를 사용하여 spring-loeaded Java Agent를 사용하게 되면 IDE에서 Spring 웹 프로젝트를 개발하면서 서버 재시작 없이 빠르게 개발을 진행할 수 있다. Spring은 복잡하고 많은 라이브러리와 클래스를 포함하고 있기 때문에 서버를 재시작하면 서버 재시작 시간 비용이 굉장히 많이 들기 때문에 개발을 할 때 서버를 재시작한다면 매우 답답할 수 밖에 없다. 하지만 소개한 방법을 사용하면 빠르게 Spring 개발을 할 수 있을 것으로 기대된다.

참조

https://docs.spring.io/spring-boot/docs/current/reference/html/howto-hotswapping.html
http://tomaszjanek.pl/blog/2015/02/03/hot-reloading-in-spring-boot-with-spring-loaded/
http://blog.saltfactory.net/java/creating-springboot-project-in-intellij.html
https://github.com/spring-projects/spring-loaded

연구원 소개

작성자 : 송성광 개발 연구원
블로그 : http://blog.saltfactory.net
이메일 : saltfactory@gmail.com
트위터 : @saltfactory
페이스북 : https://facebook.com/salthub
연구소 : 하이브레인넷 부설연구소
연구실 : 창원대학교 데이터베이스 연구실

saltfactory's blog

엣지있게 설명한 Ionic 수정증보판 작업을 진행 합니다.

최신 Ionic 버전을 위한 개정판 준비

새롭게 바뀌는 내용

독자(개발자) 의견

역자의 말

엣지있게 설명한 ionic 책 소개

연구원 소개

Ionic 하이브리드 앱 (PhoneGap, Cordova) iOS 3D Touch 적용하기

서론

Ionic 프로젝트 생성

cordova-plugin-3dtouch

3D Touch 홈스크린 3D Touch 정의하기

3D Touch 이벤트 처리하는 핸들러 정의하기

결론

참고

소스코드

ionic 책

연구원 소개

PhoneGap(Cordova) 안드로이드 앱에서 외부 링크 새로운 브라우저 앱으로 열기

서론

Custom WebViewClient

MainActivity

결론

참고

연구원 소개

Spring에서 RestTemplate을 사용하여 웹(API 서버)에 Multipart/Form-data (첨부파일 포함) 전송하기

서론

테스트를 위한 프로젝트와 컨트롤러 생성

RestTemplate을 사용하여 GET 요청하여 HTML 문서 확인하기

RestTemplate을 사용하여 POST 로 FORM 데이터 보내기

MultiValueMap을 사용하여 application/x-www-form-urlencoded 전송하기

MultiValueMap을 사용하여 Multipart/Form-data 전송하기

Java Reflection을 사용하여 자동으로 MultiValueMap 만들기

결론

소스코드

참조

연구원 소개

Spring에서 RestTemplate을 사용하여 REST 기반 서비스 요청과 테스트하기

서론

데모를 위한 프로젝트 생성

@WebIntegrationTest 로 RestTemplate 사용하기

GET /api/articles

POST /api/articles

DELETE /api/articles/{id}

PUT /api/articles/{id}

PATCH /api/articles/{id}

결론

소스코드

참조

연구원 소개

Spring에서 REST 서비스를 위한 컨트롤러에 FORM과 파일업로드(multipart/form-data)를 함께 사용하기와 컨트롤러 테스트하기

서론

SpringBootDemo 만들기

Thymeleaf 라이브러리 추가

@RestController Vs. @Controller

@RequestBody Vs. @ModelAndAttribute

파일 업로드

서버 실행

결론

소스코드

참고

연구원 소개

Spring에서 YAML 파일 데이터 객체에 매핑하여 로드하기

서론

테스트를 위한 데이터 YAML 파일로 만들기

YAML 파일을 Map으로 매핑하기

YAML 파일을 POJO로 매핑하기

계층 구조의 YAML 파일을 POJO로 매핑하기

결론

소스코드

참조

연구원 소개

Spring에서 REST 서비스를 위한 컨트롤러 생성과 컨트롤러 단위테스트 하기

서론

IntelliJ에서 Spring Boot 프로젝트 생성하기

테스트를 위한 데이터 YAML 파일 만들기

@Service 객체 만들기

REST 서비스를 위한 Controller 생성

GET /api/articles