Sejujurnya, saya tidak begitu merasakan perbedaan yang signifikan antara 

, keduanya dapat saya bilang seperti HTTP Clients saja. 

-nya adalah satu-satunya yang menarik perhatian saya. 

What does exactly "declarative" mean? Let's dive deeper.

 Spring yang berguna untuk melakukan HTTP 

 ke sebuah API. Kita bisa menggunakan RestTemplate untuk melakukan berbagai macam HTTP request, seperti 

. Selain itu, RestTemplate juga mendukung fitur untuk mengatur 

 yang juga berguna untuk melakukan komunikasi antar aplikasi. OpenFeign menyediakan 

 yang bisa kita implementasikan untuk mengakses API. Setiap 

 pada interface tersebut akan merepresentasikan HTTP request yang akan dilakukan terhadap sebuah API. OpenFeign juga mendukung fitur 

Kedua cara ini memiliki kelebihan dan kekurangan masing-masing. Berikut adalah beberapa perbandingan antara Spring RestTemplate dan OpenFeign:

Spring RestTemplate membutuhkan konfigurasi yang lebih banyak dibandingkan OpenFeign. Kita harus menambahkan dependensi Spring Web dan RestTemplate pada project kita, serta menambahkan bean RestTemplate di konfigurasi Spring kita.

OpenFeign hanya membutuhkan dependensi OpenFeign dan menambahkan annotation 

Spring RestTemplate menyediakan kelas yang bisa kita gunakan langsung untuk melakukan HTTP 

 yang disediakan oleh kelas tersebut sesuai dengan kebutuhan kita.

 yang harus kita implementasikan untuk mengakses API. Setiap method pada 

Spring RestTemplate lebih fleksibel dibandingkan OpenFeign. Kita bisa dengan mudah mengubah setiap aspek dari 

yang telah ditentukan. Kita hanya bisa mengubah aspek-aspek 

Spring RestTemplate lebih cocok digunakan untuk 

 yang membutuhkan fleksibilitas dan kontrol yang lebih besar terhadap proses komunikasi antar aplikasi. RestTemplate bisa digunakan untuk komunikasi dengan protokol selain HTTP, seperti FTP atau SMTP.

 yang membutuhkan implementasi yang lebih sederhana dan terstruktur dalam komunikasi antar aplikasi. 

, perlu diingat bahwa OpenFeign hanya dapat digunakan untuk komunikasi dengan protokol HTTP.

Berikut ini adalah contoh sederhana implementasi Spring RestTemplate dan OpenFeign untuk melakukan HTTP GET request ke API sederhana yang mengembalikan data "Hello, World!".

 pada kelas RestTemplate untuk melakukan HTTP 

ini akan mengembalikan objek yang sesuai dengan tipe data yang kita tentukan (dalam contoh di atas, tipe data yang dikembalikan adalah 

Pastikan untuk menambahkan dependensi yang diperlukan pada project kita, seperti 

 oleh OpenFeign). Juga pastikan bahwa konfigurasi Spring sudah mengaktifkan 

Spring RestTemplate dan OpenFeign adalah dua cara populer untuk melakukan komunikasi antar aplikasi di dunia Java. Namun pilihan terbaik antara Spring RestTemplate dan OpenFeign akan tergantung pada kebutuhan dan karakteristik 

 yang sedang kita kerjakan. Jika kita membutuhkan fleksibilitas yang lebih tinggi dalam mengubah aspek-aspek request, maka Spring RestTemplate mungkin lebih cocok untuk kita. Namun, jika kita ingin implementasi yang lebih sederhana dan terstruktur, maka OpenFeign mungkin lebih cocok untuk kita.

: Feign memungkinkan kita untuk tidak perlu menulis 

 yang mengimplementasikan komunikasi dengan sebuah API yang akan kita akses, sehingga penggunaan Feign sangat memudahkan proses pembuatan 

OpenFeign/feign: Feign makes writing java http clients easier

Using Feign REST Client for Service Invocation

So, it's 2022 and I just heard about OpenFeign. Guess I'm a bit late but I gave it a try, and...is it more advantageous than 

Feign: Spring RestTemplate Alternatives? [Bahasa]

". This phrase is often used to emphasize the importance of creating effective logs that provide clear and concise information about events and issues within an application. A good log should be 


Just as a fairytale tells a clear and concise story that is easy to understand and follow, a good log should provide the same quality of information about events and issues within an application. This can make it easier to manage and troubleshoot issues within your application, and can provide valuable information for tracking and analyzing specific events and issues within your system.


Basically, a good log should include details such as the time the event occurred, the logging level (e.g. 

), a descriptive message about the event, and any relevant context or additional details.

For example, a simple good log might look like this:

This log includes the time the event occurred, the logging level (

), and a clear message about the event (user logged in successfully).

But to leverage this to be more informative, it's also helpful to include context within the log message, such as the user's username or the specific action they took. For example:

Including context within the log message can make it easier to understand the log and track specific events within the system.

Only Experienced Software Engineers Know The Importance of Logging

Let me start with a short fictional story:

Alice is a junior software engineer who is working on a new application. She is responsible for implementing a feature that allows users to search for products within the application.

Alice is so focused on getting the feature working as quickly as possible, and does not think about the importance of logging. As a result, she does not include any logging code in her implementation.

A few days later, the application is deployed to production and users start reporting errors when using the search feature. Alice is unable to reproduce the errors in her development environment, and is unable to understand what is causing the errors.

Bob, an experienced software engineer who is working on the same project, recognizes the importance of logging and suggests that Alice include logging code in her implementation to help understand and troubleshoot the errors.
Alice follows Bob's advice and adds logging code to the implementation.

With the help of the log data, Alice is able to understand the root cause of the errors and fix the issue. Without the log data, Alice would have had a much harder time understanding and troubleshooting the issue, and it might have taken significantly longer to fix the issue.

Now from this simple story, I assume we all agree that logging is an important aspect of software engineering. It is a critical tool for understanding and troubleshooting issues within an application, and can provide valuable information for tracking and analyzing specific events and issues within your system.


Experience is often an important factor in understanding the importance of logging. As software engineers gain experience working on different types of applications and systems, they often come to appreciate the value of logging as a tool for managing and troubleshooting issues.


Good logging requires a good understanding of the various types of logs that are available, as well as the layout and format of log messages. It also requires an understanding of how to effectively use logging tools and frameworks to manage and analyze log data.

These skills are often developed over time through experience working with different types of applications and systems.

Now that we understand how important logging is, the next question is, how do we write a good log? The key of a good log is as I mentioned, clear and concise. It must provide 

 about the event or issue being logged without overwhelming the reader with unnecessary details.

And that comes to another strategy to pick if an information provided in the logs is valuable. This is what we call effective logging.


There are a few key pieces of information that should be included in order to create effective logging:

Timestamps: Timestamps should be included in log messages to provide a reference point for when the event or issue being logged occurred. This can be particularly useful for understanding the sequence of events and for tracking the duration of events or issues.

Event or issue details: Log messages should include clear and concise information about the event or issue being logged. This can include details about the type of event or issue, as well as any relevant context or additional details that may be useful for understanding and troubleshooting the issue.

Relevant context: Log messages should include relevant context and additional details as needed. Relevant means no unnecessary information being told. For  example, information about the user or system that triggered the event or issue, or the request and response being sent , as well as any other relevant details that may be useful for understanding and troubleshooting the issue.

Log levels: Log messages should include log levels to indicate the severity of the event or issue being logged. This can help prioritize and prioritize issues based on their severity, and can be particularly useful for filtering log data to focus on specific types of events or issues.

So now, let's see how we would usually do the logging in our application.

There is nothing wrong about this logging way. But if we see more closely that in this example, the logging code is included directly within the 

 method, which means that you would need to include similar logging code in every method where you want to log events. This can be repetitive and can make it difficult to manage and maintain logging in your application.


And this is when it comes to the point where we might reconsider writing such repetitive code in this way and take a look at Aspect Oriented Programming (AOP).

Let's see how we write same functional code as above using AOP.

and we can totally remove the logging code in our 

Now you see that we don't really write logging code in the 

 method like before, instead we remove it. But I assure you, it works the same. How could it be possible?


Aspect Oriented Programming (AOP) is a programming paradigm that allows you to manage cross-cutting concerns (e.g. logging, security, transactions) in a 

. Using AOP can help you create an effective logging system for your application that is easy to manage and maintain, and provides valuable context for tracking and analyzing specific events and issues within your system.


As you can see in the comparison above, using AOP can make it easier to manage and maintain logging in your application, as you only need to update the logging aspect rather than searching for and updating logging code throughout your application.

In addition to using AOP to manage logging in a centralized and modular way, you can also use the Mapped Diagnostic Context (MDC) feature in Java Spring to add context to your logs. MDC allows you to add key-value pairs to the current thread's context, which can then be included in your logs. And this is very useful when it comes to provide valuable information we need in the log.


For example, you might use MDC to add the 

 and user information to your logs, like this:

Using MDC in this way allows you to add context to your logs centralized and modular just as AOP does. You can use the 

 method to add key-value pairs to the MDC, and the 

 method to remove them when they are no longer needed.


MDC provides a way to enrich log messages with information that could be unavailable in the scope where the logging actually occurs but that can be indeed useful to better track the execution of the program. 👍

After the log is written in this way, it comes to the next moment of truth to prove its effectiveness and usefulness, it is monitoring time. What is all the purpose of all this if it is not for this, right? Now you might think that some of us still do monitoring like this.

Don't get me wrong. Monitoring our system's logs in this way is absolutely fine. I still find that using terminal to log into system is still the fastest way especially when you want to go 

But what if I tell you that we can have easier and more comprehensive way viewing this data via table-like format? It can give us better point of view especially when it comes to data analysis. 

As you see in the picture above, that is the power of Elasticsearch. Elasticsearch is an open-source search and analytics engine that is commonly used to search, analyze, and visualize log data. Elasticsearch is designed to be highly scalable and efficient, and can handle a large volume of log data in real-time.


Using a table-like format for your logs can make it easier to read and analyze log data, especially when using tools like Kibana, which provides a visual interface for viewing and analyzing log data.

To create a table-like format for your logs, you can use a structured logging library or framework that allows you to include log data in a structured format, such as JSON. Structured logging libraries and frameworks provide a consistent and standardized way to include log data in a structured format, making it easier to read and analyze log data.

Here is an example of a log message in JSON format using Logback:

In this example, the log data is included in a structured format with clearly defined fields for the timestamp, logging level, request ID, user, and message. This makes it easier to read and analyze the log data, and also allows tools like Kibana to easily extract and display the log data in a table-like format.


By using a structured logging library or framework and including log data in a structured format, you can create logs that are easy to read and analyze, especially when using tools like Kibana. 

Now that we have learned how important logging is, how to effectively doing it, also combine it with Elasticsearch, I hope this information could help 

to be a better developer through enhancing this aspect. 

To close this, I would like to add some tips for creating effective logs in your application:

Choose a logging library that meets your needs. Some popular logging libraries for Java include 

Create a logging configuration file that is appropriate for the logging library you are using. This file will control how logging is configured, such as the logging level, output, and format. You can find more detailed documentation on how to configure this file on the website of the logging library you are using.

For specific framework like Spring, use the 

 annotation in the class you want to log. This annotation will create a logger variable that can be used to manage logging in that class. You can use commands like 

. The logging level is responsible for determining the importance of a log, such as 

. Use higher levels only for logs that are truly important, so you can minimize the number of logs displayed and make logging more effective.

Use the appropriate format for your logs. A good format will include important information such as the time, logging level, and log message, as well as provide useful context for understanding the log. You can use placeholders like 

 to display the desired information within your log.

 to the log. It helps to know the whole flow of a certain request so that we can have a better point of view when inspecting what happened in specific error.

Enriching logs with Docker metadata using Filebeat | Elastic Blog

For further steps, you can read how to implement all these into a simple working project on this 

Logs are an important aspect of software engineering that provide valuable information for understanding and troubleshooting issues within an application. Logs can be used to track and analyze specific events and issues within your system, and can provide valuable insights into the operation and performance of your application.


If that issues occured in your system, have your logging system been good enough to tell you what happened and could it lead you to an effective solving?

Better Support Experience with Meaningful Logging

, tentu sangat penting untuk berkomunikasi dengan 

mengenai API apa saja yang kita sediakan dan dapat digunakan oleh tim 

 yang diperlukan adalah dokumentasi yang sering disebut sebagai 


Cara paling mudah ya bisa saja dengan dokumen sederhana seperti Word atau Excel. 

karena program-program semacam ini tidak spesifik diperuntukan untuk pembuatan dokumentasi, 

Sulit untuk membuat dokumentasi yang jelas, detil, terstruktur dan terorganisir dengan baik. 

dibuat standarisasi format mengenai bagaimana dokumen ini dibuat, dokumentasi semacam ini akan sulit untuk dikonsumsi.

 seperti Word atau Excel, kita memerlukan 

dan tanpa adanya program ini, dokumentasi tidak dapat digunakan.

Dokumen semacam ini biasanya statis dan tidak 

terjadi pada API, dokumentasi ini akan dengan cepat menjadi 

API kita melalui sebuah UI yang interaktif dan dapat langsung di-

dan sudah cukup banyak integrasinya ke banyak 

salah satunya yang akan kita gunakan, Spring Boot. Konfigurasinya pun sangat mudah, bahkan 

 😂 

Lalu bagaimana bentuk Swagger ini 

API kita? Nah, nantinya, dokumentasi API kita yang dapat dikonsumsi oleh tim 

Bahkan, Swagger memungkinkan kita untuk melakukan 

API tersebut, sehingga penerima dokumentasi dapat langsung melakukan verifikasi dengan cepat (

) apakah API yang kita sediakan dapat mereka pergunakan atau tidak.


Selain itu, Swagger dirancang khusus untuk keperluan dokumentasi API dan sudah sesuai dengan standar 

. Oleh karena itu hasil dokumentasi dari Swagger dapat dengan mudah dan jelas untuk digunakan oleh para 

. Ditambah lagi, Swagger juga sudah menyediakan fitur-fitur seperti 

. Swagger menjamin dokumentasi yang dihasilkan menjadi tetap akurat dan 

Untuk mencoba menggunakan Swagger, kita akan menggunakan project backend API yang saya tulis untuk materi program BCA Advisory Program yaitu 

Advisory Program 2022 (Chapter 1) : Create Your First API

Selanjutnya buat file baru untuk melakukan konfigurasi Swagger. Pada 

Ini adalah konfigurasi minimal yang perlu kita lakukan untuk Swagger. Perlu diperhatikan bahwa kita mendefinisikan 

terhadap komponen-komponen di dalam project kita. Ubah value properti ini sesuai dengan struktur project kalian.

Berikutnya, kita perlu mengaktifkan Swagger dan WebMvc. Aktifasi Swagger dapat kita lakukan melalui anotasi 

. Sedangkan WebMvc diaktifkan dengan anotasi 

. Sebagai informasi, Swagger UI sudah menyediakan UI-nya sendiri, dimana di dalamnya tentu terdapat komponen-komponen 

apabila digunakan untuk membuat aplikasi web yang dapat menghasilkan UI. Salah satu syaratnya, dengan mengaktifkan modul MVC di dalamnya. Inilah alasan mengapa kita memerlukan aktifasi WebMvc.

, kita perlu memberi tahu Spring, bahwa kita menggunakan 

halaman UI Swagger tadi. Tambahkan konfigurasi 

, dengan menggunakan Swagger, kita baru saja membuat dokumentasi API yang jelas, interaktif, mudah digunakan, dan terorganisir hanya dalam 3 langkah! 

bukan? Bayangkan apabila kita perlu membuat dokumen ini menggunakan Word atau Excel 😵‍💫


Untuk mengakses dokumentasi kita, cukup buka browser dan arahkan ke URL aplikasi kita dengan tambahan path 

lah untuk mengetahui apa saja yang sudah di-

untuk kita. Swagger memiliki konfigurasi yang sangat 

dapat lakukan konfigurasi sendiri sesuai 

mengenai integrasi kedua sistem. Bagaimana sebaiknya dokumentasi dibuat?

Easy and Fast API Delivery with Swagger

Sebelum memulai masuk lebih dalam, ada beberapa program yang

Menjelaskan instalasi masing-masing program tersebut akan memakan waktu dan membuat tulisan ini menjadi lebih panjang dan melebar, 

bisa mencari referensi di internet ya, banyak sekali kok 😁

Perlu diketahui bahwa pada program ini saya tidak menjelaskan mengenai tutorial, misalnya tutorial Java, tutorial Spring atau tutorial Angular. Namun apa yang saya jelaskan lebih ke bagaimana implementasi 

tertentu pada aplikasi sederhana dan integrasinya berdasarkan konsep yang dibahas, seperti misalnya model arsitektur, mengapa menggunakan 


Hal ini saya tujukan karena materi seperti tutorial-tutorial tersebut sangat mudah 

. Nyatanya, saya sendiri pun belajar banyak dari platform-platform tersebut. Akan sangat memakan waktu dan tenaga apabila saya berusaha membuat tutorial serupa yang berulang dimana saya sendiri tidak begitu yakin bahwa 


Ditambah lagi, saya ingin berfokus pada hal-hal lain yang lebih diperlukan pada dunia industri profesional. Misalnya seperti desain arsitektur aplikasi, 

, tips & trik, atau bahkan sekedar memperkenalkan 

atau teknologi yang mungkin belum dikenal sebelumnya namun banyak digunakan di pekerjaan nantinya.

peserta program untuk dapat lebih dahulu mempelajari konsep dasar dari 

yang akan digunakan, misalnya seperti mengerti konsep dasar Java, OOP, Javascript, database, dll. Hal ini akan membantu 

dalam mengikuti program ini dengan lebih efektif.

, atau juga dikenal BFF, terdiri dari paling sedikit dua bagian utama, yaitu 

biasanya berperan sebagai perantara dalam bentuk API untuk berhubungan dengan bagian "dalam" aplikasi seperti database, 

bagi pengguna agar dapat berinteraksi dengan aplikasi kita. Arsitektur ini sudah sangat 

digunakan dalam membangun aplikasi terutama aplikasi berbasis web.

Tapi, kenapa kita perlu memisahkan frontend dengan backend 

? 

Ada beberapa alasan kenapa kita perlu melakukan pemisahan ini. Berdasarkan pengalaman saya pribadi, dua hal terpenting untuk melakukan separasi ini adalah alasan 

. Namun, di artikel ini saya tidak akan membahas mengenai hal tersebut, kita akan bahas lagi lain waktu.

Sebagai referensi, 

Gambaran arsitektur aplikasi yang akan kita bangun berdasarkan pemisahan tersebut adalah sebagai berikut.


Teknologi yang akan kita gunakan untuk membangun aplikasi sederhana kita adalah Spring Boot untuk 

dimana kita akan menggunakan komponen-komponen seperti Spring Web MVC untuk membuat REST API, Spring Data JPA untuk berinteraksi dengan 

, kita akan menggunakan PostgreSQL saja untuk kemudahan.


Apabila kamu belum familiar dengan API, 


Nah, aplikasi yang akan kita buat adalah aplikasi 

 sederhana dimana pengguna dapat menambahkan 

. Kurang lebih, API yang akan kita buat nantinya adalah berikut ini.

Java adalah bahasa pemrograman yang dapat dibilang "tua", dan di zaman sekarang ini banyak developer yang mungkin sudah tidak menggunakannya lagi. Berkaitan dengan hal tersebut, 

  mengenai mengapa saya masih menggunakan Java hingga saat ini😁

tidak akan kesulitan mendapatkannya di internet. Namun dalam perjalanan saya bersama Java selama kurang lebih 10 tahun ini, 

tidak ada yang lebih mudah melakukan Java development daripada menggunakan Spring sebagai 


Menurut saya, sepertinya di luar sana Spring sudah menjadi "

. Memang banyak alternatif lain selain Spring, seperti Struts, JSF, Vaadin, Grails, 

kita mendapatkan pengalaman pemrograman yang lebih mudah, lebih cepat, dan lebih aman.


Untuk lebih lengkap silakan cek link ini, 

Untuk membuat aplikasi Spring Boot, Spring telah menyediakan sebuah 

 yang memudahkan kita untuk memulai, yaitu 

. Sebenarnya ada juga cara lain seperti membuat sebuah Maven project kemudian kita tambahkan Spring Boot 


Pada Spring Initialzr, saya akan menggunakan Maven untuk 

nya dengan Java 11 untuk versinya. Untuk versi Java sendiri 

dapat memilih versi java 8 atau bahkan 17. Namun saat 

ini saya tulis, Java 11 adalah versi menengah yang tidak terlalu tertinggal dan juga tidak terlalu baru (cenderung stabil).


Nah kemudian, kita perlu untuk menambahkan 

 kita. Kalau kalian bingung dengan istilah 

Spring Web (komponen Spring utama yang kita butuhkan untuk membuat aplikasi Spring Web atau REST API dengan Spring)

Spring Data JPA (diperlukan untuk berinteraksi dengan 

Lombok (sebuah library yang sangat berguna untuk memudahkan kita dalam menuliskan program Java, terutama untuk mempersingkat dan mengurangi redundansi yang tidak perlu)

berikut adalah konfigurasi Spring Initialzr kita.

bagi saya, IDE ibarat agama, jadi saya tidak mengharuskan 

untuk mengikuti dengan IDE yang saya gunakan. 

But in my development, most of the time I will go with 

tidak punya preferensi IDE dan ingin menggunakan VSCode juga, silakan kalian dapat 

Spring kita ke IDE ada banyak cara, namun secara umum, cari opsi seperti 

dapat menggunakan cara yang lebih singkat dengan klik kanan pada folder 

Nah, sebelum kita melangkah lebih dalam, ada baiknya kita lebih dulu mengerti apa saja 

 yang mungkin akan kita ubah adalah filel 

baru atau ada konfigurasi Maven khusus yang perlu dilakukan.

BLOG TAG

Spring Boot

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run". We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need minimal Spring configuration.

Here are some articles tagged with "Spring Boot" :