Setalah sekian lama, akhirnya penulis mencoba menyempatkan kembali menulis sedikit artikel untuk bisa berbagi ke teman - teman. Pada artikel ini, penulis akan membahas mengenai salah satu bahasa pemrograman yang cukup populer yaitu Go-Lang.

Apa itu Go-Lang ?

Go-Lang adalah kepanjangan dari go language, dimana go-lang ini merupakan bahasa pemrograman yang diciptakan oleh google bersama Ken Thompson, Robert Griesemer, dan Rob Pike pada tahun 2009. Go-Lang termasuk statically typed dan compiled programming dimana hasil akhir nya berupa binary.

Instalasi Go-Lang

Melakukan instalasi Go-Lang sangat lah mudah, pada artikel ini penulis hanya akan membahas instalasi go-lang pada sistem operasi linux. Yang perlu teman - teman lakukan adalah

1. Download runtime golang di golang
2. Lalu silahkan buka file environment dengan perintah

sudo gedit /etc/environment

Lalu tambahkan parameter berikut, silahkan sesuaikan dengan path folder Go-Lang runtime teman - teman

GOROOT=/home/rizki/Tool/Runtime/go

Selanjutnya silahkan tambahkan pada bagian PATH menjadi seperti berikut

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/home/rizki/Tool/Runtime/go/bin"

Setelah selesai, silakan restart komputer teman - teman lalu jalankan perintah berikut untuk mengecek versi Go-Lang nya

go version

Jika berhasil maka akan muncul output seperti berikut

go version go1.19.4 linux/amd64

Instalasi Editor Go-Lang

Untuk memulai melakukan coding pasti nya teman - teman memerlukan editor. Editor yang digunakan di Go-Lang ada beberapa yaitu

1. GoLand
2. Visual Studio Code

Penulis menggunakan 2 editor tersebut dan dua - dua nya sangat mudah digunakan. Jika teman - teman menggunakan visual studio code, penulis sarankan untuk melakukan instalasi plugin berikut untuk mempermudah dalam proses coding.

1. go
2. go test
3. prettier
4. go template

Sekian tutorial kali ini dan selamat coding Go-Lang. Terima kasih :).

Pada artikel Blocking IO Dan Non Blocking IO, penulis telah membahas mengenai implementasi non blocking IO pada node js. Pada artikel ini, penulis akan melakukan implementasi non blocking IO dengan menggunakan spring async. Contoh kasus yang penulis gunakan disini adalah melakukan call web service REST API.

Spring Async berfungsi untuk membuat suatu proses dijalankan secara asynchronous sehingga suatu proses dapat dijalankan tanpa harus menunggu proses yang lain selesai.

Setup Project

Silahkan akses start.spring.io untuk melakukan setup project spring. Kemudian silahkan lakukan setup seperti berikut

Lalu buka project tersebut dengan IDE yang anda gunakan misal nya seperti netbeans, eclipse atau Intellij IDEA. Buka file pom.xml lalu tambahkan library spring-security-oauth2 sehingga konfigurasi pom.xml menjadi

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>org.rizki.mufrizal.async</groupId>
    <artifactId>Belajar-Async</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Belajar-Async</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security.oauth</groupId>
            <artifactId>spring-security-oauth2</artifactId>
            <version>2.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Development Project

Pada tulisan ini, penulis akan mencoba melakukan demo spring async dengan cara melakukan call http client. Web service yang akan penulis lakukan adalah sebuah REST API, dimana penulis akan menggunakan service album dan category yang terdapat pada Developer Spotify.

Ubah file application.properties menjadi application.yml yang terdapat di dalam folder resources. Kemudian masukkan konfigurasi berikut

security:
  oauth2:
    client:
      clientId: 1baff7d8d760442184bf7d49acd5477d
      clientSecret: b0c85b1291c64a19bca01cb14907a918
      accessTokenUri: https://accounts.spotify.com/api/token
      grantType: client_credentials

service:
  getAllNewRelease:
    url: https://api.spotify.com/v1/browse/new-releases
  getCategories:
    url: https://api.spotify.com/v1/browse/categories

Key diatas dapat kamu ambil dari halaman Developer Spotify dengan mengikuti ketentuan prosedur pada web tersebut. Selanjutnya silahkan buat sebuah package configuration lalu tambahkan java class AsyncConfiguration dengan code seperti berikut

package org.rizki.mufrizal.async.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfiguration {

    @Bean(name = "asyncTaskExecutor")
    public Executor asyncTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(3);
        threadPoolTaskExecutor.setMaxPoolSize(3);
        threadPoolTaskExecutor.setQueueCapacity(50);
        threadPoolTaskExecutor.setThreadNamePrefix("async-task-");
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }

}

Code diatas berfungsi untuk mendefinisikan bean asyncTaskExecutor, dimana penulis membuat sebuah thread pool dengan prefix async-task-, sehingga nanti nya kita dapat menggunakan prefix tersebut untuk memanggil thread pool nya, contoh penggunaan nya yaitu async-task-test atau async-task-sample.

Untuk mempermudah penggunaan security OAuth2 maka penulis menggunakan spring-security-oauth2. Silahkan buat sebuah class java RestClientConfiguration di dalam package configuration lalu tambahkan code seperti berikut.

package org.rizki.mufrizal.async.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.security.oauth2.client.DefaultOAuth2ClientContext;
import org.springframework.security.oauth2.client.OAuth2RestOperations;
import org.springframework.security.oauth2.client.OAuth2RestTemplate;
import org.springframework.security.oauth2.client.resource.OAuth2ProtectedResourceDetails;
import org.springframework.security.oauth2.client.token.DefaultAccessTokenRequest;
import org.springframework.security.oauth2.client.token.grant.client.ClientCredentialsResourceDetails;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableOAuth2Client;
import org.springframework.web.client.RestTemplate;

@Configuration
@EnableOAuth2Client
public class RestClientConfiguration {

    @Autowired
    private Environment environment;

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    protected OAuth2ProtectedResourceDetails oAuth2ProtectedResourceDetails() {
        ClientCredentialsResourceDetails clientCredentialsResourceDetails = new ClientCredentialsResourceDetails();
        clientCredentialsResourceDetails.setClientId(environment.getRequiredProperty("security.oauth2.client.clientId"));
        clientCredentialsResourceDetails.setClientSecret(environment.getRequiredProperty("security.oauth2.client.clientSecret"));
        clientCredentialsResourceDetails.setAccessTokenUri(environment.getRequiredProperty("security.oauth2.client.accessTokenUri"));
        clientCredentialsResourceDetails.setGrantType(environment.getRequiredProperty("security.oauth2.client.grantType"));
        return clientCredentialsResourceDetails;
    }

    @Bean
    public OAuth2RestOperations oAuth2RestOperations() {
        return new OAuth2RestTemplate(oAuth2ProtectedResourceDetails(), new DefaultOAuth2ClientContext(new DefaultAccessTokenRequest()));
    }

}

Pada code diatas, penulis mendefinisikan konfigurasi OAuth2 untuk client, sehingga penulis tidak perlu membuat code untuk memanggil service OAuth2 dikarenakan secara otomatis akan dipanggil oleh spring-security-oauth2, ini hanya berlaku jika OAuth2 yang digunakan adalah OAuth2 dengan standard yang sama atau dengan standard secara global.

Selanjutnya penulis membuat class - class mapper untuk dilakukan mapping antara request dan response. Silahkan buat sebuah package mapper lalu masukkan code berikut pada java class ItemMapper, ItemCategoryMapper, CategoriesMapper, CategoryMapper, AlbumsMapper dan AlbumMapper.

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class ItemMapper implements Serializable {

    @JsonProperty("album_type")
    private String albumType;

    @JsonProperty("href")
    private String href;

    @JsonProperty("id")
    private String id;

    @JsonProperty("name")
    private String name;

    @JsonProperty("release_date")
    private String releaseDate;

    @JsonProperty("release_date_precision")
    private String releaseDatePrecision;

    @JsonProperty("total_tracks")
    private Double totalTracks;

    @JsonProperty("type")
    private String type;

    @JsonProperty("uri")
    private String uri;

}

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class ItemCategoryMapper implements Serializable {

    @JsonProperty("href")
    private String href;

    @JsonProperty("id")
    private String id;

    @JsonProperty("name")
    private String name;

}

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class CategoriesMapper implements Serializable {

    @JsonProperty("href")
    public String href;

    @JsonProperty("items")
    public List<ItemCategoryMapper> items;

    @JsonProperty("limit")
    public Double limit;

    @JsonProperty("next")
    public String next;

    @JsonProperty("offset")
    public String offset;

    @JsonProperty("previous")
    public String previous;

    @JsonProperty("total")
    public Double total;

}

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class CategoryMapper implements Serializable {

    @JsonProperty("categories")
    public CategoriesMapper categoriesMapper;

}

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class AlbumsMapper implements Serializable {

    @JsonProperty("href")
    private String href;

    @JsonProperty("items")
    private List<ItemMapper> items;

    @JsonProperty("limit")
    private Double limit;

    @JsonProperty("next")
    private String next;

    @JsonProperty("offset")
    private String offset;

    @JsonProperty("previous")
    private String previous;

    @JsonProperty("total")
    private Double total;

}

package org.rizki.mufrizal.async.mapper;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class AlbumMapper implements Serializable {

    @JsonProperty("albums")
    public AlbumsMapper albums;

}

Code - code diatas secara otomatis akan dibuatkan getter setter dengan bantuan lombok. Lalu selanjutnya kita akan masuk ke pembahasan spring async nya. Silahkan buat sebuah package httpclient lalu tambahkan sebuah class java SyncHttpClient dan tambahkan code berikut.

package org.rizki.mufrizal.async.httpclient;

import lombok.extern.slf4j.Slf4j;
import org.rizki.mufrizal.async.mapper.AlbumMapper;
import org.rizki.mufrizal.async.mapper.CategoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.oauth2.client.OAuth2RestOperations;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.CompletableFuture;

@Service
@Slf4j
public class SyncHttpClient {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private OAuth2RestOperations oAuth2RestOperations;

    @Autowired
    private Environment environment;

    public CompletableFuture<AlbumMapper> getAlbum() {
        log.info("Start Get Album");

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        httpHeaders.set("Authorization", "Bearer " + oAuth2RestOperations.getAccessToken().getValue());
        HttpEntity<HttpHeaders> entity = new HttpEntity<>(httpHeaders);

        ResponseEntity<AlbumMapper> albumMapperResponseEntity = restTemplate
                .exchange(environment.getRequiredProperty("service.getAllNewRelease.url"), HttpMethod.GET, entity, AlbumMapper.class);
        log.info("End Get Album");
        return CompletableFuture.completedFuture(albumMapperResponseEntity.getBody());
    }

    public CompletableFuture<CategoryMapper> getCategory() {
        log.info("Start Get Category");

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        httpHeaders.set("Authorization", "Bearer " + oAuth2RestOperations.getAccessToken().getValue());
        HttpEntity<HttpHeaders> entity = new HttpEntity<>(httpHeaders);

        ResponseEntity<CategoryMapper> categoryMapperResponseEntity = restTemplate
                .exchange(environment.getRequiredProperty("service.getCategories.url"), HttpMethod.GET, entity, CategoryMapper.class);
        log.info("End Get Category");
        return CompletableFuture.completedFuture(categoryMapperResponseEntity.getBody());
    }

}

Kemudian buat sebuah class AsyncHttpClient dan masukkan code berikut

package org.rizki.mufrizal.async.httpclient;

import lombok.extern.slf4j.Slf4j;
import org.rizki.mufrizal.async.mapper.AlbumMapper;
import org.rizki.mufrizal.async.mapper.CategoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.annotation.Async;
import org.springframework.security.oauth2.client.OAuth2RestOperations;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.CompletableFuture;

@Service
@Slf4j
public class AsyncHttpClient {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private OAuth2RestOperations oAuth2RestOperations;

    @Autowired
    private Environment environment;

    @Async("asyncTaskExecutor")
    public CompletableFuture<AlbumMapper> getAlbum() {
        log.info("Start Get Album");

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        httpHeaders.set("Authorization", "Bearer " + oAuth2RestOperations.getAccessToken().getValue());
        HttpEntity<HttpHeaders> entity = new HttpEntity<>(httpHeaders);

        ResponseEntity<AlbumMapper> albumMapperResponseEntity = restTemplate
                .exchange(environment.getRequiredProperty("service.getAllNewRelease.url"), HttpMethod.GET, entity, AlbumMapper.class);
        log.info("End Get Album");
        return CompletableFuture.completedFuture(albumMapperResponseEntity.getBody());
    }

    @Async("asyncTaskExecutor")
    public CompletableFuture<CategoryMapper> getCategory() {
        log.info("Start Get Category");

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        httpHeaders.set("Authorization", "Bearer " + oAuth2RestOperations.getAccessToken().getValue());
        HttpEntity<HttpHeaders> entity = new HttpEntity<>(httpHeaders);

        ResponseEntity<CategoryMapper> categoryMapperResponseEntity = restTemplate
                .exchange(environment.getRequiredProperty("service.getCategories.url"), HttpMethod.GET, entity, CategoryMapper.class);
        log.info("End Get Category");
        return CompletableFuture.completedFuture(categoryMapperResponseEntity.getBody());
    }

}

Dari kedua code diatas tidak ada perbedaan, hanya terdapat perbedaan yaitu di class AsyncHttpClient setiap method nya menggunakan annotation @Async dengan nama bean nya asyncTaskExecutor. Dari segi code memang sama dan tidak ditemukan perbedaan nya sehingga kita tidak dapat mengetahui apakan proses tersebut dilakukans secara sync atau async.

Test Async Dan Sync

Pada tulisan ini, penulis akan menggunakan library bawaan spring boot untuk melakukan unit test yaitu spring-boot-starter-test. Silahkan buka code BelajarAsyncApplicationTests di dalam package test lalu tambahkan code berikut

package org.rizki.mufrizal.async;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.rizki.mufrizal.async.httpclient.AsyncHttpClient;
import org.rizki.mufrizal.async.httpclient.SyncHttpClient;
import org.rizki.mufrizal.async.mapper.AlbumMapper;
import org.rizki.mufrizal.async.mapper.CategoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

@SpringBootTest
@Slf4j
class BelajarAsyncApplicationTests {

    @Autowired
    private AsyncHttpClient asyncHttpClient;

    @Autowired
    private SyncHttpClient syncHttpClient;

    @Test
    void asyncHttpClientTest() throws ExecutionException, InterruptedException, JsonProcessingException {
        log.info("Start Test Async Test");
        CompletableFuture<AlbumMapper> albumMapperResponseMapperCompletableFuture = asyncHttpClient.getAlbum();
        CompletableFuture<CategoryMapper> categoryMapperCompletableFuture = asyncHttpClient.getCategory();

        log.info("Result Get Album {}", new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(albumMapperResponseMapperCompletableFuture.get()));
        log.info("Result Get Category {}", new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(categoryMapperCompletableFuture.get()));
        log.info("End Test Async Test");
    }

    @Test
    void syncHttpClientTest() throws ExecutionException, InterruptedException, JsonProcessingException {
        log.info("Start Test Sync Test");
        CompletableFuture<AlbumMapper> albumMapperResponseMapperCompletableFuture = syncHttpClient.getAlbum();
        CompletableFuture<CategoryMapper> categoryMapperCompletableFuture = syncHttpClient.getCategory();

        log.info("Result Get Album {}", new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(albumMapperResponseMapperCompletableFuture.get()));
        log.info("Result Get Category {}", new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(categoryMapperCompletableFuture.get()));
        log.info("End Test Sync Test");
    }

}

Kemudian jalankan test nya dengan perintah

mvn clean install

Pada terminal akan muncul log seperti berikut untuk proses async nya

2021-02-22 13:46:33.335  INFO 48219 --- [           main] o.r.m.a.BelajarAsyncApplicationTests     : Start Test Async Test
2021-02-22 13:46:33.349  INFO 48219 --- [   async-task-1] o.r.m.async.httpclient.AsyncHttpClient   : Start Get Album
2021-02-22 13:46:33.349  INFO 48219 --- [   async-task-2] o.r.m.async.httpclient.AsyncHttpClient   : Start Get Category
2021-02-22 13:46:34.003  INFO 48219 --- [   async-task-2] o.r.m.async.httpclient.AsyncHttpClient   : End Get Category
2021-02-22 13:46:34.063  INFO 48219 --- [   async-task-1] o.r.m.async.httpclient.AsyncHttpClient   : End Get Album
2021-02-22 13:46:34.088  INFO 48219 --- [           main] o.r.m.a.BelajarAsyncApplicationTests     : End Test Async Test

sedangkan untuk proses sync nya

2021-02-22 13:46:34.100  INFO 48219 --- [           main] o.r.m.a.BelajarAsyncApplicationTests     : Start Test Sync Test
2021-02-22 13:46:34.101  INFO 48219 --- [           main] o.r.m.async.httpclient.SyncHttpClient    : Start Get Album
2021-02-22 13:46:34.226  INFO 48219 --- [           main] o.r.m.async.httpclient.SyncHttpClient    : End Get Album
2021-02-22 13:46:34.226  INFO 48219 --- [           main] o.r.m.async.httpclient.SyncHttpClient    : Start Get Category
2021-02-22 13:46:34.299  INFO 48219 --- [           main] o.r.m.async.httpclient.SyncHttpClient    : End Get Category
2021-02-22 13:46:34.314  INFO 48219 --- [           main] o.r.m.a.BelajarAsyncApplicationTests     : End Test Sync Test

Dari log diatas dapat dilihat bahwa proses async berjalan dengan menggunakan thread masing - masing, dapat dilihat thread nya yaitu async-task-1 dan async-task-2 sedangkan pada proses sync hanya menggunakan thread yang sama yaitu main thread. Untuk proses async dapat berjalan secara independent sehingga proses call http client dapat berjalan secara bersamaan, sedangkan pada proses sync, call http client akan dijalankan secara sequence. Untuk source code diatas dapat anda akses di Belajar-Async. Sekian artikel mengenai belajar spring async jika ada saran dan komentar silahkan isi dibawah dan terima kasih :).

Aplikasi - aplikasi yang telah berjalan pada zaman sekarang biasa nya dibuat dalam bentuk blocking. Contoh yang sangat sederhana adalah aplikasi yang dibangun dengan menggunakan spring webmvc, dimana aplikasi ini masih menggunakan konsep blocking. Sebelum penulis membahas mengenai blocking dan non blocking, maka penulis akan membahas terlebih dahulu mengenai thread dikarenakan blocking dan non blocking sangat berkaitan dengan thread.

Apa Itu Thread ?

Thread adalah rangkain eksekusi dari sebuah aplikasi, biasa nya setiap aplikasi akan memiliki thread, minimal 1 thread.

Contoh yang paling sederhana dapat dilihat dari sebuah aplikasi web. Setiap request yang masuk ke dalam sebuah aplikasi web, maka akan membentuk sebuah koneksi. Koneksi yang dibentuk karena sebuah request akan dijadikan 1 thread pada aplikasi web tersebut. Berikut merupakan sample thread jika diilustrasikan pada sebuah aplikasi web.

Dari gambar diatas, dapat dilihat terdapat request yang masuk secara bersamaan dari pengguna 1 dan pengguna 2. Masing - masing pengguna akan dibuatkan sebuah thread atau istilahnya multithread, dimana masing - masing proses akan dijalankan secara independent sehingga tidak ada proses tunggu menunggu antara kedua request tersebut.

Mungkin ada yang bertanya - tanya, apa perbedaan nya antara multithread dan multicore ? dan apakah dengan komputer single core dapat menggunakan multithread ?. Secara arsitektur, 1 core mempunya beberapa thread, biasanya 1 core memiliki 2 thread. Berikut jika digambarkan arsitektur dari core dan thread.

Jika anda menggunakan linux, kita dapat melakukan pengecekan core dan thread dengan perintah

lscpu

Kemudian lihat pada bagian Thread(s) per core yang menandakan jumlah thread per core dan Core(s) per socket yang menandakan jumlah core dari processor. berikut contohnya

Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
Address sizes: 43 bits physical, 48 bits virtual
CPU(s): 16
On-line CPU(s) list: 0-15
Thread(s) per core: 2
Core(s) per socket: 8
Socket(s): 1
NUMA node(s): 1
Vendor ID: AuthenticAMD
CPU family: 23
Model: 8
Model name: AMD Ryzen 7 2700X Eight-Core Processor

Dari informasi diatas dapat dilihat bahwa cpu nya memiliki 8 core dan setiap core memiliki 2 thread virtual processor sehingga total nya ada 16 thread virtual processor.

Apa Itu Thread pool Dan Task Queue ?

Setiap menjalankan 1 thread, biasa nya pada komputer dengan arsitektur x64 membutuhkan memory sebanyak 1MB. Bayangkan jika thread tidak di manage dengan baik maka dapat dipastikan resource sebuah komputer akan habis dan aplikasi tersebut tidak dapat berjalan.

Thread Pool merupakan sebuah management thread yang dapat digunakan untuk memanage thread dari sebuah aplikasi.

Dengan ada nya thread pool ini, kita dapat mendefinisikan berapa maksimal thread yang akan dibuat, minimal thread, idle dari setiap thread dan lain sebagainya. Jika thread pool nya penuh, bagaimana dengan thread baru selanjutnya ?. Thread baru selanjutnya akan dibuat di dalam sebuah antrian dengan nama task queue.

Task Queue berisi thread antrian jika jumlah thread pada thread pool telah penuh.

Task queue atau istilah lain nya yaitu backlog jika disisi http port. Task queue atau backlog juga dapat dibatasi, jika melebihi dari yang ditentukan maka task tersebut tidak akan masuk ke dalam sebuah task queue. Berikut merupakan gambar dari arsitektur thread pool dan task queue.

Apa Itu Blocking IO ?

Blocking IO adalah sebuah proses akan dijalankan jika proses sebelum nya telah selesai dijalankan atau istilah lain nya yaitu synchronous

Blocking IO diadopsi oleh hampir semua web server dan web framework seperti apache tomcat, jetty, dan lain sebagai nya. Blocking IO sendiri mengadopsi teknologi thread pool dan task queue sehingga proses dijalankan jika terdapat thread yang sedang idle atau tidak digunakan. Berikut contoh arsitektur blocking IO jika diimplementasikan ke dalam sebuah web server.

Dari gambar diatas, 1 request yang datang dari client dianggap sebagai sebuah thread, dimana 1 thread ini juga mewakili dari sebuah connection. Backlog pada gambar diatas berfungsi untuk menampung request jika thread yang terdapat pada thread pool sedang penuh atau istilahnya request tersebut akan diantrikan di dalam backlog tersebut. Jika thread yang terdapat pada thread pool tersebut ada yang telah direlease atau dilepas maka request yang terdapat pada backlog akan dimasukkan ke dalam thread pool. Misal maksimal kapasitas thread pool kita setting di angka 500, dan backlog di setting di angka 200. Request yang datang dari client sebanyak 1000 request maka 500 request akan di process secara bersamaan, 200 request akan dimasukkan ke dalam antrian sedangkan 300 request lagi akan di reject karena melebihi kapasitas dari backlog yang telah ditentukan. Dari proses diatas, response server biasa nya terlihat sangat lambat dikarenakan adanya antrian dan harus menunggu proses yang sebelum nya. Contoh framework yang menggunakan blocking IO adalah spring webmvc, ruby on rails, laravel dan lain sebagain nya.

Apa Itu Non Blocking IO ?

Non Blocking IO adalah sebuah proses akan dijalankan tanpa harus menunggu proses lain selesai atau istilah lain nya yaitu asynchronous.

Non blocking IO biasa nya menggunakan teknologi event loop, dimana event loop ini sering disebut sebagai thread bos. Thread bos ini berfungsi sebagai penerima request, dimana jika request tersebut memiliki operasi non blocking IO maka akan langsung di execute oleh thread bos tapi jika memiliki operasi blocking seperti http call, akses ke database maka thread bos akan meneruskan operasi atau task tersebut ke thread worker. Di dalam non blocking IO, thread yang akan digunakan biasa nya sebesar (jumlah virtual processor x 2), dimana thread tersebut nanti nya akan dijadikan sebagai worker thread. Misal nya jika kita memiliki 4 thread virtual processor maka total thread yang akan di buat adalah sebanyak 9 thread terdiri dari 1 thread bos dan 8 thread worker. Berikut contoh arsitektur Non blocking IO jika diimplementasikan ke dalam sebuah web server.

Mengapa Non blocking IO ini dapat berjalan di thread yang kecil ? hal ini disebabkan pada saat dilakukan process blocking semisal kita melakukan http call ke backend, di belakang layar sebenarnya thread tersebut akan melakukan pengiriman http call tersebut dengan bantuan epoll (contoh jika menggunakan linux) dan epoll disini berfungsi untuk menunggu response http call tersebut. Setelah memberikan instruksi kepada epoll, thread tersebut akan di release sehingga thread dapat menjalankan perintah yang lain. Jika response telah diterima, epoll akan melakukan callback atau memberikan informasi kepada worker thread bahwa response telah diterima, lalu worker thread akan mengirimkan response tersebut ke thread bos dan dikembalikan kepada user.

Kapan Penggunaan Blocking IO Dan Non Blocking IO ?

Blocking IO akan digunakan jika terdapat process yang banyak menggunakan CPU atau lebih dikenal dengan CPU Bound. Contoh dari penggunaan CPU bound seperti perhitungan aritmatika, process encrypt decrypt, dimana process ini tidak cocok jika kita gunakan dengan menggunakan non blocking IO karena CPU bound membutuhkan thread yang banyak untuk pemrosesan yang berat dan jika menggunakan non blocking IO maka aplikasi akan semakin lambat. Berbeda dengan CPU Bound, IO Bound adalah process yang lebih berkaitan dengan IO, baik itu secara network atau secara disk. Contoh IO bound seperti http call yang membutuhkan IO secara network atau membuat koneksi ke database yang membutuhkan IO secara network dan disk. Dari penjelasan diatas, dapat disimpulkan jika aplikasi yang akan kita develop nanti nya banyak menggunakan CPU bound maka gunakanlah blocking IO tapi jika banyak menggunakan IO bound maka gunakanlah non blocking IO.

Contoh Implementasi Blocking IO Dan Non Blocking IO

Pada artikel ini, penulis akan memberikan contoh implementasi blocking IO dan non blocking IO dengan menggunakan node js. Bagi kamu yang belum tau apa itu node js, silahkan simak artikel Instalasi Perlengkapan Coding Node JS.

Implementasi Blocking IO

Silkahkan buat sebuah file data.txt lalu isi dengan text berikut.

Contoh Blocking IO dan Non Blocking IO dengan menggunakan node js

Lalu buat sebuah file blocking-io.js lalu isi dengan codingan berikut

const fs = require('fs');

console.log('start');

const dataFromFile = fs.readFileSync('data.txt');
console.log(dataFromFile.toString());

console.log('End');

Kemudian jalankan dengan perintah node blocking-io.js maka akan muncul hasil

start
Contoh Blocking IO dan Non Blocking IO dengan menggunakan node js
End

Dari codingan diatas, penulis menggunakan module fs untuk membaca sebuah file. Dapat dilihat, pada codingan diatas penulis menggunakan fungsi readFileSync, dimana fungsi tersebut berfungsi untuk membaca file dengan metode sync atau blocking IO sehingga proses diatas berjalan secara sequence. Jika proses readFileSync belum selesai maka console.log(‘End’) tidak akan dijalankan sampai proses readFileSync selesai.

Implementasi Non Blocking IO

Silahkan buat sebuah file non-blocking-io.js lalu isi dengan codingan berikut

const fs = require('fs');

console.log('start');

fs.readFile('data.txt', function (error, data) {
if(error) console.log(error);
	console.log(data.toString());
});

console.log('End');

Kemudian jalankan dengan perintah node non-blocking-io.js maka akan muncul hasil

start
End
Contoh Blocking IO dan Non Blocking IO dengan menggunakan node js

Dari codingan diatas dapat dilihat perbedaannya yaitu pada non blocking IO, penulis menggunakan fungsi readFile dimana fungsi tersebut berfungsi untuk membaca file dengan metode async atau non blocking IO. Dikarenakan proses read file lama maka proses console.log(‘End’) dijalankan terlebih dahulu pada implementasi non blocking IO. Pada non blocking IO, semua proses akan dijalankan tapi tidak seperti blocking IO dimana proses selanjutnya tidak berpengaruh jika proses sebelum nya masih belum selesai.

Dalam dunia programming, setiap developer pasti akan membuat aplikasi yang dapat berjalan secara concurrent dan parallel. Salah satu contohnya yaitu sebuah web application. Web application merupakan salah satu contoh dari penerapan concurrent dan parallel, hal ini dapat dilihat jika web application tersebut dapat melakukan processing untuk setiap pengguna yang berbeda. Proses concurrent dan parallel biasa nya digunakan secara bersamaan untuk mendapatkan hasil terbaik dan efisien. Pada zaman sekarang, semua bahasa pemrograman sudah mendukung proses yang berjalan secara concurrent dan parallel, contohnya seperti bahasa pemrograman java, golang, php dan lain sebagainya.

Apa Itu Concurrent ?

Concurrent adalah sebuah proses yang dijalankan secara sekaligus atau sebuah proses yang dapat melakukan beberapa hal secara sekaligus

Dari pengertian diatas dapat diartikan bahwa concurrent tidak dijalankan secara bersamaan akan tetapi dilakukan secara sekaligus. Contoh di dalam kehidupan nyata adalah ketika seseorang bersepeda, lalu tali sepatu nya terlepas maka orang tersebut memperbaiki tali sepatu kemudian bersepeda kembali. Pada contoh diatas, terdapat 2 pengerjaan yaitu bersepeda dan memperbaiki tali sepatu, dimana pengerjaan diatas dapat dilakukan secara sekaligus tetapi tidak dilakukan secara parallel. Berikut merupakan gambar concurrent.

Apa Itu Parallel ?

Parallel adalah beberapa proses yang dilakukan secara bersamaan

Parallel dapat melakukan sebuah proses secara bersamaan, contoh nya adalah misal ada 2 orang yang bersepeda, mereka sama - sama melakukan proses yang bersamaan yaitu bersepeda tetapi dengan pengguna yang berbeda. Contoh lain nya adalah misal seseorang sedang bersepeda, ketika dia bersepeda, dia juga mendengarkan musik. Pada kasus yang kedua, orang tersebut melakukan aktifitas bersamaan yaitu bersepeda dan mendengarkan musik. Berikut merupakan gambar parallel.

Implementasi Concurrent Pada Java Programming

Silahkan buat sebuah file dengan nama Concurrent.java lalu sisipkan code berikut

/**
 *
 * @author rizki mufrizal
 */
public class Concurrent {

    static int calculate(int a, int b) {
        return a + b;
    }

    static void print(int result) {
        System.out.println("Result " + result);
    }

    public static void main(String[] args) {
        int a = 1;
        int b = 1;
        int calculate = calculate(a, b);
        print(calculate);
    }
}

Dari contoh diatas, dapat dilihat yang pertama kali dilakukan adalah task calculate angka dari variable a dan variable b, lalu kemudian dijalankan task print. Concurrent juga dapat dilakukan dengan melakukan implementasi multi thread karena pada dasar nya concurrent biasa nya menggunakan single core dengan banyak thread sedangkan pada parallel akan menggunakan multi core processor.

Implementasi Parallel Pada Java Programming

Silahkan buat sebuah file dengan nama Parallel.java lalu sisipkan code berikut

import java.util.stream.IntStream;

/**
 *
 * @author rizki
 */
public class Parallel {

    public static void main(String[] args) {
        System.out.println("Normal Iterasi");
        IntStream iterasiNormal = IntStream.rangeClosed(1, 10);
        System.out.println("Is Parallel : " + iterasiNormal.isParallel());
        iterasiNormal.forEach(i -> System.out.println("Normal Iterasi : " + i));

        System.out.println("Parallel Iterasi");
        IntStream iterasiParallel = IntStream.rangeClosed(1, 10).parallel();
        System.out.println("Is Parallel : " + iterasiParallel.isParallel());
        iterasiParallel.forEach(i -> System.out.println("Parallel Iterasi : " + i));
    }

}

Pada saat code java diatas dijalankan maka akan muncul output seperti berikut

Normal Iterasi
Is Parallel : false
Normal Iterasi : 1
Normal Iterasi : 2
Normal Iterasi : 3
Normal Iterasi : 4
Normal Iterasi : 5
Normal Iterasi : 6
Normal Iterasi : 7
Normal Iterasi : 8
Normal Iterasi : 9
Normal Iterasi : 10

Parallel Iterasi
Is Parallel : true
Parallel Iterasi : 7
Parallel Iterasi : 6
Parallel Iterasi : 8
Parallel Iterasi : 1
Parallel Iterasi : 4
Parallel Iterasi : 2
Parallel Iterasi : 9
Parallel Iterasi : 5
Parallel Iterasi : 10
Parallel Iterasi : 3

Hasil dari percobaan diatas dapat dilihat bahwa jika sebuah proses tidak dilakukan dengan parallel maka iterasi yang dihasilkan adalah iterasi sequence atau berurutan. Pada saat dijalankan secara parallel maka iterasi yang dihasilkan dapat berbagai macam dan tidak sequence atau berurutan. Pada sample code diatas, penulis menggunakan java 8 stream yaitu IntStream, dimana class ini dapat digunakan untuk melakukan proses secara parallel maupun non parallel.

Apa Itu ISO ?

ISO (International Organization for Standardization) adalah badan penetap standar internasional yang terdiri dari wakil-wakil dari badan standardisasi nasional setiap negara.

ISO biasanya akan menetapkan suatu standarisasi untuk kebutuhan tertentu misalnya seperti penetapan standarisasi sistem keamanan rantai pasokan pada ISO 28000, sistem terhadap manajemen lingkungan pada ISO 14001 dan lain - lain nya. Penetapan standarisasi ini berguna untuk membuat keseragaman / standarisasi antar negara sehingga memudahkan dalam proses integrasi.

Apa Itu ISO 8583 ?

ISO 8583 adalah sebuah standart internasional untuk transaksi financial.

ISO 8583 ini sudah sangat banyak digunakan untuk hal transaksi financial terutama di dunia perbankan. ISO 8583 ini tidak hanya dapat digunakan di bagian perbankan melainkan dapat digunakan di bagian lain yang berhubungan dalam hal transaksi financial. Contoh implementasi dari ISO 8583 sendiri adalah terletak pada mesin ATM dan EDC, dimana pada saat proses transaksi, mesin ATM atau EDC akan mengirimkan data dalam bentuk ISO 8583 ke server untuk diproses.

Komponent ISO 8583

Secara global, komponent ISO 8583 terdiri dari :

• Message Header : biasanya digunakan sebagai penanda awal dari sebuah message
• Application Data : bagian ini berisi dari inti ISO 8583
• Message Trailer : digunakan sebagai penanda akhir sebuah message atau pembeda antar message

Pada artikel ini, penulis hanya akan membahas mengenai application data dikarenakan hal yang paling banyak dibahas atau yang perlu dipelajari adalah pada bagian application data. Di dalam application data terdiri dari beberapa komponent yaitu : MTI (Message Type Indicator), Bitmap dan Data Element.

MTI (Message Type Indicator)

MTI (Message Type Indicator) adalah 4 digit angka yang berfungsi sebagai message utama dan penjelasan mengenai tentang tipe pesan.

Di dalam MTI terdapat 4 digit dimana 4 digit tersebut dibagi menjadi :

• Message Version : berfungsi mendefinisikan versi ISO 8583 yang digunakan, berikut adalah versi yang dapat digunakan :

• Message Class : berfungsi mendefinisikan tujuan message yang akan dikirim, berikut adalah tabel untuk message class.

• Message Function : berfungsi sebagai type dari message, misalnya apakah dia berupa request, response, advice dan lain - lain nya. berikut adalah tabel untuk message function.

• Message Origin berfungsi untuk mendefinisikan sumber pengirimkan data misalnya seperti acquirer (instansi keuangan yang menerbitkan kartu pembeli), issuer (instansi keuangan yang berhubungan langsung dengan mesin EDC penjual) dan lain - lain. erikut adalah tabel untuk message origin.

Berikut adalah contoh sederhana dari MTI.

0100 artinya Authorization Request dimana

• 0 -> ISO 8583 tahun 1987
• 1 -> Authorization message
• 0 -> Request
• 0 -> Acquirer

Contoh response nya 0110 artinya Authorization Response dimana

• 0 -> ISO 8583 tahun 1987
• 1 -> Authorization message
• 1 -> Request response
• 0 -> Acquirer

Bitmap

Bitmap adalah salah satu komponent dari ISO 8583 dimana terdiri dari 16 angka (dalam bentuk hexadecimal) atau lebih tergantung dari apakah terdapat secondary dan tertiary bitmap yang aktif.

Bitmap terdiri dari hexadecimal, dimana hexadecimal ini nantinya akan dirubah terlebih dahulu menjadi biner. Biner yang terdapat dalam bitmap yang telah dirubah dari hexadecimal menjadi biner berfungsi untuk melakukan lookup terhadap posisi data element yang akan digunakan. Untuk melakukan lookup terhadap posisi data element maka digunakan biner yang aktif, dimana biner yang aktif bernilai 1 sedangkan biner yang non aktif bernilai 0.

Di dalam bitmap, terdapat beberapa bitmap yaitu :

• Primary Bitmap : ini merupakan bitmap yang wajib untuk setiap ISO 8583, data element yang aktif pada bitmap ini yaitu dari biner 1 sampai 64.
• Secondary Bitmap : merupakan bitmap dengan data element yang aktif pada biner 65 sampai 128.
• Tertiary Bitmap : merupakan bitmap dengan data element yang aktif pada biner 129 sampai 192.

Cara Menghitung Bitmap Dari Hexadecimal

Untuk menghitung bitmap, maka kita perlu melakukan convert dari hexadecimal menjadi biner. Berikut adalah tabel convert yang biasanya digunakan.

Misalnya terdapat contoh bitmap : F23C449108E080000000000000000021

dimana bitmap diatas terdiri dari 32 karakter maka dapat dipastikan bitmap diatas terdapat Secondary bitmap. Cara merubah hexadecimal diatas menjadi biner adalah silakan pecah hexadecimal tersebut menjadi 2 digit lalu convert 1 digit hexadecimal menjadi biner seperti berikut.

Kemudian silahkan gabungkan seluruh binari tersebut menjadi seperti berikut.

11110010001111000100010010010001000010001110000010000000000000000000000000000000000000000000000000000000000000000000000000100001

Dari binari diatas dapat dilihat bahwa angka 1 menunjukkan bahwa binari aktif, berikut adalah binari yang aktif pada posisi : 1,2,3,4,7,11,12,13,14,18,22,25,28,32,37,41,42,43,49,123 dan 128.

Cara Menghitung Bitmap Dari Document Spesification

Hal yang terpenting selanjutnya adalah bagaimana cara membaca spec dari dokumen yang diberikan ketika pihak kita ingin melakukan request ke pihak lain. Pada artikel ini, penulis menggunakan dokumen NIBSS yaitu salah satu bank di negara nigeria. Dokumen tersebut dapat anda akses di Document Spesification NIBSS. Lalu silahkan buka halaman 7 pada bagian Authorization Request Response. Disana terdapat tabel yang berisi mengenai informasi posisi bit dan indicator dari bit tersebut. Pada artikel ini, kita hanya menggunakan mandatory bit. Berikut adalah bit yang digunakan yaitu pada bit 1,2,3,4,12,18,22,23,25,32,37,39,49,123,128. Mengapa bit 1 digunakan ? dikarenakan bit 1 menandakan terdapat secondary dikarenakan posisi bit sampai dengan 128.

Hal yang pertama dilakukan adalah silahkan tulis binari sebanyak 128 seperti berikut.

00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000

Lalu isikan bit 1 sesuai dengan posisi bit diatas maka hasilnya seperti berikut.

11110000 00010000
01000110 10000001
00001010 00000000
10000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00100001

Lalu silahkan convert binari diatas menjadi hexadecimal, misalnya hasil dari 11110000 adalah F0 dan 00010000 adalah 10 lalu substring dari awal hingga akhir. Jika hasil dari convert tersebut memberikan angka digit maka tambahkan angka 0 di depan nya misalnya hasil hexadecimal dari 00001010 adalah A maka tambahkan 0 di depan nya sehingga menjadi 0A. Dan hasilnya adalah.

F01046810A0080000000000000000021

Data Element

Data Element merupakan inti dari ISO 8583 dimana di dalam data element, semua informasi transaksi akan tersedia di dalam nya.

Di dalam data element, terdapat format data yang harus diperhatikan, misalnya panjang data nya, data nya hanya boleh berbentuk angka dan sebagainya. Berikut adalah format data untuk data element yang biasanya digunakan.

Contoh Data Element

Berikut adalah contoh dari data element

dari contoh diatas dapat dilihat bahwa misalnya data Primary account number (PAN) menunjukan n 19 yang menjelaskan bahwa PAN menggunakan type data number dengan length nya yaitu 19 angka.

Menyusun Contoh Message ISO 8583

Diatas adalah contoh dari data element untuk Financial Request Response, maka kita akan menggunakan MTI 0210. Data element yang digunakan adalah pada posisi 2,3,4,12,18,22,23,25,32,37,39,49,123 dan 128 sehingga silahkan buat binari 128 dan hasilnya seperti berikut.

11110000 00010000
01000110 10000001
00001010 00000000
10000000 00000000
00000000 00000000
00000000 00000000
00000000 00000000
00000000 00100001

Maka hasil hexadecimal nya adalah

F01046810A0080000000000000000021

Lalu untuk data element maka silahkan concat seluruh data berdasarkan urutan nya maka hasilnya menjadi seperti berikut.

92581234124234567A000011000000007232000101233211101RRN00100100A1016AA107B5118BC17D

maka kesimpulan nya adalah

MIT          : 0210
Bitmap       : F01046810A0080000000000000000021
Data Element : 92581234124234567A000011000000007232000101233211101RRN00100100A1016AA107B5118BC17D
Message ISO 8583 : 0210F01046810A008000000000000000002192581234124234567A000011000000007232000101233211101RRN00100100A1016AA107B5118BC17D

Message ISO 8583 yang akan dikirim adalah dalam bentuk

0210F01046810A008000000000000000002192581234124234567A000011000000007232000101233211101RRN00100100A1016AA107B5118BC17D

Sekian artikel mengenai Belajar ISO 8583 dan terima kasih :).