Spring Boot Project Setup: Initializr, Maven/Gradle, Hello World - SC Guide | Spring Boot ආරම්භය

කොහොමද යාලුවනේ! 👋

අද අපි ලංකාවේ IT ලෝකේ ගොඩක්ම ජනප්‍රිය වෙලා තියෙන, Java Backend Development වලට නැතිවම බැරි දෙයක් ගැන කතා කරන්නයි යන්නේ. ඒ තමයි Spring Boot! Spring Boot කියන්නේ Java Application හදන්න තියෙන සුපිරිම Framework එකක්. ලොකු Company වල වගේම Startup වලත් ගොඩක් දෙනෙක් මේක පාවිච්චි කරනවා. මොකද මේකෙන් අපිට පුළුවන් ගොඩක් ඉක්මනට robust, production-ready applications හදන්න.

අපේ රටෙත් Spring Boot developer ලාට ලොකු ඉල්ලුමක් තියෙනවා. ඒ නිසා ඔයාත් Java Backend Development පැත්තට යන්න හිතන් ඉන්නවා නම්, Spring Boot අනිවාර්යයෙන්ම ඉගෙන ගන්න ඕන දෙයක්. අද අපි බලමු Spring Boot project එකක් මුල ඉඳන්ම කොහොමද හදාගන්නේ, ඒකේ තියෙන වැදගත් කොටස් මොනවද, සහ පොඩි 'Hello World' application එකක් Run කරන්නේ කොහොමද කියලා.

ලංකාවේ සටක සටක ගාලා, කොළඹ ට්‍රැෆික් එකේ යන වේගෙන් වගේම, අපිට Spring Boot project එකක් හදාගන්න පුළුවන් Super Fast විදිහක් තමයි Spring Initializr කියන්නේ. එහෙනම්, වැඩේට බහිමුද?

Spring Initializr - අලුත් Project එකක් පටන් ගනිමු! 🚀

Spring Initializr කියන්නේ අපිට Spring Boot project එකක් හදන්න උදව් වෙන Web tool එකක්. මේකෙන් අපිට පුළුවන් අවශ්‍ය Dependencies ටිකත් එක්කම, project structure එක automacally Generate කරගන්න. මේක use කරන එක හරිම ලේසියි.

මුලින්ම ඔයාගේ Web Browser එක open කරලා start.spring.io කියලා ගහලා යන්න. මේක තමයි Spring Initializr වෙබ් අඩවිය.

මේ Page එකට ගියාම ඔයාට Options කීපයක් පේයි:

1. Project:
   • Maven Project: Maven කියන්නේ Build Automation tool එකක්. XML වලින් Configurations කරන නිසා පොඩ්ඩක් cumbersome වෙන්න පුළුවන්, හැබැයි ගොඩක් project වල use කරනවා.
   • Gradle Project: Gradle කියන්නේ අලුත් Build tool එකක්. Groovy or Kotlin DSL (Domain Specific Language) වලින් Configurations කරන නිසා Maven වලට වඩා Flexible, Powerful සහ සමහර වෙලාවට වේගවත්. ඔයාගේ කැමැත්ත අනුව එකක් තෝරගන්න පුළුවන්. මේ Post එකට අපි Maven තෝරගමු.
2. Language:
   • Java: අපි Java වලින් හදන නිසා මේක තෝරගමු.
   • Kotlin: Kotlin කියන්නේ JetBrains ලා හදපු JVM (Java Virtual Machine) එකේ වැඩ කරන භාෂාවක්.
   • Groovy: Groovy කියන්නේ Java platform එකේ script කරන්න පුළුවන් Dynamic language එකක්.
3. Spring Boot:
   • අලුත්ම Stable Version එක තෝරගන්න. 3.x.x වගේ Version එකක් දැන් ඇති.
4. Project Metadata: මේ කොටස තමයි Project එකේ Details.
   • Group: මේක සාමාන්‍යයෙන් ඔයාගේ Company එකේ or Personal Domain name එකේ reverse order එක දානවා. උදාහරණයක් විදියට com.yourcompany හෝ lk.scguide.
   • Artifact: මේක තමයි ඔයාගේ Project එකේ නම. අපි hello-spring-boot කියලා දාමු.
   • Name: Project එකට display වෙන නම. hello-spring-boot කියලාම තියමු.
   • Description: Project එක මොකටද කියලා පොඩි Description එකක් දෙන්න පුළුවන්. Demo project for Spring Boot කියලා දාමු.
   • Package name: මේක Group and Artifact එක්වෙලා හැදෙන එක. lk.scguide.hellospringboot වගේ දෙයක් Automatically generate වෙයි.
   • Packaging:
     • Jar: සාමාන්‍යයෙන් Java application Run කරන්න Use කරන Executable archive එකක්. Spring Boot වලදී මෙය Recommend කරනවා.
     • War: Web application server (Tomcat වගේ) එකක Deploy කරන්න Use කරන archive එකක්. මෙය සාමාන්‍යයෙන් Use කරන්නේ Traditional Web Applications වලට. අපි Jar තෝරගමු.
   • Java: Java Version එක තෝරන්න. දැනට 17 වගේ එකක් තෝරගන්න පුළුවන්.
5. Dependencies:
   • මේක තමයි වැදගත්ම කොටස. අපිට Project එකට ඕන libraries මෙතනින් Add කරගන්න පුළුවන්.
   • Add Dependencies... button එක click කරලා, search bar එකේ Spring Web කියලා type කරලා ඒක තෝරගන්න. මේකෙන් අපිට Web applications හදන්න ඕන Libraries ටික ලැබෙනවා.
   • අපිට තව Lombok වගේ දේවල් Add කරගන්නත් පුළුවන්. ඒත් මුලින්ම Spring Web විතරක් තෝරගමු.

ඔක්කොම හරිනම්, Generate button එක click කරන්න. ඔයාගේ Project එක Zip file එකක් විදියට Download වෙයි. මේක Extract කරලා ඔයාගේ කැමති තැනක Save කරගන්න.

pom.xml / build.gradle - Project එකේ හදවත ❤️

අපි Download කරගත්ත Project එකේ, pom.xml (Maven නම්) නැත්නම් build.gradle (Gradle නම්) කියන file එක හරිම වැදගත්. මේක තමයි Project එකේ "හදවත" වගේ වැඩ කරන්නේ. Project එක Build කරන්නේ කොහොමද, මොන Dependencies ද ඕන, Project එකේ Version එක මොකක්ද වගේ හැම දෙයක්ම මේකේ තමයි තියෙන්නේ.

pom.xml (Maven Project වලට)

ඔයා Maven තෝරගත්තා නම්, ඔයාගේ Project folder එක ඇතුළේ pom.xml කියලා file එකක් තියෙනවා. මේක XML format එකෙන් ලියලා තියෙන්නේ. මෙන්න පොඩි උදාහරණයක්:

<?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>3.2.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>lk.scguide</groupId>
	<artifactId>hello-spring-boot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>hello-spring-boot</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</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>
			</plugin>
		</plugins>
	</build>

</project>

මේකේ තියෙන වැදගත් කොටස් ටිකක් බලමු:

• <parent>: මේකෙන් කියන්නේ අපේ project එක Spring Boot parent project එකෙන් inherit වෙනවා කියලා. මේකෙන් තමයි Spring Boot වල default configurations, dependency versions වගේ දේවල් manage වෙන්නේ.
• <groupId>, <artifactId>, <version>: මේවා තමයි project එකේ Unique identifiers.
• <properties>: Project එකට අදාළ properties (උදා: Java Version) මෙතන define කරන්න පුළුවන්.
• <dependencies>: මේක තමයි අපේ project එකට ඕන libraries (dependencies) ටික අපි දාන තැන. අපි Spring Initializr එකෙන් Spring Web add කරපු නිසා spring-boot-starter-web dependency එක මෙතන Add වෙලා තියෙනවා.
• <build>: Project එක build කරන්න ඕන Plugins (උදා: spring-boot-maven-plugin) මේකේ configure කරනවා.

build.gradle (Gradle Project වලට)

ඔයා Gradle තෝරගත්තා නම්, ඔයාගේ Project folder එක ඇතුළේ build.gradle කියලා file එකක් තියෙනවා. මේක Groovy or Kotlin syntax වලින් ලියලා තියෙන්නේ. මෙන්න පොඩි උදාහරණයක්:

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.2.0'
	id 'io.spring.dependency-management' version '1.1.4'
}

group = 'lk.scguide'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '17'
}

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
	useJUnitPlatform()
}

මේකේ තියෙන වැදගත් කොටස් ටිකක් බලමු:

• plugins { ... }: Project එකට ඕන Gradle plugins මෙතන define කරනවා.
• group, version: මේවා Maven වල වගේම project එකේ Unique identifiers.
• java { sourceCompatibility = '17' }: Java Version එක configure කරන තැන.
• repositories { mavenCentral() }: Dependencies download කරගන්න ඕන locations (repositories) මෙතන define කරනවා.
• dependencies { ... }: මේක තමයි අපේ project එකට ඕන libraries (dependencies) ටික අපි දාන තැන.

මූලිකව, මේ දෙකෙන්ම වෙන්නේ project එක build කරන්න අවශ්‍ය tools, dependencies වගේ දේවල් define කරන එක. ඔයාට ඕන දෙයක් add කරන්න, remove කරන්න මේ files වලට ගිහින් Edit කරන්න පුළුවන්.

My First Spring Boot App: "Hello World" 🌍

දැන් අපි Project එක Download කරගෙන, ඒකේ Build tool configuration file එක ගැනත් ටිකක් දැනගත්තනේ. දැන් වෙලාව තමයි අපේ පළවෙනි Spring Boot application එක හදලා Run කරන්න.

1. Project එක IDE එකකින් Open කරගනිමු

ඔයා කැමති IDE එකක් (Integrated Development Environment) open කරගන්න. IntelliJ IDEA, VS Code, Eclipse වගේ ඒවා ගොඩක් අය use කරනවා. මම නම් IntelliJ IDEA recommend කරනවා, Spring Boot වලට ගොඩක් හොඳ Support එකක් තියෙනවා. IDE එකෙන් Open Project or Import Project කියන Option එක දීලා, ඔයා Download කරගෙන Extract කරගත්ත Project Folder එක තෝරගන්න. IDE එක Automatically Project එක recognize කරලා Load කරගනීවි.

2. Main Application Class එක

Project එක Open උනාට පස්සේ, src/main/java folder එක ඇතුළේ, ඔයාගේ package name එකට අදාල folder structure එක ඇතුළේ (උදා: lk/scguide/hellospringboot) HelloSpringBootApplication.java වගේ නමින් Class එකක් තියෙනවා. මේක තමයි ඔයාගේ Spring Boot application එකේ Main Class එක.

package lk.scguide.hellospringboot;

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

@SpringBootApplication
public class HelloSpringBootApplication {

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

}

මේකේ තියෙන @SpringBootApplication annotation එක හරිම වැදගත්. මේක ඇතුළේ තව Annotations තුනක් තියෙනවා:

• @Configuration: Spring configuration classes define කරන්න.
• @EnableAutoConfiguration: Spring Boot වල Auto-configuration feature එක enable කරන්න. මේකෙන් තමයි Spring Boot අපේ project එකේ dependencies අනුව auto-configure වෙන්නේ. (උදා: Spring Web තියෙනවා නම් Tomcat server එක auto-configure කරනවා).
• @ComponentScan: Spring components (like Controllers, Services, Repositories) project එකේ scan කරලා Beans විදියට register කරන්න.

main method එක තමයි Java application එකක starting point එක. SpringApplication.run() method එකෙන් තමයි Spring Boot application එක start වෙන්නේ.

3. "Hello World" REST Controller එකක් හදමු

දැන් අපි අපේ Browser එකෙන් or Postman එකෙන් Access කරන්න පුළුවන් simple "Hello World" endpoint එකක් හදමු.

src/main/java/lk/scguide/hellospringboot folder එක ඇතුළේ, අලුත් Package එකක් හදන්න. ඒකට controller කියලා නමක් දෙන්න. මේක standard practice එකක්. මේ Package එක ඇතුළේ අලුත් Java Class එකක් හදන්න, ඒකට HelloController කියලා නමක් දෙන්න.

දැන් HelloController.java file එකට පහත Code එක Copy කරන්න.

package lk.scguide.hellospringboot.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello World from SC Guide!";
    }
}

මේ Code එක ගැන පොඩ්ඩක් බලමු:

• @RestController: මේක Spring Annotation එකක්. මේ Class එක REST API endpoints provide කරන Controller එකක් කියලා Spring Framework එකට කියනවා. ඒ කියන්නේ මේ Class එක ඇතුළේ HTTP requests handle කරන්න Methods තියෙනවා.
• @GetMapping("/hello"): මේකත් Spring Annotation එකක්. මේකෙන් කියන්නේ, /hello කියන URL එකට GET request එකක් ආවොත්, ඊට යටින් තියෙන hello() method එක call කරන්න කියලා.
• public String hello(): මේක තමයි අපේ method එක. මේක String එකක් return කරනවා.
• return "Hello World from SC Guide!";: මේ String එක තමයි Client එකට response එක විදියට යවන්නේ.

4. Application එක Run කරමු!

දැන් ඔක්කොම සෙට් එක හදලා ඉවරයි. Application එක Run කරන්න විවිධ විදි තියෙනවා:

• IDE එකෙන්:
  • HelloSpringBootApplication.java file එක open කරලා, main method එකේ 옆 තියෙන Green Play (Run) Button එක click කරන්න.
  • නැත්නම් IDE එකේ Run Menu එකට ගිහින් Run "HelloSpringBootApplication" කියලා දෙන්න.
• Command Line එකෙන් (Maven නම්):
  • Project root folder එකට Command Prompt or Terminal එක open කරගන්න.
• Command Line එකෙන් (Gradle නම්):
  • Project root folder එකට Command Prompt or Terminal එක open කරගන්න.

පහත Command එක Type කරලා Enter කරන්න:

gradle bootRun

පහත Command එක Type කරලා Enter කරන්න:

mvn spring-boot:run

Application එක Start උනාට පස්සේ Console එකේ ඔයාට පේයි "Started HelloSpringBootApplication in ..." වගේ Message එකක්. ඒ වගේම Tomcat started on port(s): 8080 (http) වගේ Message එකකුත් පේයි.

5. Application එක Test කරමු

දැන් ඔයාගේ Browser එක open කරලා, Address bar එකේ http://localhost:8080/hello කියලා ගහලා Enter කරන්න. ඔයාට "Hello World from SC Guide!" කියලා message එකක් පේන්න ඕන!

ඔයාට Postman වගේ API testing tool එකක් use කරන්නත් පුළුවන්. ඒකෙත් GET request එකක් http://localhost:8080/hello URL එකට යවන්න.

නිගමනය සහ ඉදිරි ගමන ✨

අද අපි Spring Boot Project එකක් මුල ඉඳන්ම හදාගන්න විදිහ, Spring Initializr පාවිච්චි කරලා ඉක්මනටම project එකක් generate කරගන්න විදිහ, pom.xml / build.gradle files වල වැදගත්කම, සහ සරල "Hello World" application එකක් හදලා run කරලා Test කරන විදිහ ගැන කතා කළා.

මේක Spring Boot journey එකේ පොඩිම පොඩි ආරම්භයක් විතරයි. මේ Framework එකේ කරන්න පුළුවන් දේවල් ගොඩක් තියෙනවා. Database connectivity, Security, Microservices, Testing වගේ ගොඩක් දේවල් ඉදිරියේදී අපිට ඉගෙන ගන්න පුළුවන්.

දැන් ඔයාට පුළුවන් මේ Project එක modify කරලා, තව පොඩි පොඩි Endpoints add කරලා Experiment කරන්න. මේක ඔයාගේ Coding journey එකට හොඳ ආරම්භයක් වෙයි කියලා මම හිතනවා. මොකද, Practice තමයි හැමදේටම වඩා වැදගත්.

ඔයාට මේ Post එක ගැන මොනවා හරි ප්‍රශ්න තියෙනවා නම්, හරි ඔයාගේ අත්දැකීම් share කරන්න ඕන නම්, පහළින් Comment එකක් දාන්න. අපි ඊළඟ Post එකෙන් මොනවා ගැනද කතා කරන්නේ කියලා යෝජනා කරන්නත් පුළුවන්.

එහෙනම්, ආයෙත් දවසක හමුවෙමු! Happy Coding! 😊