Mastering Spring Boot Customization SC Guide

කොහොමද යාලුවනේ! අද අපි කතා කරමු අපේ දිනපතා වැඩ වලට නැතුවම බැරි වුණු Spring Boot ගැන. Spring Boot කියන්නේ development process එක පුදුම විදිහට පහසු කරන framework එකක් කියලා ඔයාලා දන්නවා. ඒකේ තියෙන auto-configuration, starters වගේ දේවල් නිසා code කරන්න පටන් ගන්න එක හරිම ලේසියි. ඒත් හැම වෙලාවෙම Spring Boot එකෙන් දෙන default settings අපිට හරියන්නේ නෑ නේද? සමහර වෙලාවට අපිට ඕන වෙනවා අපේ project එකේ විශේෂ අවශ්‍යතා අනුව මේ default behavior එක වෙනස් කරන්න, අපිට ඕන විදිහට custom කරන්න. අන්න ඒ වෙලාවට තමයි Spring Boot Customization කියන concept එක වැදගත් වෙන්නේ.

මේ ලිපියෙන් අපි බලමු Spring Boot එකේ auto-configuration සහ starters කියන්නේ මොනවද කියලා, ඒ වගේම අපිට කොහොමද මේවා customize කරන්න පුළුවන් කියලා. විශේෂයෙන්ම, default bean configuration එකක් override කරලා අපිට ඕන විදිහට වැඩ කරවගන්න පුළුවන් කොහොමද කියලා අපි practical example එකක් එක්ක කතා කරමු.

Spring Boot Magic: Auto-Configuration සහ Starters

මුලින්ම අපි පොඩ්ඩක් මතක් කරගමු Spring Boot එහෙම ලේසියෙන් වැඩ කරන්නේ කොහොමද කියලා. මේකේ ප්‍රධානම magic එක තමයි auto-configuration. ඒ කියන්නේ, ඔයා project එකට add කරන dependencies අනුව (උදාහරණයක් විදිහට, database එකකට සම්බන්ධ වෙන්න spring-boot-starter-data-jpa එක add කළොත්) Spring Boot එකෙන් automatic ව project එකට අවශ්‍ය configurations ටික හදලා දෙනවා. Database connection pools, Hibernate setup, Web servers (like Tomcat or Jetty) වගේ දේවල් ගැන අපිට වද වෙන්න ඕන වෙන්නේ නෑ. හරිම පහසුයි නේද?

ඊළඟට starters. මේවා කියන්නේ එකිනෙකට සම්බන්ධ dependencies ටිකක් එකට pack කරලා තියෙන sets වගයක්. උදාහරණයක් විදිහට, spring-boot-starter-web එක add කළොත් ඒක ඇතුළේ Spring MVC, Tomcat, Jackson JSON processor වගේ web application එකකට අවශ්‍ය හැම දෙයක්ම තියෙනවා. මේවා නිසා project එකක් හදනකොට අවශ්‍ය dependencies එකින් එක manually add කරන්න ඕන වෙන්නේ නෑ. ඒත්, මේ පහසුවත් එක්ක පොඩි අවාසියකුත් තියෙනවා. ඒ තමයි, සමහර වෙලාවට මේ auto-configured දේවල් අපේ specific requirements වලට හරියන්නේ නැති එක. අන්න එතකොට තමයි අපි customization ගැන හිතන්න ඕන.

ඇයි අපිට Customize කරන්න ඕන? (Why do we need to customize?)

දැන් ඔයාලා හිතනවා ඇති, “Spring Boot එකෙන් ඔක්කොම හරි කරනවා නම්, ඇයි අපිට customize කරන්න ඕන?” කියලා. මේකට හේතු කීපයක් තියෙනවා:

• Default settings මදි වුණාම: සමහර අවස්ථාවලදී Spring Boot එකෙන් දෙන default settings අපේ production environment එකකට හෝ project එකේ විශේෂිත අවශ්‍යතාවයකට මදි වෙන්න පුළුවන්. උදාහරණයක් විදිහට, database connection pool එකේ size එක වැඩි කරන්න, හෝ thread pool එකක settings වෙනස් කරන්න වගේ දේවල්.
• විශේෂිත පරිසරයන්ට අනුව හදන්න: Development, testing, production වගේ වෙනස් පරිසරයන්ට අවශ්‍ය වෙනස් configurations තියෙන්න පුළුවන්. ඒ වගේ වෙලාවට අපිට ඒ ඒ පරිසරයට අදාළව auto-configuration එක adjust කරන්න ඕන වෙනවා.
• Performance optimization: සමහර components වල default behavior එක, අපේ application එකේ performance එකට බලපාන්න පුළුවන්. ඒ වගේ වෙලාවට custom settings දාලා performance එක improve කරන්න පුළුවන්.
• Legacy systems එක්ක integrate කරනකොට: පරණ system එකක් එක්ක integrate කරනකොට, Spring Boot එකෙන් දෙන default configurations හරියන්නේ නැති වෙන්න පුළුවන්. එතකොට අපිට custom configurations ලියන්න වෙනවා.
• Bean conflicts: කලාතුරකින් වුණත්, dependency conflicts හෝ වෙනත් හේතු නිසා Spring Boot එකෙන් හදන bean එකක් අපේ application එකේ තවත් bean එකක් එක්ක ගැටෙන්න පුළුවන්. ඒ වගේ වෙලාවට default bean එක override කරන්න වෙනවා.

ඉතින් මේ වගේ අවස්ථාවලදී Spring Boot customization කියන එක අපිට ගොඩක් වැදගත් වෙනවා.

Auto-Configuration Disable කරන්නේ කොහොමද? (How to disable Auto-Configuration?)

සමහර අවස්ථාවලදී අපිට අවශ්‍ය වෙනවා Spring Boot එකෙන් කරන specific auto-configuration එකක් disable කරන්න. මේක කරන්න ක්‍රම දෙකක් තියෙනවා:

application.properties හෝ application.yml file එක පාවිච්චි කරලා:මේක තවත් පහසු ක්‍රමයක්. ඔයාගේ application.properties (හෝ .yml) file එකට මේ line එක add කරන්න පුළුවන්:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

එකකට වඩා classes disable කරන්න ඕන නම් comma වලින් වෙන් කරලා දෙන්න පුළුවන්:

spring.autoconfigure.exclude=\n  org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\n  org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration

සාමාන්‍යයෙන් application.properties එකෙන් කරන එක තමයි පහසුම සහ recommend කරන ක්‍රමය. මොකද project එකේ code එක වෙනස් කරන්නේ නැතුව configuration එක විතරක් වෙනස් කරන්න පුළුවන් නිසා.

@SpringBootApplication annotation එක පාවිච්චි කරලා:ඔයාගේ main application class එකේ තියෙන @SpringBootApplication annotation එකට exclude attribute එක add කරලා, ඔයාට disable කරන්න අවශ්‍ය auto-configuration class එක specify කරන්න පුළුවන්. උදාහරණයක් විදිහට, ඔයාට Spring Boot එකෙන් auto-configure කරන DataSource එක disable කරන්න ඕන නම්, මේ විදිහට කරන්න පුළුවන්:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyAppApplication {

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

Custom Beans හදමු, Default Beans Override කරමු! (Let’s create Custom Beans, Override Default Beans!)

දැන් අපි යමු මේ ලිපියේ ප්‍රධානම කොටසට. ඒ තමයි, Spring Boot එකෙන් auto-configure කරන default bean එකක් override කරලා අපේම custom bean එකක් නිර්මාණය කරගන්න එක. මේ සඳහා අපි RestTemplate එක උදාහරණයට ගමු. RestTemplate කියන්නේ RESTful web services consume කරන්න පාවිච්චි කරන Spring class එකක්. Spring Boot එකෙන් default RestTemplate bean එකක් auto-configure කරනවා.

Example: Default RestTemplate Bean එක Override කිරීම

අපිට අවශ්‍යයි custom timeout settings තියෙන RestTemplate එකක් පාවිච්චි කරන්න. Spring Boot එකෙන් දෙන default RestTemplate එකේ request timeout එකක් නෑ. ඉතින් අපි ඒක හදමු.

පියවර 1: RestTemplate එකක් පාවිච්චි කරන සාමාන්‍ය Application එකක්

මුලින්ම අපි බලමු, RestTemplate එකක් පාවිච්චි කරන පොඩි application එකක් කොහොමද කියලා. ඔයාගේ service layer එකේ මේ වගේ code එකක් තියෙන්න පුළුවන්:

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyRemoteService {

    private final RestTemplate restTemplate;

    public MyRemoteService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String getDataFromRemoteApi() {
        // Default RestTemplate එක මෙතනදි පාවිච්චි වෙනවා
        return restTemplate.getForObject("https://jsonplaceholder.typicode.com/todos/1", String.class);
    }
}

මේ RestTemplate එක Spring Boot එකෙන් auto-configured වෙලා අපේ service එකට inject වෙනවා.

පියවර 2: Custom RestTemplate Bean එකක් නිර්මාණය කිරීම

දැන් අපි බලමු, අපේම custom RestTemplate bean එකක් හදලා, Spring Boot එකෙන් දෙන default එක override කරන්නේ කොහොමද කියලා. මේකට අපි @Configuration annotation එකක් පාවිච්චි කරලා configuration class එකක් හදන්න ඕන.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.boot.web.client.RestTemplateBuilder;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate customRestTemplate(RestTemplateBuilder builder) {
        return builder
                .setConnectTimeout(java.time.Duration.ofSeconds(3))
                .setReadTimeout(java.time.Duration.ofSeconds(5))
                .build();
    }
}

මේ class එකේ අපි @Bean annotation එක පාවිච්චි කරලා customRestTemplate කියලා method එකක් හදලා තියෙනවා. මේ method එකෙන් return කරන්නේ අපිට අවශ්‍ය timeout settings එක්ක build කරපු අලුත් RestTemplate instance එකක්. මෙතනදී Spring Boot එකෙන් provide කරන RestTemplateBuilder එක පාවිච්චි කරන එක recommended. මොකද ඒකෙන් Spring Boot එකේ Message Converters, Error Handlers වගේ දේවල් auto-apply කරන නිසා.

වැදගත් දේ: @ConditionalOnMissingBean Magic එක

දැන් ඔයාලා හිතනවා ඇති, “Spring Boot එක දැනටමත් RestTemplate bean එකක් හදනවා නම්, අපි තව එකක් හැදුවම conflict වෙන්නේ නැද්ද?” කියලා. අන්න එතන තමයි Spring Boot එකේ තියෙන @ConditionalOnMissingBean කියන annotation එකේ බලය තියෙන්නේ.

Spring Boot එකේ auto-configuration classes (RestTemplateAutoConfiguration වගේ) ඇතුළේ default beans define කරලා තියෙන්නේ @ConditionalOnMissingBean කියන condition එක එක්ක. ඒ කියන්නේ, “මේ type එකේ bean එකක් Spring Context එකේ නැත්නම් විතරක් මාව හදන්න” කියලා. ඉතින්, අපි අපේම custom RestTemplate bean එකක් define කරපු ගමන්, Spring Boot එකේ default auto-configuration එක disable වෙනවා, මොකද Spring Context එකේ ඒ type එකේ bean එකක් දැනටමත් තියෙන නිසා.

මේක Spring Boot customization වල තියෙන ලොකුම වාසියක්. අපිට අවශ්‍ය නම් default behavior එක පාවිච්චි කරන්න පුළුවන්. අවශ්‍ය නැත්නම් අපේම custom implementation එකක් දාලා ඒක override කරන්න පුළුවන්. කිසිම ගැටුමක් නැතුව Spring Context එක smart විදිහට තීරණය කරනවා මොන bean එක පාවිච්චි කරන්න ඕනද කියලා.

තවත් Customization ක්‍රම

@Bean annotation එක පාවිච්චි කරලා default beans override කරන එකට අමතරව තවත් customization ක්‍රම ගොඩක් තියෙනවා:

• Properties files (application.properties / application.yml): සරල customizations සඳහා මේවා පාවිච්චි කරන්න පුළුවන්. උදාහරණයක් විදිහට, server port එක, database URLs, logging levels වගේ දේවල්. මේවා තමයි ගොඩක් වෙලාවට අපි පාවිච්චි කරන්නේ.
• Custom Annotations: ඔයාට අවශ්‍ය නම් ඔයාගේම custom annotations හදලා, ඒ හරහා configurations apply කරන්න පුළුවන්.
• Event Listeners: Spring Boot application lifecycle events වලට listen කරලා, specific points වලදී custom logic execute කරන්න පුළුවන්.
• Profile-specific configurations: application-dev.properties, application-prod.properties වගේ files පාවිච්චි කරලා, වෙනස් environment වලට අවශ්‍ය වෙනස් configurations manage කරන්න පුළුවන්.

අවසානයට

ඉතින් යාලුවනේ, ඔයාලා දැක්කා නේද Spring Boot කියන්නේ නිකම්ම "magic" එකක් නෙවෙයි, අපිට අවශ්‍ය විදිහට customize කරන්න පුළුවන් බලවත් tool එකක් කියලා. Auto-configuration එකේ පහසුව විඳිමින්ම, අවශ්‍ය වෙලාවට අපේ project එකේ විශේෂිත අවශ්‍යතා අනුව customize කිරීමේ හැකියාව Spring Boot අපිට ලබා දෙනවා.

මේ customization හැකියාව නිසා අපිට පුළුවන් අපේ applications වඩාත් flexible, maintainable, සහ performance-oriented විදිහට හදන්න. අද අපි කතා කළා auto-configuration disable කරන විදිහ සහ default bean එකක් override කරලා අපේම custom bean එකක් හදන විදිහ ගැන. මේ knowledge එක ඔයාලගේ දිනපතා Spring Boot development වලට ගොඩක් උදව් වෙයි කියලා මම හිතනවා.

ඔයාලත් මේ දේවල් ඔයාලගේ project වලට apply කරලා බලන්න. මොකද theory විතරක් මදි, practical experience එක තමයි වැදගත්. මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් comment කරන්න. මේ වගේ තවත් දේවල් දැනගන්න ඕන නම් කියන්න! අපි ඊළඟ ලිපියෙන් හම්බවෙමු! සුභ දවසක්!