දත්ත සමුදා සම්බන්ධතා වේගවත් කරන්න: Database Connection Pooling! ⚡ (HikariCP සහ Tomcat JDBC) SC Guide

හායී මචන්ලා! කොහොමද? ඔයාලා හැමෝම Application හදනකොට, Database එක්ක වැඩ කරනකොට පොඩි අවුලකට මුහුණ දීලා ඇති නේද? සමහර වෙලාවට API Call එකක් ගහනකොට Data Load වෙන්න ටිකක් වෙලා යනවා. නැත්තම් Application එකේ Performance එක මදි වගේ දැනෙනවා. විශේෂයෙන්ම ලංකාවේ Internet speed, Server Response එක්ක මේක ලොකු ප්‍රශ්නයක්. මේකට එක ප්‍රධාන හේතුවක් තමයි Database Connection Management එක හරියට නොකරන එක. හැම පාරම Database එකට අලුත් Connection එකක් හදාගෙන, වැඩේ ඉවර වුනාම ඒක close කරන එක හොඳ වැඩක් නෙවෙයි. ඒකෙන් ලොකු Performance Cost එකක් තියෙනවා.

අද අපි කතා කරන්නේ මේ ප්‍රශ්නයට තියෙන හොඳම විසඳුමක් ගැන – ඒ තමයි Database Connection Pooling. ඔයාලා දන්නවද, මේක හරියට කරගත්තොත් Application එකේ Performance එකට ලොකු Boost එකක් දෙන්න පුළුවන්. විශේෂයෙන්ම Production Environment වල Connection Pooling නැතුව Application එකක් දුවනවා කියන්නේ, Engine එකක් නැතුව Car එකක් දුවනවා වගේ වැඩක්! අපි බලමු HikariCP සහ Tomcat JDBC වගේ පොරවල් මේ වැඩේට උදව් වෙන්නේ කොහොමද කියලා.

Connection Pooling කියන්නේ මොකක්ද? 🤔

සරලවම කියනවා නම්, Connection Pooling කියන්නේ Database Connections ටිකක් කලින්ම හදලා, ඒ ටික එක Pool එකක (එහෙමත් නැත්තම් පොකුරක් වගේ තැනක) තියාගෙන, ඕන වෙලාවට ඒකෙන් Connection එකක් අරන් පාවිච්චි කරලා, වැඩේ ඉවර වුනාම ආයෙත් ඒ Connection එක Pool එකටම දාන ක්‍රමයක්. හිතන්නකෝ ඔයාලා Lunch ගන්න Canteen එකකට යනවා කියලා. හැම පාරම අලුතෙන් තහඩුවක් හදාගෙන කෑම කනවා වෙනුවට, කලින්ම සෝදලා තියෙන පිරිසිදු තහඩු ටිකක් අරන් පාවිච්චි කරලා, ආයෙත් සෝදන්න දානවා වගේ වැඩක්. මේකෙන් වෙන්නේ මොකක්ද? අලුතෙන් Connection එකක් හදනකොට යන වෙලාවත්, ඒකට යන System Resources ප්‍රමාණයත් ඉතුරු වෙන එක.

සාමාන්‍යයෙන් Database Connection එකක් හදන එක කියන්නේ ලේසි වැඩක් නෙවෙයි. Network Latency, Authentication, Authorization වගේ දේවල් ගොඩක් ඒකට බලපානවා. මේ හැම දේකටම වෙලාවක් යනවා. ඒ වගේම, හැම Request එකකටම අලුතෙන් Connection එකක් හැදුවොත්, Database Server එකටත් ලොකු Load එකක් එනවා. Connection Pool එකක් පාවිච්චි කරනකොට, මුලින්ම එක සැරයක් Connections ටිකක් හදාගෙන තියාගන්නවා. ඊට පස්සේ, Application එකෙන් Connection එකක් ඉල්ලුවොත්, Pool එකෙන් තියෙන Connection එකක් දෙනවා. වැඩේ ඉවර වුනාම, Connection එක close කරන්නේ නැතුව, ආයෙත් Pool එකට දානවා. ඒකෙන් වෙන්නේ ඒ Connection එක තවත් Request එකකට පාවිච්චි කරන්න පුළුවන් වෙන එක. මේකෙන් Performance එකට අති විශාල වාසියක් ලැබෙනවා.

HikariCP - වේගයේ රහස 🚀

Java Ecosystem එකේ Connection Pooling වලට තියෙන Best එකක් තමයි HikariCP. මේක ගොඩක් Speed, Efficient, සහ Reliable. මේකේ Speed එකට හේතු ගොඩක් තියෙනවා. එකක් තමයි ඒගොල්ලෝ Byte Code Manipulation වගේ අමුතු Tricks පාවිච්චි කරනවා. අනිත් එක තමයි මේකේ Codebase එක ගොඩක් පොඩි එකක්. ඒකෙන් Overhead එක අඩුවෙනවා. ඒ වගේම, HikariCP Connection Pool Size එක ගොඩක් Intelligent විදියට Manage කරනවා. ඒක නිසා නිකරුනේ Connections හද හදා ඉන්නේ නැහැ.

Spring Boot Project එකක HikariCP Configure කරන එක නම් ගොඩක් ලේසියි. මොකද Spring Boot වල Default Connection Pool එක විදියට එන්නේ HikariCP. ඒ නිසා ඔයාලට කරන්න තියෙන්නේ application.properties (හෝ application.yml) file එකේ අවශ්‍ය Properties ටික දාන එක විතරයි.

HikariCP Configuration Example (Spring Boot - application.properties):

spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# HikariCP specific properties
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.pool-name=MyHikariCP
spring.datasource.hikari.auto-commit=true
spring.datasource.hikari.leak-detection-threshold=2000

මේ properties ටිකෙන් අපි කරන්නේ, අපේ Database එකට සම්බන්ධ වෙන්න ඕනේ විස්තර ටික දෙන එකයි, HikariCP එකේ Pool එකේ Connections කීයක් තියෙන්න ඕනෙද, Connection එකක් ඉල්ලලා තියෙන්නේ නැත්නම් කොච්චර වෙලාට පස්සේ ඒක close කරන්න ඕනෙද වගේ දේවල් කියන එකයි. maximum-pool-size කියන්නේ Pool එකේ තියෙන්න පුළුවන් උපරිම Connections ගාන. minimum-idle කියන්නේ Pool එකේ නිකන් තියෙන්න ඕනේ අවම Connections ගාන. connection-timeout කියන්නේ Connection එකක් ගන්න පුළුවන් උපරිම වෙලාව. මේ වගේ දේවල් හරියට Configure කරන එක ගොඩක් වැදගත්.

Maven Dependency (if not using Spring Boot auto-config):

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version> <!-- Use the latest version -->
</dependency>

Tomcat JDBC - විශ්වාසනීය සහ සරල 🌟

Tomcat JDBC කියන්නේ Apache Tomcat Project එකේ කොටසක් විදියට එන Connection Pooling Implementation එකක්. මේකත් ගොඩක් ජනප්‍රියයි, විශේෂයෙන්ම Tomcat Application Server එකත් එක්ක වැඩ කරන අයට. මේකේ Performance එක HikariCP තරම් Speed නැති උනත්, මේක ගොඩක් Reliable සහ Configuration කරන්න ලේසියි.

Tomcat JDBC වල තියෙන ලොකු වාසියක් තමයි, ඒක Apache Tomcat Server එකත් එක්ක seamlessly integrate වෙන එක. ඒ නිසා Tomcat Server එකේ context.xml file එකේ direct මේක Configure කරන්න පුළුවන්. ඒකෙන් Application එක deploy කරනකොට Connection Pool එක Server එකෙන්ම Manage වෙනවා.

Tomcat JDBC Configuration Example (context.xml - for Tomcat Servers):

<Resource name="jdbc/MyDataSource"
          auth="Container"
          type="javax.sql.DataSource"
          factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
          driverClassName="com.mysql.cj.jdbc.Driver"
          url="jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC"
          username="root"
          password="your_password"
          maxActive="100"
          maxIdle="30"
          minIdle="10"
          initialSize="10"
          validationQuery="SELECT 1"
          testOnBorrow="true"
          removeAbandoned="true"
          removeAbandonedTimeout="60"
          logAbandoned="true"
          jdbcInterceptors="org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;
                           org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer" />

මේ context.xml එකේ Resource tag එක ඇතුලේ අපි DataSource එකක් define කරනවා. maxActive, maxIdle, minIdle වගේ properties HikariCP වල වගේම මෙතනත් තියෙනවා. validationQuery කියන්නේ Connection එකක් නිවැරදිව වැඩ කරනවද කියලා Check කරන්න පාවිච්චි කරන Query එක. testOnBorrow කියන්නේ Connection එකක් Pool එකෙන් අරන් දෙනකොට ඒක Check කරන්න ඕනෙද කියන එක. removeAbandoned වගේ දේවල් පාවිච්චි වෙන්නේ Connection leaks වළක්වා ගන්න.

Maven Dependency (if not using Tomcat Server directly):

<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-jdbc</artifactId>
    <version>10.1.0</version> <!-- Use the latest version -->
</dependency>

ඔයාලා Spring Boot වගේ Framework එකක් පාවිච්චි කරනවා නම්, application.properties (හෝ application.yml) එකේම Tomcat JDBC Configure කරන්නත් පුළුවන්. ඒකට කරන්න තියෙන්නේ spring.datasource.type property එකට org.apache.tomcat.jdbc.pool.DataSource කියලා දෙන එකයි.

Tomcat JDBC Configuration in Spring Boot (application.properties):

spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# Tomcat JDBC specific properties
spring.datasource.tomcat.max-active=100
spring.datasource.tomcat.max-idle=30
spring.datasource.tomcat.min-idle=10
spring.datasource.tomcat.initial-size=10
spring.datasource.tomcat.validation-query=SELECT 1
spring.datasource.tomcat.test-on-borrow=true
spring.datasource.tomcat.remove-abandoned=true
spring.datasource.tomcat.remove-abandoned-timeout=60
spring.datasource.tomcat.log-abandoned=true

ප්‍රායෝගිකව Connection Pooling යොදන්නේ කොහොමද? 🛠️

හරි, දැන් අපි HikariCPයි, Tomcat JDBCයි දෙකම ගැන කතා කළා. දැන් බලමු මේක Practical විදියට අපේ Project එකකට දාන්නේ කොහොමද කියලා, ඒ වගේම වැදගත් Configuration Parameters කිහිපයක් ගැන.

HikariCP ද Tomcat JDBC ද?

• Performance (Speed): HikariCP තමයි මේ දෙකෙන් වේගවත්ම. ඒක ගොඩක් Optimization කරලා තියෙන්නේ.
• Simplicity & Integration: ඔයාලා දැනටමත් Tomcat Server එකක් පාවිච්චි කරනවා නම්, Tomcat JDBC integrate කරන එක ගොඩක් ලේසියි. ඒ වගේම ඒක ගොඩක් stable.
• Community Support: දෙකටම හොඳ Community Support එකක් තියෙනවා.
• General Use: ගොඩක් වෙලාවට Production Environment වලදී HikariCP තමයි Recommend කරන්නේ. හැබැයි ඔයාගේ Application එකේ Traffic එක සාමාන්‍ය මට්ටමක තියෙනවා නම්, Tomcat JDBC උනත් කිසි අවුලක් නැහැ.

වැදගත් Configuration Parameters:

1. maximum-pool-size / maxActive: Pool එකේ තියෙන්න පුළුවන් උපරිම Connections ගාන. මේක තමයි ගොඩක්ම වැදගත් Parameter එක. මේකේ Size එක වැඩි වෙන තරමට Application එකට එක සැරේ Manage කරන්න පුළුවන් concurrent requests ගාන වැඩි වෙනවා. හැබැයි ඕනවට වඩා වැඩි කලොත් Database Server එකට Load එක වැඩි වෙන්න පුළුවන්. සාමාන්‍යයෙන් මේක Thread Pool Size එකට අනුව තීරණය වෙනවා.
2. minimum-idle / minIdle: Pool එකේ නිකන් තියෙන්න ඕනේ අවම Connections ගාන. Application එකේ Traffic එක අඩු වෙලාවටත් මේ Connections ගාන Pool එකේ තියාගෙන ඉන්නවා. ඒකෙන් වෙන්නේ Traffic එක ආයෙත් වැඩි වෙනකොට අලුතෙන් Connections හදන්න යන වෙලාව ඉතුරු වෙන එක.
3. connection-timeout / maxWait: Connection එකක් ගන්න පුළුවන් උපරිම වෙලාව. මේ වෙලාව ඇතුලත Connection එකක් ගන්න බැරි වුනොත් Exception එකක් throw කරනවා.
4. idle-timeout / timeBetweenEvictionRunsMillis: Connection එකක් Pool එකේ නිකන් තියෙන්න පුළුවන් උපරිම වෙලාව. මේ වෙලාවට වඩා Connection එකක් නිකන් තිබ්බොත් ඒක Pool එකෙන් අයින් කරනවා.
5. max-lifetime / maxActive: Connection එකක් පාවිච්චි කරන්න පුළුවන් උපරිම කාලය. මේක දාන්නේ Database Server එක පැත්තෙන් Connections Forcefully close වෙන එක වළක්වා ගන්න.
6. leak-detection-threshold / removeAbandoned: Connection එකක් පාවිච්චි කරලා ආයෙත් Pool එකට දාන්න අමතක වුනොත් (Connection Leak), ඒක Detect කරන්න මේක පාවිච්චි කරනවා. Debugging වලට මේක ගොඩක් වැදගත්.

Connection Pool එක Monitor කරන එක:

Connection Pool එක නිවැරදිව වැඩ කරනවද කියලා බලන එක ගොඩක් වැදගත්. ඒකට Metrics ටිකක් තියෙනවා.

• Active Connections: මේ මොහොතේ පාවිච්චි වෙමින් පවතින Connections ගාන.
• Idle Connections: නිකන් තියෙන Connections ගාන.
• Waiting Connections: Connection එකක් ගන්න Queue එකේ ඉන්න Request ගාන.

මේ Metrics ටික Prometheus, Grafana, JMX වගේ Tools පාවිච්චි කරලා Monitor කරන්න පුළුවන්. මේවා බලලා ඔයාගේ Application එකේ Peak Load එකට අනුව Connection Pool Size එක Adjust කරන්න පුළුවන්.

Best Practices:

• Credentials: Database Usernames, Passwords කෙලින්ම application.properties එකේ දාන්නේ නැතුව Environment Variables, Vault වගේ Secure Store එකක දාලා පාවිච්චි කරන්න.
• Validation Query: Connection එක Active ද කියලා Check කරන්න Valid SQL Query එකක් (උදා: SELECT 1) පාවිච්චි කරන්න.
• Error Handling: Connection එකක් ගන්න බැරි වුනොත්, ඒක Proper විදියට Handle කරන්න.
• Logging: Connection Pooling Library එකේ Logs Enable කරලා තියාගන්න. ඒකෙන් මොකක් හරි ප්‍රශ්නයක් ආවොත්, Debug කරන්න ලේසියි.

ඕක තමයි Connection Pooling ගැන කෙටියෙන් කියන්න තියෙන්නේ. මේකේ අලුත් දේවල් හොයන්න, ඒ වගේම ඔයාගේ Project එකට ගැලපෙන විදියට Configure කරන්න උත්සහ කරන්න.

අවසාන වචන ✍️

ඉතින් මචන්ලා, ඔයාලට තේරෙන්න ඇති Database Connection Pooling කියන්නේ Application Performance එකට කොච්චර වැදගත් දෙයක්ද කියලා. මේක හරියට Configure කරගත්තොත් ඔයාගේ Application එකේ Speed එකට අති විශාල Boost එකක් දෙන්න පුළුවන්. ඒ වගේම Database Server එකට එන Load එකත් ගොඩක් අඩු කරගන්න පුළුවන්. අද අපි කතා කරපු HikariCP සහ Tomcat JDBC කියන දෙකම ගොඩක් හොඳ Options දෙකක්. ඔයාලගේ Project එකට ගැලපෙන එක තෝරගෙන Implement කරලා බලන්න.

අදම ඔයාගේ Project එකේ Database Connection Pooling Configure කරලා බලන්න. ඔයා මේ ගැන හිතන්නේ මොකක්ද? ඔයා මේ වෙනකම් මොන Connection Pool එකද පාවිච්චි කලේ? ඒකෙන් මොන වගේ Results ද ලැබුනේ? පහලින් Comment Section එකේ ඔයාලගේ අත්දැකීම් Share කරන්න අමතක කරන්න එපා. අපි ඊළඟ Blog Post එකෙන් හම්බවෙමු! තව අලුත් Technology එකක් ගැන කතා කරමු! ජය වේවා!