훈마로의 보물창고

2021.04.28 · 구독하기

$ npm i react-native-splash-screen --save
$ react-native link react-native-splash-screen
import android.os.Bundle; // here
import com.facebook.react.ReactActivity;
// react-native-splash-screen >= 0.3.1
import org.devio.rn.splashscreen.SplashScreen; // here
// react-native-splash-screen < 0.3.1
import com.cboy.rn.splashscreen.SplashScreen; // here

public class MainActivity extends ReactActivity {
   @Override
    protected void onCreate(Bundle savedInstanceState) {
        SplashScreen.show(this);  // here
        super.onCreate(savedInstanceState);
    }
    // ...other code
}
#import "AppDelegate.h"

#import <React/RCTBundleURLProvider.h>
#import <React/RCTRootView.h>
#import "RNSplashScreen.h"  // here

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    // ...other code

    [RNSplashScreen show];  // here
    // or
    //[RNSplashScreen showSplash:@"LaunchScreen" inRootView:rootView];
    return YES;
}

@end
$ xed ./ios
react-native set-splash --path <path-to-image> --resize <[contain]|cover|center> --background "<background-color>"
import SplashScreen from 'react-native-splash-screen';

export default class App extends Component {
  componentDidMount() {
    SplashScreen.hide();
  }

  render() {
     // ...
  }
}
use springboot_aws_study_webservice;

show variables like 'c%';
ALTER DATABASE springboot_aws_study_webservice
CHARACTER SET = 'utf8mb4'
COLLATE = 'utf8mb4_general_ci';
select @@time_zone, now();
create table test (
    id bigint(20) not null auto_increment,
    content varchar(255) default null,
    primary key (id)
) engine=InnoDB;

insert into test(content) values ('테스트');

select * From test;
$ ssh springboot-aws-study-webservice
$ sudo yum -y install mysql
# ... 설치완료
# mysql -u [계정] -p -h [호스트명]
$ mysql -u hoonmaro -p -h springboot-aws-study-webservice.cbdudkejudka.ap-northeast-2.rds.amazonaws.com
Enter password: [패스워드 입력]

# -p 옵션으로 패스워드 입력 단계 표시
# 접속 완료

# Database 확인
> show tables;

# 이전에 추가한 springboot_aws_study_webservice 목록에 존재하는 것 확인
$ cd .ssh
$ mv ~/Downloads/springboot-aws-study-webservice.pem .
$ chmod 600 springboot-aws-study-webservice.pem
$ ssh-add springboot-aws-study-webservice.pem
$ cd .ssh
$ mv ~/Downloads/springboot-aws-study-webservice.pem .
$ chmod 600 springboot-aws-study-webservice.pem
$ vim ~/.ssh/config

# Edit config                                                                                                                 Buffers
    # springboot-aws-study-webservice
  Host springboot-aws-study-webservice
      HostName [탄력적 IP]
        User ec2-user
      IdentityFile ~/.ssh/springboot-aws-study-webservice.pem

# config 저장 및 종료 :wq

# config 실행 권한 등록
$ chmod 700 ~/.ssh/config
ssh springboot-aws-study-webservice
$ curl -O https://download.java.net/java/GA/jdk13.0.2/d4173c853231432d94f001e99d882ca7/8/GPL/openjdk-13.0.2_linux-x64_bin.tar.gz

# 다운로드 하면서 아래와 비슷한 내용이 출력
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  186M  100  186M    0     0  10.0M      0  0:00:18  0:00:18 --:--:-- 9961k

# 다운로드 완료된 것 확인
$ ls
openjdk-13.0.2_linux-x64_bin.tar.gz

# 압축 풀기
$ tar -xvf openjdk-13_linux-x64_bin.tar.gz
$ ls
jdk-13.0.2  openjdk-13.0.2_linux-x64_bin.tar.gz

# /opt/ 디렉토리로 이동
$ sudo mv jdk-13.0.2 /opt
$ cd /opt
$ ls
aws  jdk-13.0.2  rh

# 환결변수 설정
$ cd /etc/profile.d
$ vim jdk13.sh

# Edit jdk13.sh
export JAVA_HOME=/opt/jdk-13.0.2
export PATH=$PATH:$JAVA_HOME/bin
## 저장 및 종료 :wa

# 설정 반영
$ source /etc/profile.d/jdk13.sh

# 확인
$ echo $JAVA_HOME
/opt/jdk-13.0.2

$ java --version
openjdk 13.0.2 2020-01-14
OpenJDK Runtime Environment (build 13.0.2+8)
OpenJDK 64-Bit Server VM (build 13.0.2+8, mixed mode, sharing)
# 현재 시간 확인
$ date
Sun Jun 28 13:25:53 UTC 2020

# 시간대 정보 변경
$ sudo rm /etc/localtime
$ sudo ln -s /usr/share/zoneinfo/Asia/Seoul /etc/localtime

# 심링크 확인
$ ll /etc/ | grep localtime
lrwxrwxrwx  1 root root       30 Jun 28 22:26 localtime -> /usr/share/zoneinfo/Asia/Seoul

# 현재 시간 다시 확인
$ date
Sun Jun 28 22:27:26 KST 2020
$ sudo hostnamectl set-hostname springboot-aws-study-webserivce
$ hostname
springboot-aws-study-webserivce

$ sudo systemctl restart network

$ sudo reboot
> brew search jdk

==> Formulae
openjdk ✔                                                              openjdk@11 ✔
==> Casks
adoptopenjdk                       adoptopenjdk12-openj9              adoptopenjdk14                     adoptopenjdk8-openj9-jre
adoptopenjdk10                     adoptopenjdk12-openj9-jre          adoptopenjdk14-jre                 adoptopenjdk8-openj9-jre-large
adoptopenjdk11                     adoptopenjdk12-openj9-jre-large    adoptopenjdk14-openj9              adoptopenjdk8-openj9-large
adoptopenjdk11-jre                 adoptopenjdk12-openj9-large        adoptopenjdk14-openj9-jre          adoptopenjdk9
adoptopenjdk11-openj9              adoptopenjdk13 ✔                   adoptopenjdk14-openj9-jre-large    jdk-mission-control
adoptopenjdk11-openj9-jre          adoptopenjdk13-jre                 adoptopenjdk14-openj9-large        oracle-jdk
adoptopenjdk11-openj9-jre-large    adoptopenjdk13-openj9              adoptopenjdk8 ✔                    oracle-jdk-javadoc
adoptopenjdk11-openj9-large        adoptopenjdk13-openj9-jre          adoptopenjdk8 ✔                    sapmachine-jdk
adoptopenjdk12                     adoptopenjdk13-openj9-jre-large    adoptopenjdk8-jre
adoptopenjdk12-jre                 adoptopenjdk13-openj9-large        adoptopenjdk8-openj9

> brew install openjdk
> brew cask install adoptopenjdk8
> brew install jenv

> echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.zshrc
> echo 'eval "$(jenv init -)"' >> ~/.zshrc
> source ~/.zshrc
# adoptopenjdk 8
> jenv add /Library/Java/JavaVirtualMachines/adoptopenjdk-8.jdk/Contents/Home

# openjdk (13)
> jenv add /usr/local/opt/openjdk

# 확인
> jenv versions
system
openjdk64-1.8.0.242
openjdk64-13.0.2
$ jenv global openjdk64-13.0.2
$ jenv local openjdk64-1.8.0.242
$ jenv shell openjdk64-13.0.2
DECLARE
    CURSUR [커서이름] IS [SELECT 문];
BEGIN
    OPEN [커서이름];
    FETCH [커서이름] INTO [변수];
    CLOSE [커서이름];
END;
SELECT select_list INTO variable_list FROM remainder_of_query
-- * ORACLE Live SQL OE(Order Entry) 스키마를 활용한 SELECT INTO 커서 예제

-- 카테고리 이름이 office1인 데이터의 카테고리 설명을 가져온다.
DECLARE
    v_category_desc oe.categories_tab.category_description%TYPE;
BEGIN
    SELECT
        category_description INTO v_category_desc
    FROM oe.categories_tab
    WHERE category_name = 'office1';

    DBMS_OUTPUT.put_line(v_category_desc);
END;

-- > 결과: capitalizable assets (desks, chairs, phones ...)

-- * NO_DATA_FOUND 예외 발생 예제
DECLARE
    v_category_desc oe.categories_tab.category_description%TYPE;
BEGIN
    SELECT
        category_description INTO v_category_desc
    FROM oe.categories_tab
    WHERE category_name = 'office0';

    DBMS_OUTPUT.put_line(v_category_desc);
END;

-- > 결과: ORA-01403: no data found ORA-06512: at line 4

-- * TOO_MANY_ROWS 예외 발생 예제
DECLARE
    v_category_desc oe.categories_tab.category_description%TYPE;
BEGIN
    SELECT
        category_description INTO v_category_desc
    FROM oe.categories_tab;

    DBMS_OUTPUT.put_line(v_category_desc);
END;

-- > 결과: ORA-01422: exact fetch returns more than requested number of rows ORA-06512: at line 4

-- CATEGORIES_TAB 테이블에서 카테고리 이름이 office1인 데이터의 행 전체을 가져온다.
DECLARE
    v_category_tab oe.categories_tab%ROWTYPE;
BEGIN
    SELECT
        * INTO v_category_tab
    FROM oe.categories_tab
    WHERE category_name = 'office1';

    DBMS_OUTPUT.put_line(v_category_tab.category_name);
    DBMS_OUTPUT.put_line(v_category_tab.category_description);
END;

-- > 결과
/*
office1
capitalizable assets (desks, chairs, phones ...)
*/
-- 상품과 카테고리 테이블을 조인하여 상품 아이디 1797 데이터와 그 카테고리의 특정 정보를 조회한다.
DECLARE
    v_category_id oe.categories_tab.category_id%TYPE;
    v_category_name oe.categories_tab.category_name%TYPE;
    v_product_id oe.product_information.product_id%TYPE;
    v_product_name oe.product_information.product_name%TYPE;
BEGIN
    SELECT
        c.category_id, c.category_name, p.product_id  , p.product_name
        INTO
        v_category_id, v_category_name, v_product_id, v_product_name
    FROM oe.categories_tab c
    JOIN oe.product_information p ON c.category_id = p.category_id
    WHERE p.product_id = '1797';

    DBMS_OUTPUT.put_line(
        'PRODUCT[' || v_product_id || ']' || v_product_name 
        || ' belongs to CATEGORY[' || v_category_id || '] ' || v_category_name
    );
END;

-- > 결과: PRODUCT[1797] "Inkjet C/8/HQ" belongs to CATEGORY[12] "hardware2"
-- PL/SQL: ORA-00947: not enough values
DECLARE
    v_category_id oe.categories_tab.category_id%TYPE;
    v_category_name oe.categories_tab.category_name%TYPE;
    v_product_id oe.product_information.product_id%TYPE;
    v_product_name oe.product_information.product_name%TYPE;
BEGIN
    SELECT
        c.category_id, c.category_name, p.product_id  , p.product_name
        INTO
        v_category_id, v_category_name, v_product_id
    FROM oe.categories_tab c
    JOIN oe.product_information p ON c.category_id = p.category_id
    WHERE p.product_id = '1797';

    DBMS_OUTPUT.put_line(
        'PRODUCT[' || v_product_id || '] "' || v_product_name 
        || '" belongs to CATEGORY[' || v_category_id || '] "' || v_category_name || '"'
    );
END;

-- PL/SQL: ORA-00913: too many values
DECLARE
    v_category_id oe.categories_tab.category_id%TYPE;
    v_category_name oe.categories_tab.category_name%TYPE;
    v_product_id oe.product_information.product_id%TYPE;
    v_product_name oe.product_information.product_name%TYPE;
    v_add_one VARCHAR2(10 Char);
BEGIN
    SELECT
        c.category_id, c.category_name, p.product_id  , p.product_name
        INTO
        v_category_id, v_category_name, v_product_id, v_product_name, v_add_one
    FROM oe.categories_tab c
    JOIN oe.product_information p ON c.category_id = p.category_id
    WHERE p.product_id = '1797';

    DBMS_OUTPUT.put_line(
        'PRODUCT[' || v_product_id || '] "' || v_product_name 
        || '" belongs to CATEGORY[' || v_category_id || '] "' || v_category_name || '"'
    );
END;

-- ORA-06502: PL/SQL: numeric or value error: character to number conversion error
DECLARE
    v_category_id oe.categories_tab.category_id%TYPE;
    v_category_name oe.categories_tab.category_name%TYPE;
    v_product_id oe.product_information.product_id%TYPE;
    v_product_name NUMBER;
BEGIN
    SELECT
        c.category_id, c.category_name, p.product_id  , p.product_name
        INTO
        v_category_id, v_category_name, v_product_id, v_product_name
    FROM oe.categories_tab c
    JOIN oe.product_information p ON c.category_id = p.category_id
    WHERE p.product_id = '1797';

    DBMS_OUTPUT.put_line(
        'PRODUCT[' || v_product_id || '] "' || v_product_name 
        || '" belongs to CATEGORY[' || v_category_id || '] "' || v_category_name || '"'
    );
END;
DECLARE
    v_total_bonus INTEGER := 10000;

    CURSOR sales_rep_cur
    IS
        SELECT 
            * 
        FROM (
            SELECT
                sales_rep_id, SUM(order_total) sum_order_total
            FROM oe.orders
            WHERE sales_rep_id IS NOT NULL
            GROUP BY sales_rep_id
        )
        ORDER BY sum_order_total DESC
    ;

    v_sales_rep_id sales_rep_cur%ROWTYPE;

BEGIN
    OPEN sales_rep_cur;
    LOOP
        FETCH sales_rep_cur INTO v_sales_rep_id;
        EXIT WHEN sales_rep_cur%NOTFOUND;

        v_total_bonus := v_total_bonus - 2000;
        DBMS_OUTPUT.put_line('SALES[' || v_sales_rep_id.sales_rep_id || '] get bonus $2000');

        EXIT WHEN v_total_bonus <= 0;
    END LOOP;

    CLOSE sales_rep_cur;

END;
-- 결과
/*
SALES[161] get bonus $2000
SALES[156] get bonus $2000
SALES[154] get bonus $2000
SALES[158] get bonus $2000
SALES[159] get bonus $2000
*/
DECLARE
    v_total_bonus INTEGER := 10000;

    CURSOR sales_rep_cur
    IS
        SELECT 
            * 
        FROM (
            SELECT
                sales_rep_id, SUM(order_total) sum_order_total
            FROM oe.orders
            WHERE sales_rep_id IS NOT NULL
            GROUP BY sales_rep_id
        )
        ORDER BY sum_order_total DESC
    ;

BEGIN
    FOR sales_rep IN sales_rep_cur
    LOOP
        v_total_bonus := v_total_bonus - 2000;
        DBMS_OUTPUT.put_line('SALES[' || sales_rep.sales_rep_id || '] get bonus $2000'
            || ', sales $' || sales_rep.sum_order_total || ' in this month' 
        );
        EXIT WHEN v_total_bonus <= 0;
    END LOOP;

END;

-- 결과
/*
SALES[161] get bonus $2000, sales $661734.5 in this month
SALES[156] get bonus $2000, sales $202617.6 in this month
SALES[154] get bonus $2000, sales $171973.1 in this month
SALES[158] get bonus $2000, sales $156296.2 in this month
SALES[159] get bonus $2000, sales $151167.2 in this month
*/

-- 다른 변수가 없다면 선언부를 생략할 수 있다
BEGIN
    FOR sales_rep IN (
        SELECT 
            * 
        FROM (
            SELECT
                sales_rep_id, SUM(order_total) sum_order_total
            FROM oe.orders
            WHERE sales_rep_id IS NOT NULL
            GROUP BY sales_rep_id
        )
        ORDER BY sum_order_total DESC
    )
    LOOP
        DBMS_OUTPUT.put_line('SALESMAN[' || sales_rep.sales_rep_id || ']'
            || ' sales $' || sales_rep.sum_order_total || ' in this month' 
        );
    END LOOP;
END;

-- 결과
/*
SALESMAN[161] sales $661734.5 in this month
SALESMAN[156] sales $202617.6 in this month
SALESMAN[154] sales $171973.1 in this month
SALESMAN[158] sales $156296.2 in this month
SALESMAN[159] sales $151167.2 in this month
SALESMAN[155] sales $134415.2 in this month
SALESMAN[163] sales $128249.5 in this month
SALESMAN[153] sales $114215.7 in this month
SALESMAN[160] sales $88238.4 in this month
*/
-- 단일 결과 동적 쿼리
CREATE OR REPLACE FUNCTION 
single_number_value (
   table_in    IN VARCHAR2,
   column_in   IN VARCHAR2,
   where_in    IN VARCHAR2)
   RETURN NUMBER
IS
   l_return   NUMBER;
BEGIN
   EXECUTE IMMEDIATE
         'SELECT '
      || column_in
      || ' FROM '
      || table_in
      || ' WHERE '
      || where_in
      INTO l_return;
   RETURN l_return;
END;
-- Function created.

-- SQL Worksheet에서 따로 따로 써서 RUN 해야 한다.
BEGIN
   DBMS_OUTPUT.put_line (
      single_number_value (
                'oe.product_information',
                'category_id',
                'product_id=1797'));
END;
-- 결과: 12

-- 여러 결과 동적 쿼리 (BULK COLLECT 사용)
CREATE OR REPLACE PROCEDURE 
show_number_values (
   table_in    IN VARCHAR2,
   column_in   IN VARCHAR2,
   where_in    IN VARCHAR2)
IS
   TYPE values_t IS TABLE OF NUMBER;

   l_values   values_t;
BEGIN
   EXECUTE IMMEDIATE
         'SELECT '
      || column_in
      || ' FROM '
      || table_in
      || ' WHERE '
      || where_in
      BULK COLLECT INTO l_values;

   FOR indx IN 1 .. l_values.COUNT
   LOOP
      DBMS_OUTPUT.put_line 
      (l_values (indx));
   END LOOP;
END;
-- Procedure created.

BEGIN
   show_number_values (
      'oe.orders',
      'order_total',
      'order_total >= 25000 
       order by order_total desc');
END;
-- 결과
/*
295892
282694.3
268651.8
144054.8
120131.3
103834.4
103679.3
94513.5
92829.4
...
*/
-- 매출이 가장 높은 상품 구하는 함수 생성
CREATE OR REPLACE FUNCTION
find_top_sales_product (
    result_count_in NUMBER
) RETURN SYS_REFCURSOR
IS
    cur SYS_REFCURSOR;
BEGIN
    OPEN cur FOR
    SELECT
            product_id, sales
        FROM (
            SELECT
                product_id, sum(quantity * unit_price) sales
            FROM oe.order_items
            GROUP BY product_id
            ORDER BY sales DESC
        )
        WHERE ROWNUM <= result_count_in;

    RETURN cur;
END;

-- 함수를 호출하여 상위 10개의 출력하는 PL/SQL
DECLARE
   v_products_cur   SYS_REFCURSOR;
   v_product_id NUMBER;
   v_sales NUMBER;
BEGIN
   v_products_cur := find_top_sales_product(10);

   LOOP
    FETCH v_products_cur INTO v_product_id, v_sales;
    EXIT WHEN v_products_cur%NOTFOUND;
      DBMS_OUTPUT.put_line('Product[' || v_product_id || '] sales $' || v_sales);
   END LOOP;

END;
-- 결과
/*
Product[2350] sales $922708.6
Product[3127] sales $364351
Product[2359] sales $180872.8
Product[2252] sales $134079
Product[3003] sales $97464.4
Product[2311] sales $89411.7
Product[3106] sales $82490
Product[2236] sales $79741.2
Product[2289] sales $78099
Product[2245] sales $61908
*/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    ...

    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
        return restTemplateBuilder
                // 로깅 인터셉터에서 Stream을 소비하므로 BufferingClientHttpRequestFactory 을 꼭 써야한다.
                .requestFactory(() -> new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()))
                // 타임아웃 설정 (ms 단위)
                .setConnectTimeout(30000)
                .setReadTimeout(30000)
                // UTF-8 인코딩으로 메시지 컨버터 추가
                .additionalMessageConverters(new StringHttpMessageConverter(Charset.forName("UTF-8")))
                // 로깅 인터셉터 설정
                .additionalInterceptors(new RestTemplateLoggingRequestInterceptor())
                .build();
    }

    ...
}

/**
 * Spring RestTemplate 로깅 인터셉터
 *
 * @author Hoonmaro
 */
@Slf4j
public class RestTemplateLoggingRequestInterceptor implements ClientHttpRequestInterceptor {

    /**
     * <pre>
     * RestTemplate 로깅 Interceptor
     *
     * <pre>
     *
     * @param request HttpRequest
     * @param body Request Body
     * @param execution ClientHttpRequestExecution
     * @throws IOException
     */
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {

        // request log
        URI uri = request.getURI();
        traceRequest(request, body);

        // execute
        ClientHttpResponse response = execution.execute(request, body);

        // response log
        traceResponse(response, uri);
        return response;
    }

    /**
     * <pre>
     * RestTemplate Request 로깅
     *
     * <pre>
     * @param request HttpRequest
     * @param body Request Body
     */
    private void traceRequest(HttpRequest request, byte[] body) {
        StringBuilder reqLog = new StringBuilder();
        reqLog.append("[REQUEST] ")
        .append("Uri : ").append(request.getURI())
        .append(", Method : ").append(request.getMethod())
        .append(", Request Body : ").append(new String(body, StandardCharsets.UTF_8));
        log.info(reqLog.toString());
    }

    /**
     * <pre>
     * RestTemplate Response 로깅
     *
     * <pre>
     * @param response ClientHttpResponse
     * @throws IOException
     */
    private void traceResponse(ClientHttpResponse response, URI uri) throws IOException {
        StringBuilder resLog = new StringBuilder();
        resLog.append("[RESPONSE] ")
        .append("Uri : ").append(uri)
        .append(", Status code : ").append(response.getStatusCode())
        .append(", Response Body : ").append(StreamUtils.copyToString(response.getBody(), StandardCharsets.UTF_8));
        log.info(resLog.toString());
    }
}

# 1. 필요 패키지 설치
$ sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# 2. CentOS용 docker-ce stable 버전 레포지토리 설정
$ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 3. DockerCE 설치
$ sudo yum install -y docker-ce

# 4. Docker 시작
$ sudo service docker start

# 1. Docker Compose 설치
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 2. 퍼미션 수정
$ sudo chmod +x /usr/local/bin/docker-compose

# 3. 테스트
$ docker-compose --version

$ git clone https://github.com/deviantony/docker-elk#requirements

$ chcon -R system_u:object_r:admin_home_t:s0 docker-elk/

# docker-elk
.
+-- elasticsearch
|    +-- Dockerfile
|    +-- config
|    |    +-- elasticsearch.yml
+-- logstash
|    +-- Dockerfile
|    +-- config
|    |    +-- logstash.yml
|    +-- pipeline
|    |    +-- logstash.conf
+-- kibana
|    +-- Dockerfile
|    +-- config
|    |    +-- kibana.yml
+-- extenseions
|    +-- README.md
|    +-- curator...
|    +-- logspout ...
+-- docker-compose.yml
+-- README.md
+-- LICENSE

# docker-compose.yml이 있는 디렉토리에서 수행해야 한다
# build
$ docker-compose build

# 빌드를 통해 생성된 도커 이미지 확인
$ docker images

# up: 컨테이너 생성 및 구동, -d는 백그라운드로 실행 옵션
$ docker-compose up -d

# 컨테이너 목록 확인
$ docker-compose ps

# 컨테이너 로그 확인
$ docker-compose logs -f

# elasticsearch 인덱스 확인
$ curl -XGET localhost:9200/_cat/indices?v

let promise = new Promise(function(resolve, reject) {
   setTimeout(resolve, 100, 'foo');
});

console.log(promise);
// [object Promise]

new Promise(function(resolve, reject) { ... });

RestTemplate template = new RestTemplate(new HttpComponentsClientHttpRequestFactory());

/* String vararg */
String result = restTemplate.getForObject(
        "http://example.com/hotels/{hotel}/bookings/{booking}", String.class, "42", "21");

/* Map<String, String> */
Map<String, String> vars = Collections.singletonMap("hotel", "42");

String result = restTemplate.getForObject(
        "http://example.com/hotels/{hotel}/rooms/{hotel}", String.class, vars);

restTemplate.getForObject("http://example.com/hotel list", String.class);

// 요청 url: "http://example.com/hotel%20list"

String uriTemplate = "http://example.com/hotels/{hotel}";
URI uri = UriComponentsBuilder.fromUriString(uriTemplate).build(42);

RequestEntity<Void> requestEntity = RequestEntity.get(uri)
        .header(("MyRequestHeader", "MyValue")
        .build();

ResponseEntity<String> response = template.exchange(requestEntity, String.class);

String responseHeader = response.getHeaders().getFirst("MyResponseHeader");
String body = response.getBody();

URI location = template.postForLocation("http://example.com/people", person);

Person person = restTemplate.getForObject("http://example.com/people/{id}", Person.class, 42);

MappingJacksonValue value = new MappingJacksonValue(new User("eric", "7!jd#h23"));
value.setSerializationView(User.WithoutPasswordView.class);

RequestEntity<MappingJacksonValue> requestEntity =
    RequestEntity.post(new URI("http://example.com/user")).body(value);

ResponseEntity<String> response = template.exchange(requestEntity, String.class);

MultipartBodyBuilder builder = new MultipartBodyBuilder();
builder.part("fieldPart", "fieldValue");
builder.part("filePart", new FileSystemResource("...logo.png"));
builder.part("jsonPart", new Person("Jason"));

MultiValueMap<String, HttpEntity<?>> parts = builder.build();

MultipartBodyBuilder builder = ...;
template.postForObject("http://example.com/upload", builder.build(), Void.class);

[macOS, 맥OS] jEnv로 자바 환경 세팅 (0)	2020.06.27
글을 안 올리는 이유(변명!?) (0)	2017.06.14
개발자 자기계발 및 실력향상 노하우 (프로젝트가 서쪽으로 간 까닭은, 프로그래머의 리더십) (0)	2016.03.17

OAuth 2.0 정리 (0)	2021.04.28
글을 안 올리는 이유(변명!?) (0)	2017.06.14
개발자 자기계발 및 실력향상 노하우 (프로젝트가 서쪽으로 간 까닭은, 프로그래머의 리더십) (0)	2016.03.17

마로의 Oracle 공부: DDL(3) - DROP (0)	2016.12.14
마로의 Oracle 공부: DDL(2) - ALTER (0)	2016.12.08
마로의 Oracle 공부: DDL(1) - CREATE (0)	2016.10.26
마로의 Oracle 공부: SQL 기초 (0)	2016.01.04

마로의 Spring Framework 공부 - RestTemplate (0)	2018.08.22
마로의 Spring Framework 공부 - 스프링 정적 자원 버전관리 (resource versioning) (0)	2018.08.08
마로의 Spring Framework 공부 - 스프링 소개(Spring Framework Introduction) (1)	2017.02.24
Application Context와 Servlet Context 설정과 Transaction (2)	2017.01.13

상태	설명
pending(대기)	fulfiled 또는 rejected가 아닌 상태
fulfilled(이행)	promise.then(f)에서 f가 콜되자마자의 상태
rejected(실패)	promise.then(undefined, r)에서 r이 콜되자마자의 상태

상태	설명
settled	pending이 아닐 때를 말하며, `Promise`의 상태는 아닌 언어적 편의를 위한 표현이다.
resolved	기본적으로 settled되어 이행(fulfilled)이든 실패(rejected)든 처리가 해소된 상태를 말하며, 연결된 `Promise`가 있을 경우에도 사용되는 용어
unresolved	기본적으로 resolved가 아닌 상태를 말하며, pending인 상황에 사용되는 용어

Method group	Description
getForObject	GET method를 통해 representation을 조회
getForEntity	GET method를 통해 ResponseEntity를 조회 (status, headers, body)
headForHeaders	HEAD method를 통해 리소스의 모든 헤더들을 조회
postForLocation	POST method를 통해 새로운 리소스를 생성하고 응답에 Location 헤더를 리턴
postForObject	POST method를 통해 새로운 리소스를 생성하고 응답에 representation을 리턴
postForEntity	POST method를 통해 새로운 리소스를 생성하고 응답에 representation을 리턴
put	PUT method를 통해 리소스를 새로 생성하거나 수정
patchForObject	PATCH method를 통해 리소스를 수정하고 응답의 representation을 리턴. 주의할 것은 JDK HttpURLConnection은 PATCH 를 지원하지 않고, Apache HttpComponents와 다른 것들은 지원함
delete	DELETE method를 통해 특정 URI의 리소스를 삭제
optionsForAllow	ALLOW method를 통해 리소스가 허용하는 HTTP method들을 조회
exchange	위의 method들 보다 더 일반화되고, 덜 선택적인 버전으로 필요한 경우 추가적인 유연성을 제공함 HTTP 메서드, URL, 헤더 및 본문을 포함한 RequestEntity를 입력받아 ResponseEntity를 리턴 이러한 방법을 사용하면 `Class` 대신 `ParameterizedTypeReference`를 사용하여 제네릭 타입 응답을 지정할 수 있음
execute	요청을 수행하는 가장 일반화된 방법으로, 콜백 인터페이스를 통한 요청 준비 및 응답 추출에 대한 완벽한 제어가 가능

MessageConverter	Description
StringHttpMessageConverter	HTTP 요청 및 응답으로부터 문자열(String)을 읽고 쓸 수 있는 구현체 기본적으로 모든 텍스트 미디어 타입들 `(text/*)`을 지원하며, `text/plain` `Content-Type`으로 작성한다.
FormHttpMessageConverter	HTTP 요청 및 응답으로부터 form 데이터를 읽고 쓸 수 있는 구현체 기본적으로 `application/x-www-form-urlencoded` 미디어 타입을 지원한다. Form 데이터는 `MultiValueMap<String, String>`읽고 작성된다.
ByteArrayHttpMessageConverter	HTTP 요청 및 응답으로부터 바이트 배열을 읽고 쓸 수 있는 구현체 기본적으로 모든 미디어 타입 `(/)`을 지원하며, `application/octet-stream` `Content-Type`으로 작성한다. 이 컨버터는 `supportedMediaTypes` 속성을 설정하고 `getContentType(byte[])`를 오버라이드하여 재정의할 수 있다
MarshallingHttpMessageConverter	`org.springframework.oxm` 패키지의 스프링의 마샬러(Marshaller)와 언마샬러(Unmarshaller) 추상화를 사용하여 XML을 읽고 쓸 수 있는 구현체 이 컨버터는 사용하기 전에 마샬러와 언마샬러를 필요로 한다. 이들은 생성자 또는 빈 프로퍼티를 통해 주입될 수 있다. 기본적으로 `text/xml`과 `application/xml`을 지원한다
MappingJackson2HttpMessageConverter	`Jackson` 라이브러리의 `ObjectMapper`를 사용하여 JSON을 읽고 쓸 수 있는 구현체 JSON 매핑은 필요에 따라 `Jackson`이 제공하는 어노테이션을 통해 커스터마이징 될 수 있다 추가 제어가 필요할 경우 특히, 특정 유형에 대해 커스텀 JSON 직렬화/역직렬화를 제공해야 하는 경우 ObjectMapper 속성을 통해 커스텀 ObjectMapper를 주입할 수 있다. 기본적으로 `application/json`을 지원한다
MappingJackson2XmlHttpMessageConverter	`Jackson XML`의 XmlMapper를 사용하여 XML을 읽고 쓸 수 있는 구현체 `Jackson`이 제공하는 어노테이션을 또는 JAXB를 사용하여 필요에 따라 XML 매핑은 커스터마이징 될 수 있다 추가 제어가 필요한 경우, 특히 특정 유형에 대해 커스텀 XML 직렬화/역직렬화를 제공해야하는 경우 ObjectMapper 속성을 통해 커스텀 XmlMapper를 주입할 수 있다 기본적으로 `application/xml`을 지원한다
SourceHttpMessageConverter	HTTP 요청 및 응답으로부터 `javax.xml.transform.Source`를 읽고 쓸 수 있는 구현체 `DOMSource`, `SAXSource`, `StreamSource`만 지원된다. 기본적으로 `text/xml`과 `application/xml`를 지원한다
BufferedImageHttpMessageConverter	HTTP 요청 및 응답으로부터 `java.awt.image.BufferedImage`를 읽고 쓸 수 있는 구현체 `Java I/O API`에서 지원하는 미디어 타입을 읽고 쓴다

마로의 Spring Framework 공부 - RestTemplate Logging(로그) (0)	2019.03.13
마로의 Spring Framework 공부 - 스프링 정적 자원 버전관리 (resource versioning) (0)	2018.08.08
마로의 Spring Framework 공부 - 스프링 소개(Spring Framework Introduction) (1)	2017.02.24
Application Context와 Servlet Context 설정과 Transaction (2)	2017.01.13

프로그래밍

OAuth 2.0

OAuth 2.0 이란?

용어 설명

인가 승인 방식

1. Authorization Code

2. Implicit

3. Resource Owner Password Credentials

4. Client Credentials

풀어쓰는 OAuth 2.0 인가 절차 이야기

참조

'프로그래밍 > 이야기' 카테고리의 다른 글

리액트 네이티브(React Native) 스플래쉬 스크린(Splash Screen) 구현

스플래쉬 스크린이란

리액트 네이티브 스플래쉬 스크린

설치

다운로드

플러그인 설치

플러그인 설정

스플래쉬 스크린 생성

참고

AWS RDS 생성과 기본 설정

RDS 생성하기

RDS 데이터베이스 인스턴스 생성

MariaDB 엔진 선택

상세 설정

RDS 운영환경에 맞는 설정

파라미터 그룹

타임존 설정

문자열 셋 설정

Max Connection 설정

파라미터 그룹과 DB 인스턴스 연결

RDS 보안 설정

DB에 접속해보기

Datagrip으로 연결

설정 확인

EC2에서 접속하기

참고

'프로그래밍 > AWS' 카테고리의 다른 글

AWS EC2(아마존 리눅스2) 생성과 Java 13 설치

AWS EC2 인스턴스 생성

EC2 대시보드 → 인스턴스 시작

이미지 선택

Amazon Linx 2 AMI 선택

인스턴스 유형 선택

T 시리즈

인스턴스 세부 정보 구성

스토리지 추가

태그 추가

보안 그룹 구성

키 페어 생성

키 페어 등록

인스턴스 대시보드에서 확인

EIP 할당

인스턴스 정보 확인

터미널로 EC2 인스턴스 접속

pem키 등록

인스턴스 아마존 리눅스 서버 설정

JDK 설치

서버 시간대(타임존) 변경

호스트네임 변경

참고

'프로그래밍 > AWS' 카테고리의 다른 글

jEnv로 자바 환경 세팅

Java 설치

jEnv 설치

JDK jEnv 설정

글로벌 Java 버전 설정

로컬 Java 버전 설정 (디렉토리별)

쉘 Java 버전 설정

'프로그래밍 > 이야기' 카테고리의 다른 글

오라클 커서(Cursor)

기본 문법

예제 준비

오라클 커서란

SELECT-INTO문

명시적 커서로부터 가져오기

커서 FOR 반복문 사용

동적 쿼리 사용(EXECUTE IMMEDIATE INTO)

커서 변수