JavaBeans පැහැදිලි කිරීම: නිර්වචන, නීති, ප්‍රායෝගික භාවිතය, සහ ෆ්‍රේම්වර්ක් ඒකාබද්ධ කිරීමේ මාර්ගෝපදේශය

1. හැඳින්වීම | JavaBeans යනු කුමක්ද සහ ඒවා ඇයි වැදගත්ද

JavaBeans යනු Java සංවර්ධනයේ මූලික ඒවායි

JavaBeans යනු Java කේතනයේදී විකිණීමට සුදුසු සංරචක සඳහා සැලසුම් නීති කිහිපයකි. ඒවා විශේෂිත නිර්දේශ අනුව ලියැවුණු Java පන්ති වන අතර, දත්ත විනිමය සහ වස්තු තත්ත්ව කළමනාකරණය කිරීම සඳහා කාර්යක්ෂමව භාවිතා වේ.
උදාහරණයක් ලෙස, වෙබ් අඩවිවලදී, පරිශීලකයින් විසින් ආකෘතිවල ඇතුළත් කරන තොරතුරු තාවකාලිකව ගබඩා කිරීම සඳහා JavaBeans භාවිතා කිරීම ඉතා සුලබයි.

JavaBeans නිර්දේශය මගින් සම්පාදනය වන පහසුව

JavaBeans යනු සාමාන්‍ය Java පන්ති පමණක් නොවේ—නීති කිහිපයක් අනුගමනය කිරීමෙන්, ඒවා විවිධ රාමු සහ පුස්තකාගාර සමඟ ඒකාබද්ධ කිරීමට පහසු වේ. Spring Framework සහ JavaServer Pages (JSP) වැනි තාක්ෂණයන් JavaBeans මත පදනම් වී සැලසුම් කර ඇති අතර, JavaBeans සමඟ සමගිය පමණක් තිබීමෙන් ඔබට බොහෝ විශේෂාංග ස්වයංක්‍රීයව ලැබෙනු ඇත.
ඊට අමතරව, JavaBeans හි මූලික ගොඩනැගිල්ල වැනි දේවල්—ස්වයංක්‍රීය සුදුසුකම් ප්‍රවේශයට ඉඩදෙන getter/setter ක්‍රම සහ දත්ත සුරකින/හුවමාරු කිරීම සඳහා serialization—වලට තේරුම් ගැනීම නිශ්චිත Java සංවර්ධනයට සෘජුව සම්බන්ධ වන ප්‍රායෝගික කුසලතාවකි.

මෙම ලිපිය ආවරණය කරන දේ

මෙම ලිපිය පියවරෙන් පියවර පැහැදිලි කරයි—JavaBeans හි මූලික නිර්වචනය සිට ආරම්භ කර, ක්‍රියාත්මක කිරීමේ නීති, කේත උදාහරණ සහ ප්‍රායෝගික භාවිතය දක්වා. ආරම්භකයින් සඳහා සුලබව ඇතිවන බාධක ආවරණය කරමින්, “JavaBeans යනු ඇත්තටම කුමක්ද?” යන මූලික ප්‍රශ්නය විසඳීම සහ සැබෑ සංවර්ධන කාර්යයන්හි භාවිතා කළ හැකි දැනුමක් ලබා ගැනීම ඉලක්කයි.

2. JavaBeans හි මූලික | නිර්වචනය, ලක්ෂණ සහ POJO සිට වෙනස්කම්

JavaBeans හි නිර්වචනය කුමක්ද?

JavaBean යනු Java හි සංවර්ධනය කරන ලද විකිණීමට සුදුසු මෘදුකාංග සංරචකයකි. විධිමත්ව, එය Sun Microsystems (දැන් Oracle) විසින් පිහිටුවන ලද නිර්දේශ අනුව නිර්වචනය කරන ලද Java පන්තියකි, සහ එය විශේෂිත ව්‍යාකරණ නීති අනුව ක්‍රියාත්මක කර ඇත.
JavaBeans ප්‍රධාන වශයෙන් පහත අරමුණු සඳහා භාවිතා වේ:

• දත්ත හුවමාරුව (DTO-වැනි භූමිකාව)
• GUI සංරචක සමඟ ඒකාබද්ධ කිරීම
• වෙබ් යෙදුම්වල මාදිලි ස්ථරය ගොඩනැගීම

මෙලෙස, JavaBeans බොහෝ විට “දත්ත ගබඩා කරන සහ එය බාහිරය සමඟ ආරක්ෂිතව සහ කාර්යක්ෂමව හුවමාරු කරන (වස්තූන්) භාජන” ලෙස භාවිතා වේ.

JavaBeans හි නියෝජිත ලක්ෂණ

JavaBeans හි පහත ලක්ෂණ ඇත:

• පොදු පරාමිතරයකින් තොර ක්‍රියාකාරකයෙකු → පන්තියේ නිදහස් ආරම්භකරණයට ඉඩදෙයි
• පෞද්ගලික ගුණාංග සහ සම්බන්ධ පොදු getter/setter ක්‍රම → ආවරණය සහ ප්‍රවේශ පාලනය සක්‍රීය කරයි
• Serializable අතුරුම්පත් ක්‍රියාත්මක කිරීම → වස්තූන් byte ධාරාවලට පරිවර්තනය කිරීමට ඉඩදෙයි ගබඩා කිරීම සහ හුවමාරු කිරීම සඳහා
• නාමකරණ සම්මත අනුගමනය කරන ක්‍රම උදාහරණ: getName() , setName() , isAvailable() , ආදිය.

මෙම ලක්ෂණ JavaBeans වැඩසටහන් සහ රාමු සමඟ ස්වයංක්‍රීයව ඒකාබද්ධ කිරීමට පහසු කරයි.

එය POJO සිට කෙසේ වෙනස්ද?

බොහෝ විට සංසන්දනය කරන සංකල්පයක් වන්නේ “POJO (Plain Old Java Object)” ය.
POJO යනු JavaBeans ට වඩා පුළුල් සංකල්පයක් වන අතර, වෙනස්කම් පහත පරිදියි:

සංක්ෂිප්තව, POJO යනු සීමාවකින් තොර සාමාන්‍ය Java වස්තුවකි, ධ JavaBeans යනු භාණ්ඩ ඒකාබද්ධ කිරීම සඳහා සැලසුම් කරන ලද නීති සහිත POJO වේ.

JavaBeans කවදා භාවිතා කළ යුතුද?

JavaBeans විශේෂයෙන් කාර්යක්ෂම වන්නේ පහත දර්ශනවලදී:

• Spring හෝ JSP වැනි ප්‍රධාන Java රාමුවල දත්ත හුවමාරුව
• වස්තු serialization සහ session කළමනාකරණය
• බාහිර පුස්තකාගාර සහ සංවර්ධන උපකරණවල ස්වයංක්‍රීය ගුණාංග හඳුනාගැනීම

සම්මත අනුගමනය කරන කේත ලිවීමෙන්, ඔබ සංවර්ධන ස්වයංක්‍රීයකරණය සහ නඩත්තුකම්කරණයට දායක වනු ඇත.

3 JavaBeans නිර්දේශ සහ නීති | Getter/Setter සහ Serializable හි මූලික

JavaBeans සඳහා අවශ්‍ය මූලික නිර්දේශ මොනවාද?

JavaBeans යනු “සාමාන්‍ය Java පන්තියන්” නොවේ. ඒවා නියමිත සම්මතයන් අනුගමනය කළ යුතුය. මෙම සම්මතයන් IDE සහ framework ගණනාවකට JavaBean ගුණාංග සහ ක්‍රම ස්වයංක්‍රීයව හඳුනා ගැනීමට ඉඩ සලසයි, එමඟින් යෙදුම් සංරචනය කිරීම සහ කේතය නැවත භාවිතා කිරීම පහසු වේ.

පහත දැක්වෙන්නේ JavaBean එකක් ලෙස නිවැරදිව ක්‍රියා කිරීමට පන්තියට අවශ්‍ය ප්‍රධාන විශේෂණයන් වේ.

A Public No-Argument Constructor

JavaBeans බොහෝ විට ගතිකව නිර්මාණය කරනු ලබන බැවින්, ඒවාට පොදු පරාමිතියක් නොමැති නිර්මාණකරු එකක් තිබිය යුතුය. එය නොමැති නම්, JSP වැනි framework ගණනාවක් ඒවා නිර්මාණය නොකරයි, එමඟින් දෝෂ ඇති වේ.

public class UserBean {
    public UserBean() {
        // empty constructor is fine
    }
}

Private Properties and Public Getter/Setter

JavaBeans හි, සාමාජික විචල්‍ය (ක්ෂේත්‍ර) පෞද්ගලික ලෙස සංග්‍රහ කර ඇත, සහ ඒ සඳහා getter සහ setter ක්‍රම පබ්ලික් ලෙස නිර්වචනය කර ඇත. මෙය දත්තයට පාලිත බාහිර ප්‍රවේශය ලබා දී, නඩත්තුකරණය සහ ආරක්ෂාව වැඩි කරයි.

public class UserBean {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Implementation of the Serializable Interface

Web යෙදුම් වල JavaBeans බොහෝ විට සැසියන් තුළ සුරකින්නා හෝ ගොනු වලට ලියන්නා වන බැවින්, java.io.Serializable අතුරුමුහුණත ක්‍රියාත්මක කිරීම නිර්දේශ කරයි.

import java.io.Serializable;

public class UserBean implements Serializable {
    private String name;
    private int age;

    // getter/setter omitted
}

මෙම ක්‍රියාවලියෙන් JavaBeans සැසියන් හෝ මාරු කිරීම් සඳහා භාවිතා කළ හැකි වන අතර, web යෙදුම්, RMI, EJB ආදී සමඟ ඒකාබද්ධ කිරීම පහසු වේ.

Automatic Code Generation in Eclipse or IntelliJ

නවීන IDE ගණනාවක් getters/setters, constructors, serialVersionUID ආදී ස්වයංක්‍රීයව ජනනය කරන විශේෂාංග ලබා දේ.
උදාහරණයක් ලෙස, Eclipse හි Right-click → “Source” → “Generate Getters and Setters” භාවිතා කිරීමෙන් බහු ගුණාංග සඳහා සමූහ ජනනය කළ හැක. මෙය අතින් සිදුවන දෝෂ වැළැක්වීම සහ නිෂ්පාදනශීලතාව වැඩි කරයි.

The Importance of Following Naming Conventions

JavaBeans හි, නාමකරණ සම්මතයන් කඩිනමින් අනුගමනය කිරීම framework/tool ඒකාබද්ධ කිරීම සඳහා ඉතා වැදගත් වේ. උදාහරණයක් ලෙස, Spring Framework අභ්‍යන්තරයෙන් ගුණාංග නාමයන් මත setXxx() හෝ getXxx() කැඳවයි, එබැවින් නාමකරණ උල්ලංඝන මගින් ක්‍රියාකාරිත්වය අසාර්ථක වේ.

Summary: The Structure of JavaBeans Is a “Set of Conventions”

JavaBeans විශේෂණයන් සීමාකාරී ලෙස පෙනෙන්නට හැකි වුවද, ඒවා “උපාංග සහ සංවර්ධන පරිසර සමඟ සමඟාමීව කටයුතු කිරීම සඳහා සම්මතයන්” පමණි. සංවර්ධන කණ්ඩායම් සහ framework ගණනාවට පොදු භාෂාවක් ලෙස, JavaBeans විශේෂණයන් ඉතා වැදගත් භූමිකාවක් ඉටු කරයි.

4. Basic Implementation Examples of JavaBeans | Explained with Sample Code

Let’s Look at the Structure of a JavaBean in Practice

JavaBeans සංකල්පය සහ නීති ඔබට තේරුම් ගත හැකි වුවත්, බොහෝ දෙනා ඇත්තේ කේතය ලියන තුරු ඒවා සත්‍යයෙන් අවබෝධ නොකරයි. මෙම කොටස සාමාන්‍ය JavaBean ක්‍රියාත්මක කිරීමක් පියවරෙන් පියවර ගෙන, නිරූපිත ව්‍යුහය සහ ලිවීමේ රටාව පෙන්වයි.

A Simple JavaBean Example: UserBean

මෙම උදාහරණය UserBean පන්තිය භාවිතා කරයි, එහි ගුණාංග දෙකක් ඇත: name සහ age.

import java.io.Serializable;

public class UserBean implements Serializable {
    private String name;
    private int age;

    // No-argument constructor
    public UserBean() {
    }

    // getter/setter for name
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // getter/setter for age
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

මෙම පන්තිය පහත JavaBean විශේෂණයන් සපුරාලයි:

• Serializable අතුරුමුහුණත ක්‍රියාත්මක කරයි
• පොදු පරාමිතියක් නොමැති නිර්මාණකරු ඇත
• පෞද්ගලික ක්ෂේත්‍ර සහ ඒ සඳහා සම්බන්ධිත පොදු getter/setter ක්‍රම

Usage Example: Operating JavaBean Properties

Next is a simple example showing how to instantiate this JavaBean and set/get its properties.

public class Main {
    public static void main(String[] args) {
        UserBean user = new UserBean();

        user.setName("Sato");
        user.setAge(28);

        System.out.println("Name: " + user.getName());
        System.out.println("Age: " + user.getAge());
    }
}

ක්‍රියාත්මක ප්‍රතිඵල:

Name: Sato
Age: 28

මෙම ආකාරයෙන්, JavaBeans ගුණාංග සඳහා ආරක්ෂිත බාහිර කියවීම/ලියීම ප්‍රවේශය ලබා දෙන ව්‍යුහයක් සපයයි.

බහු JavaBeans හසුරවීමේ උදාහරණය

JavaBeans අඩිවල හෝ එකතුකිරීම් තුළත් බහුලව භාවිතා කරයි. උදාහරණයක් ලෙස, පරිශීලක ලැයිස්තුවක් තබා ගැනීම පහත පරිදි කළ හැක:

import java.util.ArrayList;
import java.util.List;

public class UserListExample {
    public static void main(String[] args) {
        List<UserBean> users = new ArrayList<>();

        UserBean user1 = new UserBean();
        user1.setName("Tanaka");
        user1.setAge(30);

        UserBean user2 = new UserBean();
        user2.setName("Takahashi");
        user2.setAge(25);

        users.add(user1);
        users.add(user2);

        for (UserBean user : users) {
            System.out.println(user.getName() + " (" + user.getAge() + " years old)");
        }
    }
}

මෙම ආකාරයෙන්, JavaBeans වෙබ් යෙදුම් වලට පමණක් නොව දත්ත ව්‍යුහගත කිරීම සහ දත්ත කළමනාකරණය සඳහාද ඉතා ප්‍රයෝජනවත් වේ.

කේත සහාය: Eclipse හි ස්වයංක්‍රීය ජනනය

Eclipse වැනි IDE එකක් භාවිතා කිරීමෙන්, getters/setters, constructors, serialVersionUID වැනි දේ ස්වයංක්‍රීයව ජනනය කළ හැක.
ක්‍රියා පටිපාටිය උදාහරණයක් (Eclipse):

1. පන්තිය ගොනුව මත දකුණු-ක්ලික් → [Source] → [Generate Getters and Setters]
2. චෙක්බොක්ස් මගින් ගුණාංග තෝරන්න
3. කේතය ස්වයංක්‍රීයව ඇතුළත් කිරීමට [Generate] ක්ලික් කරන්න

IDE එකක් භාවිතා කිරීමෙන් දෝෂ වැළැක්වීමට සහ කේත ලිවීමේ කාර්යක්ෂමතාවය ගණනාවක් වැඩි කිරීමට හැක.

ඉක්මන් සාරාංශය: පළමුව, ඔබම ලියන්න උත්සාහ කරන්න

JavaBeans සරල ව්‍යුහයක් ලෙස පෙනුනත්, වාස්තුක Java සංවර්ධනයේ ඉතා සාමාන්‍ය වේ. මූලික ව්‍යුහයට පුරුදු වූ පසු, Spring වැනි උසස් තාක්ෂණයන් තේරුම් ගැනීම ඉතා පහසු වේ.

5. JavaBeans හි ප්‍රයෝගික භාවිතය | JSP, Servlet, සහ Spring හි භාවිතය

JavaBeans “දත්ත පන්තියන්” පමණක් නොව වෙනත් බොහෝ දේ

මෙතෙක් දැකූ පරිදි, JavaBeans ගුණාංග සුරකින්න සහ ලබා ගන්න පුළුවන් නැවත භාවිතා කළ හැකි කොම්පොනන්ට්ස් වේ. ඒවායේ සැබෑ වටිනාකම “ෆ්‍රේම්වර්ක් සමඟ ඒකාබද්ධ කිරීම” තුළයි. JSP, Servlets, Spring Framework වැනි බොහෝ Java-සම්බන්ධ තාක්ෂණයන්හි JavaBean ව්‍යුහය අනුගමනය කිරීමෙන් සැකසුම් සහ සැකසීම ස්වයංක්‍රීයව සිදු කර, සංවර්ධන ඵලදායීතාවය ගණනාවක් වැඩි කරයි.

JSP හි JavaBeans භාවිතය | <jsp:useBean> මගින් දත්ත හුවමාරු කිරීම

JSP හි, JavaBeans පරිශීලක ඇතුළත් දත්ත හෝ ප්‍රදර්ශනය සඳහා අවශ්‍ය දත්ත රැඳවීමට බහුලව භාවිතා වේ.

<jsp:useBean id="user" class="com.example.UserBean" scope="request" />
<jsp:setProperty name="user" property="name" value="Sato" />
<jsp:setProperty name="user" property="age" value="28" />

<p>Name: <jsp:getProperty name="user" property="name" /></p>
<p>Age: <jsp:getProperty name="user" property="age" /></p>

• <jsp:useBean> : JavaBean උදාහරණය නිර්මාණය කරයි හෝ ලබා ගනී
• <jsp:setProperty> : ගුණාංග අගයන් සකසයි
• <jsp:getProperty> : ගුණාංග අගයන් ප්‍රදර්ශනය කරයි

Servlets සමඟ ඒකාබද්ධ කිරීම | JavaBeans භාවිතයෙන් ඉල්ලීම් දත්ත කළමනාකරණය

JavaBeans Servlets සහ JSP අතර දත්ත හුවමාරුව සඳහා ඉතා ප්‍රයෝජනවත් වේ. පහත දැක්වෙන්නේ ඉල්ලීම් පරාමිතීන් JavaBean එකකට සුරකිමින් JSP වෙත යැවීමේ සාමාන්‍ය ක්‍රියාවලියයි.

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    String name = request.getParameter("name");
    int age = Integer.parseInt(request.getParameter("age"));

    UserBean user = new UserBean();
    user.setName(name);
    user.setAge(age);

    request.setAttribute("user", user);
    request.getRequestDispatcher("/result.jsp").forward(request, response);
}

With this approach, on the JSP side, accessing the user JavaBean allows for handling multiple data fields in a simplified manner.

Integration with Spring Framework | DI and Automatic Property Binding

In Spring, JavaBeans are commonly used as DI targets and form binding targets.

Example of Form Binding in a Controller (Spring MVC):

@PostMapping("/register")
public String register(@ModelAttribute("user") UserBean user) {
    // Form values are automatically bound to user
    System.out.println(user.getName());
    System.out.println(user.getAge());
    return "result";
}

• When property names match the name attribute in forms, @ModelAttribute automatically binds values.
• This works because JavaBeans naming conventions are followed.

Using applicationContext.xml as a DI Target:

<bean id="userBean" class="com.example.UserBean">
    <property name="name" value="Yamada" />
    <property name="age" value="35" />
</bean>

With XML or annotations, property injection becomes possible.

Use as DTO (Data Transfer Object)

JavaBeans are also commonly used as DTOs in web APIs or batch processing. Mapping JSON data into JavaBeans makes structured data management easier.
Spring Boot + Jackson example:

public class UserBean {
    private String name;
    private int age;

    // getter, setter omitted
}

@PostMapping("/api/user")
public ResponseEntity<?> receiveUser(@RequestBody UserBean user) {
    // JSON → JavaBeans automatic conversion
    return ResponseEntity.ok("Received: " + user.getName());
}

Quick Recap: JavaBeans Increase “Connectivity” Between Technologies

JavaBeans act less as standalone classes and more as “glue” between other technologies. By following conventions, automation and simplification of development become possible, and maintainability and reusability are greatly improved.

6. Advantages and Disadvantages of JavaBeans | Deciding When to Use Them

Advantages of JavaBeans

JavaBeans are a very frequently used design pattern in Java development, and adopting them provides many benefits. Below are the main advantages.

1. Improved Maintainability and Reusability

JavaBeans allow objects to be manipulated through clearly defined properties and accessor methods (getters and setters). Therefore, data structures become easy to understand at a glance, making the code easier for other developers to comprehend and modify. Also, the same Bean can be reused in multiple places, which increases reusability and avoids redundant code.

2. Easy Integration with Frameworks

Many Java frameworks and tools—Spring, JSP, JavaFX, etc.—support the JavaBeans specification. By simply following naming conventions, automatic form data binding and automatic value loading from configuration files become possible.

3. Data Protection Through Encapsulation

JavaBeans define properties as private and expose access through public getter/setter methods. This prevents external code from directly modifying fields and ensures data consistency. Setter methods can also include validation logic, allowing easy introduction of input checks to prevent invalid values.

Disadvantages of JavaBeans

On the other hand, JavaBeans also have points that require caution, and there are cases where they are not suitable depending on the purpose.

1. Code Tends to Become Verbose

In JavaBeans, the number of getters/setters increases in proportion to the number of properties. Therefore, beans with dozens of properties require many boilerplate code blocks, making class files more cluttered.

2. Mixing Business Logic Blurs Responsibility

JavaBeans විශේෂයෙන් “දත්ත රඳවා ගෙන යාම” සඳහා නිර්මාණය කර ඇත.
ව්‍යාපාරික තර්කය ඒවා තුළ ඇතුළත් කරන විට, ඒවා මුල් භූමිකාවෙන් ව්‍යතිරේක වේ.
කාර්යභාරයන් මිශ්‍ර කිරීම පරීක්ෂණය අධික කරයි සහ අනාගත නඩත්තු කිරීම දුෂ්කර කරයි.

3. වස්තු අකාරය (Immutability) නඩත්තු කිරීම අමාරුයි

JavaBeans සෙටර් ක්‍රම ලබා දීම නිසා වෙනස්කම් (තත්ත්ව වෙනස්වීම්) ඇති බව අනුමාන කරයි. ක්‍රියාකාරී වැඩසටහන් හෝ තන්තුව ආරක්ෂාවට අවධානය යොමු කරන ව්‍යුහ සඳහා, මෙය අකාරය (immutability) රැක ගැනීමේ අවශ්‍යතාවයට ගැලපීමේ ගැටළුවක් විය හැක.

JavaBeans භාවිතා කළ යුතු අවස්ථා / ඒවා වලක්විය යුතු අවස්ථා

නිර්දේශිත භාවිතා අවස්ථා:

• Spring, JSP, JavaFX වැනි රාමුකට්ටල සමඟ ඒකාබද්ධ කිරීමේදී
• වෙබ් පෝරම / ඉල්ලීම් දත්ත හුවමාරු කිරීමේදී
• සැසිය-පරාසය හෝ සීරීකරණ-ඉලක්ක දත්ත වස්තු
• DTO (දත්ත හුවමාරු වස්තුව) භාවිතය

වලක්විය යුතු අවස්ථා:

• තදින් ඇතුළත් තර්ක සහ තත්ත්වය සමඟ සංකීර්ණ ව්‍යාපාරික ආකෘති
• සමකාලීන සැකසුම්හි ස්ථාවර තත්ත්වයක් අවශ්‍ය වන අවස්ථා
• කුඩා පරිමාණ අවස්ථා, එහි getter/setter නිර්වචන අධික වන විට (Records හෝ Lombok භාවිතය සලකා බලන්න)

සාරාංශය: JavaBeans “නිවැරදිව භාවිත කළ යුතු මෙවලම්” වේ

JavaBeans ජාවා සංවර්ධනයේ පුළුල් ලෙස භාවිතා වන අතර එය සාමාන්‍ය ලෙස ගණන් කරයි.
එබැවින් “නිවැරදිව නිර්මාණය කළ JavaBeans” ලිවීමේ හැකියාව තවත් සංවර්ධකයන් සමඟ ස smoother සන්නිවේදනයට සෘජුවම දායක වේ.
අනෙක් වචනයෙන්, JavaBeans “කේතය හරහා ඔබේ අදහස් නිවැරදිව ප්‍රකාශ කිරීමේ ආකෘතිය” වේ.
මූලික කරුණු අගය කිරීමෙන්, ඔබට ඒවා භාවිතා කර අනාගත කුසලතා සංවර්ධනයට උපකාරී විය හැක.

7. නිතර අසන ප්‍රශ්න (FAQ)

Q1. JavaBeans සහ POJO එකම ද?

A1. ඒවා සමාන සංකල්පයන් වන නමුත් සමාන නොවේ.
POJO (Plain Old Java Object) යනු විශේෂිත විධි නියමයන්ට බඳු නොවන සාමාන්‍ය ජාවා පන්තියක් වන අතර, එය ගුණාංග සහ ක්‍රම පමණක් අඩංගු වේ.
JavaBeans, වෙනත් පැතිකඩින්, නාමකරණ නියමයන් සහ ව්‍යුහ නියමයන් (getter/setter සහ පරාමිතියක් නොමැති නිර්මාතෘ) මත පදනම් වූ සංරචක වේ.

Q2. JavaBeans අදත් සැබෑ සංවර්ධනයේ භාවිතා කරන්නේද?

A2. ඔව්, ඒවා පුළුල් ලෙස භාවිතා වේ.
ඇය JSP, Servlet, Spring Framework වැනි ජාවා-සම්බන්ධ රාමුකට්ටල සමඟ දැඩි අනුකූලතාවයක් ඇති අතර, DTOs, DI ඉලක්ක වශයෙන් නිතර භාවිතා වේ.

Q3. සෙටර් සහ ගෙටර් බොහොමයක් ඇති නිසා කේතය ගැලපෙන්නේ නැත. මෙය කෙසේ හසුරවන්නද?

A3. IDE හෝ Lombok වැනි උපකරණ භාවිතා කරන්න.
Eclipse සහ IntelliJ ස්වයං-නිර්මාණ ක්‍රියාකාරිත්වයක් ඇත, සහ Lombok ඇනෝටේෂන් මගින් getter/setter සහ නිර්මාතෘ ස්වයං-නිර්මාණය සලසයි.

import lombok.Data;

@Data
public class UserBean {
    private String name;
    private int age;
}

Q4. JavaBeans තුළ වලංගුකරණය (ආදාන පරීක්ෂා) කෙසේ ක්‍රියාත්මක කළ යුතුද?

A4. සෙටර් තුළ තර්ක ලියන්න, හෝ Bean Validation භාවිතා කරන්න.

public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age must be 0 or greater");
    }
    this.age = age;
}

Spring හි, JSR-380 (Bean Validation) ඇනෝටේෂන්-මූලික පරීක්ෂා සලසයි.

public class UserBean {
    @NotBlank
    private String name;

    @Min(0)
    private int age;
}

Q5. JavaBeans REST API වල භාවිතා කළ හැකිද?

A5. ඔව්, Spring Boot වැනි පරිසරවල ඉතා සාමාන්‍ය වේ.
@RequestBody JSON දත්ත JavaBeans වෙත පරිවර්තනය කර, ඒවා DTOs ලෙස භාවිතා කරයි.

@PostMapping("/user")
public ResponseEntity<String> addUser(@RequestBody UserBean user) {
    return ResponseEntity.ok("Received name: " + user.getName());
}

Q6. JavaBeans සහ Entity පන්තීන් අතර වෙනස කුමක්ද?

A6. අරමුණ සහ වගකීම් වෙනස් වේ.
Entity පන්තීන් JPA තුළ DB වගු වෙත සම්බන්ධ කර ඇති අතර, ඇනෝටේෂන් භාවිතයෙන් DB මෙහෙයුම් සඳහා නිර්මාණය කර ඇත.
JavaBeans DTOs සඳහා හෝ දෘශ්‍ය ස්ථරයට/සිට දත්ත හුවමාරු කිරීම සඳහා භාවිතා වේ.

8. සාරාංශය | JavaBeans ඉගෙන ගැනීමෙන් ඔබට ලැබෙන වාසි

JavaBeans යනු ජාවා සංවර්ධනයේ “මූලික මූලිකත්වය” වේ

JavaBeans යනු Java යෙදුම් සංවර්ධනයේ අතිමහත් මූලිකත්වයක් වන අතර, පුළුල් පරාසයක ප්‍රායෝගික භාවිතා අවස්ථා ඇත. විශේෂයෙන් පහත සඳහන් අවස්ථා වලදී ඒවා බලවත් වේ:

• වෙබ් පෝරම දත්ත හුවමාරු කිරීම (JSP / Servlet)
• DI / MVC ව්‍යුහවල දත්ත කළමනාකරණය (Spring Framework)
• JSON (REST API / DTO) සිතියම්ගත කිරීම
• සැසියන් හෝ ගොනු වල සුරැකුම් (Serializable)

ආරම්භකයන් සඳහා, JavaBeans “ගෙට්ටර් සහ සෙට්ටර් කට්ටලයක්” ලෙස පෙනෙන්නට හැකිය, නමුත් එම සරලත්වයම ශක්තිමත් හා ඉතා නැවත භාවිතා කළ හැකි නිර්මාණයක් සඳහා සහය දේ.

ඔබ මෙම ලිපියෙන් ඉගෙන ගත් දේ

මෙම ලිපියේ, JavaBeans සම්බන්ධයෙන් පහත සඳහන් ඉගෙනුම් පියවර අනුගමනය කළෙමු:

1. JavaBeans の 定義 と 目的
2. JavaBeans の 構造 と ルール
3. POJO から の 違い と 適用 範囲
4. JSP、Servlet、Spring との 統合
5. 利点 / 欠点 の まとめ と 適切 な 使用 ケース の 判断
6. よくある FAQ を 通じた 理解 の 強化

මෙම සංකල්පයන් Java තාක්ෂණයේ අධික පරිණාමය සඳහා පදනමක් සපයයි.

ඊළඟට ඉගෙන ගත යුතු දේ?

JavaBeans පිළිබඳ ඔබේ අවබෝධය ගැඹුරු කරගත් පසු, පහත පියවරයන් සලස්වා ගැනීමට නිර්දේශ කරයි:

• Spring Framework DI (Dependency Injection) と JavaBeans の 関係
• DTO と Entity の 明確 な 区別
• Lombok または Java Records を 用いた コード の 簡素化
• Bean Validation を 用いた 安全 な 入力 バリデーション の 実装

මෙම දේවල් ඉගෙන ගතහොත්, JavaBeans “දත්ත පන්තියක්” ලෙස පමණක් නොව, රාමු සහ පරිසර තාක්ෂණ සමඟ ඒකාබද්ධ කිරීම සඳහා ශක්තිමත් අතුරුමුහුණතක් ලෙස භාවිතා කළ හැකිය.

අවසාන සටහන: JavaBeans යනු සංවර්ධකයන් අතර පොදු භාෂාවකි

JavaBeans Java සංවර්ධනයේ ඉතා සාමාන්‍යයෙන් භාවිතා වන නිසා, බොහෝ විට ඒවා අසාත්මක ලෙස ගනී. එබැවින් “නිසි ලෙස නිර්මාණය කළ JavaBeans” ලිවීමේ හැකියාව, අනෙකුත් සංවර්ධකයන් සමඟ සාර්ථක සන්නිවේදනයට සෘජුවම දායක වේ.
වෙනත් වචනයෙන් කියනවා නම්, JavaBeans “කේතය හරහා ඔබේ අදහස නිවැරදිව ප්‍රකාශ කිරීමේ ආකෘතිය” වේ.
මූලික කරුණු මත අවධානය තබා, ඔබේ අනාගත තාක්ෂණික වර්ධනයට ඒවා ප්‍රයෝජනවත් ලෙස යොදා ගත හැකිය.