☕Topic: Java Server Pages (JSP) and Enterprise JavaBeans (EJB)
� Introduction (in Hinglish Explanation + English terms)
Java Server Pages (JSP) aur Enterprise JavaBeans (EJB) dono hi server-side Java technologies hain jo
mainly web application development aur enterprise-level business logic ke liye use kiye jaate hain.
Inka main goal hai —
�Web development ko fast, dynamic, aur reusable banana
�Business logic aur presentation logic ko separate rakhna
� �⃣ Java Server Pages (JSP)
�Definition & Concept:
JSP ek server-side technology hai jo HTML pages ke andar Java code embed karne ki facility deti hai.
Iska use dynamically web content (jaise user-specific pages) generate karne ke liye hota hai.
Yaani ki JSP file .jsp extension wali hoti hai, jisme HTML ke sath Java code likha ja sakta hai.
Server us code ko Servlet me convert karke execute karta hai.
�Working of JSP (Step-by-Step):
1. Client Request:
o Jab client kisi .jsp page ko request karta hai, request server ko jaati hai.
2. JSP Translation:
o JSP engine us .jsp page ko Java Servlet me convert karta hai.
3. Compilation:
o Servlet compile hota hai aur .class file banata hai.
4. Execution:
o Servlet run hota hai aur dynamic HTML response generate karta hai.
5. Response Sent:
o Web page browser par display hota hai.
�JSP Architecture:
Client (Browser) → Web Server (JSP Engine) → Servlet Container → Database / Resources
�JSP Elements:
Element Description
Directives (<%@ ... %>) Page settings define karta hai (e.g., imports, buffering).
Declarations (<%! ... %>) Class-level variables or methods declare karta hai.
Scriptlets (<% ... %>) Java code likhne ke liye use hota hai.
Expressions (<%= ... %>) Output ko directly HTML me print karta hai.
Comments (<%-- ... --%>) JSP comments jo browser me visible nahi hote.
�Example JSP Code:
<%@ page language="java" contentType="text/html" %>
<html>
<body>
<%
String name = [Link]("user");
[Link]("Welcome " + name + " to Java Server Pages!");
%>
</body>
</html>
➡�Output:
If URL = [Link]
Then Output = Welcome Vivek to Java Server Pages!
�Advantages of JSP:
�Easy to create dynamic web pages
�Automatically compiled into Servlets
�Tag-based structure — easy for HTML designers
�Code reusability and modularity
�Fast development and platform independent
�Disadvantages of JSP:
�Mixing HTML and Java makes large projects complex
�Debugging is difficult
�Performance slightly slower than pure Servlets
� �⃣ Enterprise JavaBeans (EJB)
�Definition & Concept:
Enterprise JavaBeans (EJB) ek server-side component architecture hai jo distributed, transactional, and
secure enterprise-level applications banane ke liye use hota hai.
EJBs mainly handle business logic (backend processing) while JSP/Servlets handle presentation logic
(frontend).
�Types of EJB:
Type Description
1. Session Bean Handles business logic for a single client session. (e.g., user login)
2. Entity Bean Represents data stored in a database (like a table row).
3. Message-Driven Bean Used for asynchronous communication using JMS (Java Messaging Service).
�Session Bean Types:
Type Explanation
Stateless Does not store client state. Each request is independent.
Stateful Maintains client state between multiple requests.
Singleton One instance shared across all clients.
�EJB Architecture:
Client Application → EJB Container → EJB Components → Database/Resources
�EJB Life Cycle (Stateless Bean):
1. Instantiation → Bean created by EJB container
2. Dependency Injection → Resources provided
3. Method Invoked → Business method executes
4. Destruction → Bean removed from container
�Example (Stateless EJB):
import [Link];
@Stateless
public class CalculatorBean {
public int add(int a, int b) {
return a + b;
}
}
➡� Is bean ko kisi JSP ya Servlet se call kiya ja sakta hai for backend business logic.
�Advantages of EJB:
�Simplifies enterprise-level development
�Provides security and transaction management automatically
�Supports distributed (multi-server) applications
�Reusable components
�Scalable and robust
�Disadvantages of EJB:
�Complex setup
�Requires Application Server (like GlassFish, JBoss)
�Overhead for small projects
� JSP vs EJB Comparison:
Feature JSP EJB
Purpose For presentation (UI) For business logic (backend)
Type Web-page technology Server-side component model
Executes on Web Container EJB Container
Focus User interaction Database / business processing
Example Use Displaying user info Processing transactions
�Example (Integration of JSP and EJB):
A JSP page takes user input (like loan amount), sends it to an EJB which calculates interest and sends result
back to JSP for display.
�Conclusion:
JSP provides an easy way to build dynamic web interfaces,
and EJB provides a strong backend framework for business logic and database handling.
Together, they form the foundation of Java Enterprise Edition (J2EE) architecture for scalable enterprise
applications.
�Short English Definition (for 5 Marks):
Java Server Pages (JSP) are server-side Java technologies used to create dynamic web content by embedding
Java code in HTML.
Enterprise JavaBeans (EJB) are reusable server-side components that encapsulate business logic and provide
services like transactions, security, and scalability for enterprise applications.
Chalo � is topic “JSP Scripting Elements – Tags - Variables and Objects – Methods” ko hum detail +
Hinglish mein samajhte hain �
� JSP (Java Server Pages) Overview
JSP ek server-side technology hai jiska use dynamic web pages banane ke liye hota hai.
Isme HTML + Java code dono likh sakte ho ek hi file ke andar.
JSP file ka extension hota hai .jsp, aur ye internally servlet mein convert hoti hai.
JSP → Servlet → HTML output browser mein show hota hai.
� 1. JSP Scripting Elements
JSP mein scripting elements ka use Java code ko HTML ke andar likhne ke liye hota hai.
Ye 3 types ke hote hain �
(a) Declarations (<%! %>)
Declaration block ka use variables or methods define karne ke liye hota hai.
Ye servlet class ke outside service() method ke likhe jaate hain.
�Syntax:
<%! int count = 0; %>
<%! public int add(int a, int b) {
return a + b;
} %>
�Explanation:
Variable count global hai — har request ke liye same rehega.
Method add() ko JSP ke andar kahin bhi use kar sakte ho.
(b) Scriptlets (<% %>)
Scriptlet tag ke andar likha Java code service() method ke andar convert hota hai.
Ye request ke hisaab se baar-baar run hota hai.
�Syntax:
<%
int a = 10, b = 20;
int c = a + b;
[Link]("Sum: " + c);
%>
�Explanation:
out implicit object use hota hai HTML mein print karne ke liye.
Har baar page reload hone par ye code run hota hai.
(c) Expressions (<%= %>)
Expression tag ka use directly output show karne ke liye hota hai.
Ye automatic [Link]() call karta hai.
�Syntax:
<%= "Welcome " + [Link]("username") %>
�Explanation:
Agar user ne form mein username dala, to ye line usko print karegi.
� 2. JSP Tags
JSP mein kuch standard tags use hote hain — ye HTML aur Java ko mix karne mein madad karte hain.
Common JSP Tags:
Tag Description
<%@ %> Directive tag – e.g. include, page info
<jsp:include> Include another JSP file
<jsp:forward> Forward request to another resource
<jsp:param> Parameter pass karne ke liye
<jsp:useBean> JavaBean object use karne ke liye
�Example:
<%@ page language="java" contentType="text/html" %>
<jsp:include page="[Link]" />
� 3. Variables and Objects in JSP
JSP mein kuch implicit (predefined) objects hote hain — jinko manually create karne ki zarurat nahi hoti.
�Common JSP Implicit Objects:
Object Description
request HTTP request data (form input, parameters)
response HTTP response data
out Output stream for writing to client
session Session data store karne ke liye
application Global data for the web app
config Servlet configuration info
pageContext Access to all JSP objects
page Current JSP page (this reference)
exception Exception object for error page
�Example:
<%
String user = [Link]("uname");
[Link]("username", user);
%>
Welcome <%= [Link]("username") %>
� 4. Methods in JSP
Methods ko declaration block (<%! %>) mein define kiya jata hai aur JSP page mein call kar sakte ho.
�Example:
<%!
public int multiply(int a, int b) {
return a * b;
}
%>
<%
int result = multiply(5, 10);
[Link]("Result: " + result);
%>
� English Definition
JSP Scripting Elements are special tags used to insert Java code into HTML pages.
They include declarations (<%! %>), scriptlets (<% %>), and expressions (<%= %>).
JSP also provides implicit objects like request, response, session, and out for web interaction.
Methods can be defined in declaration blocks and called in scriptlets for logic implementation.
Bahut badhiya topic � — chalo samajhte hain User Sessions, Cookies aur Session Objects in JSP (Java
Server Pages) step by step, exam likhne layak Hinglish + end me English definition ke sath �
☕Topic: User Sessions – Cookies – Session Objects
� Introduction
JSP (Java Server Pages) dynamic web pages banata hai. Jab koi user website par visit karta hai, to server us
user ke liye ek temporary connection banata hai jise hum session kehte hain.
Session user ki activities (jaise login info, cart items, preferences) ko track karta hai.
Web is stateless by nature — matlab har request independent hoti hai.
Isliye JSP me Sessions aur Cookies ka use hota hai taaki user ke data ko store aur track kiya ja sake.
� �⃣ Cookies
Definition (Hinglish):
Cookies chhoti text files hoti hain jo client (browser) me store hoti hain.
Server cookies me user-related data bhejta hai, jo har request ke sath wapas server ko milta hai.
Example:
<%
Cookie c1 = new Cookie("username", "Vivek");
[Link](60*60*24); // 1 day
[Link](c1);
%>
Explanation:
Yahan ek cookie username bana kar browser me store kar di gayi hai.
setMaxAge() specify karta hai ki cookie kitne time tak valid rahegi.
To read cookie:
<%
Cookie ck[] = [Link]();
for (Cookie c : ck) {
[Link]([Link]() + " = " + [Link]() + "<br>");
}
%>
Uses:
User ko remember karna (Remember Me option)
Last visit info store karna
Login auto-fill
�� �⃣ Session
Definition (Hinglish):
Session ek temporary storage area hai jo per user basis par server me maintain hota hai.
Server har user ke liye ek unique session ID generate karta hai.
Session automatically JSP me available hoti hai as an implicit object (session).
Example:
<%
String uname = [Link]("uname");
[Link]("user", uname);
[Link]("Session created for user: " + uname);
%>
To retrieve session data:
<%
String user = (String)[Link]("user");
[Link]("Welcome, " + user);
%>
To destroy session:
<%
[Link]();
%>
Uses:
Login/logout functionality
Shopping cart data maintain karna
Temporary user preferences store karna
� �⃣ Session Objects
Definition (Hinglish):
JSP ka session object ek HttpSession class ka instance hota hai jo user-specific data ko store karta hai.
Common methods:
Method Description
setAttribute(String name, Object value) Data store karta hai session me
getAttribute(String name) Data retrieve karta hai
removeAttribute(String name) Data delete karta hai
Method Description
invalidate() Session destroy karta hai
getId() Unique session ID return karta hai
getCreationTime() Session banne ka time return karta hai
Example:
<%
[Link]("city", "Gurgaon");
String c = (String)[Link]("city");
[Link]("Your city is: " + c);
%>
� Difference between Cookie and Session
Feature Cookie Session
Stored On Client Browser Server
Security Less secure More secure
Data Limit Small (4 KB) Large
Lifetime Can be set manually Till browser close or timeout
Use Remember user info Maintain user interaction
� Use Case Example
�Jab user login karta hai:
1. Server ek session create karta hai.
2. Session ID ek cookie ke form me browser me store hoti hai.
3. Jab tak user logout nahi karta, har request ke sath wo session ID server ko milti rahegi.
� English Definition
Cookies are small text files stored on the client-side browser to keep user-related information.
Sessions are server-side storage mechanisms that maintain user data across multiple requests using a unique
session ID.
The Session Object in JSP is an instance of HttpSession used to store and manage user data securely during a
web session.
Bahut accha topic � — ye JSTL (JavaServer Pages Standard Tag Library) aur Servlets with JSP dono hi
Advance Java ke most important exam aur viva topics hain.
Chalo isko full explain karte hain step-by-step, 15–20 marks level ke Hinglish notes ke form me, aur end me
English definition bhi denge �
☕Topic: JSTL and Servlets with JSP
� �⃣ Introduction
JSP (Java Server Pages) aur Servlets dono hi server-side technologies hain jo dynamic web applications
banane ke kaam aati hain.
Lekin dono ka kaam thoda alag hota hai �
Technology Work
Servlets Java code-based, request/response handle karta hai
JSP HTML-based, presentation (UI) handle karta hai
JSTL JSP ke andar common tasks ke liye predefined tags provide karta hai
In teeno ko milakar Model–View–Controller (MVC architecture) banaya jata hai — jaha:
Servlet = Controller
JSP = View
Database/Beans = Model
� �⃣ JSTL (JavaServer Pages Standard Tag Library)
�Definition:
JSTL ek tag library hai jo JSP me commonly used functionalities (like looping, condition checking, database
access, etc.) ke liye standard tags provide karti hai.
JSTL use karne se JSP me Java code likhne ki zarurat nahi hoti (kyunki <% %> ke andar code likhna avoid
karna best practice hai).
�To use JSTL in JSP:
JSP page ke top par tag library include karte hain:
<%@ taglib uri="[Link] prefix="c" %>
�Types of JSTL Tags:
Type Library URI Prefix Description
Core Tags [Link] c Control flow (if, forEach, etc.)
Formatting Tags [Link] fmt Date, numbers, currency formatting
SQL Tags [Link] sql Database access from JSP
XML Tags [Link] x XML processing
Function Tags [Link] fn String functions (length, substring, etc.)
�Common JSTL Tags Examples:
(a) Conditional Tag:
<c:if test="${marks >= 40}">
<p>You Passed!</p>
</c:if>
(b) Loop Tag:
<c:forEach var="i" begin="1" end="5">
<p>Number: ${i}</p>
</c:forEach>
(c) Choose / When / Otherwise:
<c:choose>
<c:when test="${grade == 'A'}">Excellent</c:when>
<c:otherwise>Try Harder</c:otherwise>
</c:choose>
(d) SQL Tag Example:
<sql:setDataSource var="db" driver="[Link]"
url="jdbc:mysql://localhost/studentdb" user="root" password="root"/>
<sql:query dataSource="${db}" var="rs">
SELECT * FROM student;
</sql:query>
<c:forEach var="row" items="${[Link]}">
${[Link]} - ${[Link]} <br>
</c:forEach>
� �⃣ Servlets with JSP (Integration)
Servlet aur JSP ko saath me use karna best practice hai kyunki dono ka kaam alag hai:
Component Role
Servlet Handles logic, request processing
JSP Displays result to user (UI part)
�Steps to Integrate Servlet and JSP:
�⃣ User JSP page se request bhejta hai (HTML form ke through).
�⃣ Servlet request process karta hai (data validate, DB call, business logic).
�⃣ Servlet output forward karta hai JSP page ko for displaying result.
�Example:
[Link]
<form action="LoginServlet" method="post">
Username: <input type="text" name="user"><br>
Password: <input type="password" name="pass"><br>
<input type="submit" value="Login">
</form>
[Link]
import [Link].*;
import [Link].*;
import [Link].*;
public class LoginServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String user = [Link]("user");
String pass = [Link]("pass");
if([Link]("admin") && [Link]("1234")) {
[Link]("message", "Welcome " + user);
RequestDispatcher rd = [Link]("[Link]");
[Link](request, response);
} else {
[Link]("[Link]");
}
}
}
[Link]
<h2>${message}</h2>
Explanation (Hinglish):
JSP → data input le raha hai
Servlet → logic handle kar raha hai
JSP → output display kar raha hai
Isse MVC (Model–View–Controller) structure ban jata hai.
� Advantages of Using Servlets with JSP
�Code separation (Logic and UI alag)
�Maintainability improve hoti hai
�Reusability of Servlets
�Secure and scalable applications
�JSTL tags ke through cleaner JSP pages
� English Definition
JSTL (JavaServer Pages Standard Tag Library) provides a set of predefined tags that simplify JSP
development by eliminating Java code from JSP pages.
Servlets with JSP work together in MVC architecture — where Servlets handle business logic and JSPs handle
the presentation layer for dynamic web applications.
Perfect � chalo ab samjhte hain ek bahut important Advance Java topic —
�Enterprise JavaBeans (EJB) — jo mostly server-side enterprise applications me use hota hai.
Yahan mai tumhe exam likhne layak (15–20 marks) Hinglish notes + short English definition dunga �
☕Topic: Enterprise JavaBeans (EJB)
� Introduction
Enterprise JavaBeans (EJB) ek server-side component architecture hai jo distributed, transactional, and
secure enterprise-level applications banane ke liye use hota hai.
Simple words me —
EJB ek Java object hai jo server par run hota hai aur business logic handle karta hai, jisse developer ko
networking, transactions aur security ke low-level details ke baare me sochna nahi padta.
� �⃣ What is EJB? (Hinglish Explanation)
EJB ek reusable, managed component hai jise EJB Container control karta hai.
Yani developer sirf apna business logic likhta hai, baki lifecycle, security, transactions, etc. ka dhyan EJB
Container rakhta hai.
EJB mainly use hota hai —
Large-scale business applications me
Multi-user distributed systems me
Banking, insurance, e-commerce jaise domains me
� �⃣ EJB Architecture
EJB Java EE (Jakarta EE) platform ka part hai aur ye EJB Container me deploy hota hai.
Architecture Components:
1. Enterprise Bean (Component) – Business logic hota hai.
2. EJB Container – Bean ka lifecycle, security, transactions handle karta hai.
3. Application Server – Container ko run karne ke liye (e.g., GlassFish, JBoss, WildFly).
4. Client – Remote user ya web component (Servlet, JSP) jo EJB ko call karta hai.
Client → EJB Container → Enterprise Bean → Database
� �⃣ Types of Enterprise JavaBeans
EJB ke 3 main types hote hain �
�(1) Session Bean
Ye ek single client ke liye kaam karta hai. Business logic ko represent karta hai.
Types of Session Beans:
Type Description
Stateless No data memory between method calls (e.g., calculator service)
Type Description
Stateful Maintains client state (e.g., shopping cart)
Singleton One instance per application (e.g., configuration settings)
Example (Stateless Bean):
@Stateless
public class CalculatorBean {
public int add(int a, int b) {
return a + b;
}
}
�(2) Entity Bean
Used to represent persistent data stored in a database.
(But in modern Java EE, replaced by JPA – Java Persistence API)
�(3) Message-Driven Bean (MDB)
Used for asynchronous communication via messaging (e.g., JMS – Java Message Service).
Iska kaam message queue se data receive karna hota hai.
Example:
@MessageDriven
public class NotificationBean implements MessageListener {
public void onMessage(Message msg) {
[Link]("New Message: " + msg);
}
}
� �⃣ Lifecycle of Session Bean
�⃣ Instantiation – Bean create hota hai.
�⃣ Dependency Injection – Resources assign kiye jaate hain.
�⃣ Business Method Invocation – Client bean ke methods call karta hai.
�⃣ Passivation/Activation (for Stateful) – Idle beans temporary store hote hain.
�⃣ Destruction – Bean destroy hota hai when not needed.
� �⃣ Features of EJB
Feature Description
Transaction Management Automatic handling of database transactions
Security Role-based access control
Remote Access Beans ko remote clients call kar sakte hain
Persistence Data automatically store hota hai
Scalability Supports multiple users easily
Reusability Components reusable across applications
� �⃣ Advantages of EJB
�Reduces development time (no need to manage system-level details)
�Built-in support for transactions and security
�Portable across all Java EE servers
�Scalable and reusable components
�Helps in developing distributed and enterprise-level apps
� �⃣ Disadvantages of EJB
�Complex setup and configuration
�Slower performance for small apps (overhead)
�Requires EJB server (e.g., JBoss, GlassFish)
� Example Use Case
�Banking Application
EJB manages transactions like ―transfer money‖, ―check balance‖.
Stateless beans handle transaction logic.
Stateful beans maintain customer session.
MDB beans process background notifications or alerts.
� English Definition
Enterprise JavaBeans (EJB) is a server-side component architecture for building distributed, scalable, and
transactional enterprise applications.
EJBs run inside an EJB container, which manages their lifecycle, security, and transaction handling, allowing
developers to focus only on business logic.
Let’s understand Deployment Descriptors in Enterprise JavaBeans (EJB) — in easy Hinglish + English
definition �
�Concept: Deployment Descriptors (in EJB)
Definition:
Deployment Descriptor ek XML file hoti hai jisme hum EJB application ke configuration details define karte
hain — jaise ki beans ka type, transaction rules, security settings, aur environment entries.
Ye file server ko guide karti hai ki application kaise deploy karni hai aur kaise run karni hai.
�Detailed Explanation (Hinglish + English)
Jab hum Enterprise JavaBeans (EJB) banate hain, toh sirf Java code likhna hi kaafi nahi hota.
Server ko ye bhi batana padta hai ki:
o Kaunsa class session bean hai?
o Kaunsa method transactional hai?
o Security rules kya hain?
o Kya naming conventions follow karni hain?
Ye sab information hum Deployment Descriptor (DD) file me likhte hain.
Iska extension hota hai:
�[Link]
�Example (Structure of [Link])
<ejb-jar>
<enterprise-beans>
<session>
<ejb-name>BankAccountBean</ejb-name>
<home>[Link]</home>
<remote>[Link]</remote>
<ejb-class>[Link]</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
�Explanation:
<ejb-name> → Bean ka naam.
<session-type> → Bean stateless hai ya stateful.
<transaction-type> → Transaction container-managed hai ya bean-managed.
�Purpose / Importance
1. Configuration Management: EJB components ke behavior ko specify karta hai.
2. Portability: Alag-alag application servers pe deploy karna easy hota hai.
3. Security & Transactions: Authorization aur transaction policies define karta hai.
4. Separation of Concerns: Business logic aur configuration alag-alag rakhta hai.
�English Definition:
A Deployment Descriptor is an XML configuration file used in Enterprise JavaBeans (EJB) to specify the
settings, properties, and deployment information for the EJB components, such as transaction attributes,
security roles, and bean references. It helps the application server manage the deployment and execution of the
EJBs.
Let’s understand Session JavaBean (Session Bean) in Advance Java / Enterprise JavaBeans (EJB) — full
Hinglish explanation + English definition �
� Session JavaBean (Session Bean)
�Basic Concept:
Session Bean ek Enterprise JavaBean (EJB) hoti hai jo client ke sath ek temporary interaction (session)
maintain karti hai.
Ye bean business logic perform karti hai — jaise calculation, database operation, ya transaction handling.
Session Bean ka life cycle client ke session tak limited hota hai.
�Simple Explanation (Hinglish + English)
Jab koi client (for example, ek Java program ya web app) EJB server ko request karta hai,
toh Session Bean create hoti hai jo client ke request ke hisaab se kaam karti hai.
Jab client ka kaam khatam ho jata hai → bean destroy ho jati hai.
Isliye ise Session Bean kaha jata hai — kyunki ye ek particular session ke liye hi exist karti hai.
� Types of Session Beans
�⃣ Stateless Session Bean
Client ke sath koi state (data) maintain nahi karti.
Har request independent hoti hai.
Fast hoti hai aur lightweight.
�Example:
Login validation, online ticket price calculation, etc.
�⃣ Stateful Session Bean
Client ke sath state maintain karti hai (yaani previous interactions ya data yaad rakhti hai).
Jab tak client connected hai tab tak data stored rehta hai.
�Example:
Online shopping cart (jisme items add karte jaate hain).
�⃣ Singleton Session Bean
Application me ek hi instance hoti hai.
Saare clients same bean instance share karte hain.
Shared data or configuration ke liye useful hoti hai.
�Example:
Logging service, cache management, or configuration manager.
� Example (Simple Stateless Session Bean)
import [Link];
@Stateless
public class CalculatorBean {
public int add(int a, int b) {
return a + b;
}
}
Explanation:
@Stateless → ye batata hai ki bean stateless hai.
add() method → business logic perform karta hai.
EJB container is bean ko manage karta hai (lifecycle, transactions, etc.).
� Lifecycle of Session Bean
1. Instantiation: Container bean ka object banata hai.
2. Dependency Injection: Required resources inject karta hai.
3. Ready State: Bean ready hai client ke request handle karne ke liye.
4. Method Invocation: Client methods call karta hai.
5. Destruction: Session end hone par bean destroy hoti hai.
� Advantages of Session Beans
Reusable and modular business logic
Easy transaction management
Scalability (multiple clients ke sath kaam kar sakti hai)
Security handled by container
� English Definition:
A Session JavaBean (Session Bean) is an Enterprise JavaBean (EJB) that encapsulates business logic and
serves a single client for a limited period of time. It can be stateless, stateful, or singleton, depending on
whether it maintains a client-specific state or not.
Perfect �
Chalo ab samajhte hain Entity JavaBean (Entity Bean) — full 15–20 marks Hinglish notes ke style me,
exam likhne layak explanation ke sath �
� Entity JavaBean (Entity Bean)
�Basic Concept:
Entity Bean ek Enterprise JavaBean (EJB) hoti hai jo database ke ek record (data entity) ko represent karti
hai.
Ye bean directly database ke table ke saath map hoti hai —
har entity bean ek row ya ek record ke barabar hoti hai.
�Simple Explanation (Hinglish + English)
Entity Bean ka main purpose hota hai persistent data store karna aur access karna.
Jab client kisi data ko insert, update, delete ya fetch karta hai —
toh Entity Bean wo kaam EJB container ke through database par automatically kar deti hai.
Yaani client ko SQL likhne ki zarurat nahi hoti — bean apne aap data handle karti hai.
� Features of Entity Bean
1. Persistent in nature:
Data automatically database me store hota hai, even after application close.
2. Transactional:
Multiple users ke data access ke beech consistency maintain karti hai.
3. Reusable and Secure:
Same bean multiple clients ke liye use hoti hai with container-managed security.
4. Portable:
Entity Bean platform independent hoti hai.
� Types of Entity Beans
�⃣ Container Managed Persistence (CMP)
EJB container database ke saath mapping handle karta hai.
Developer ko manually SQL likhne ki zarurat nahi hoti.
Simple configuration XML file me hoti hai.
�Example:
Container automatically ―Customer‖ bean ko ―Customer‖ table ke saath map karega.
�⃣ Bean Managed Persistence (BMP)
Yahan developer khud JDBC code likhta hai (insert, update, delete, etc.).
Zyada control milta hai par coding complex hoti hai.
�Example:
Developer manually ResultSet aur PreparedStatement ka use karta hai.
� Lifecycle of an Entity Bean
1. Instantiation: Bean object create hota hai.
2. Set Context: EJB container context provide karta hai.
3. Load: Data database se bean me load hota hai.
4. Business Methods Execution: Client methods call karta hai.
5. Store: Data database me wapas save hota hai.
6. Destroy: Bean memory se remove hoti hai.
� Example (Simplified CMP Entity Bean)
import [Link];
import [Link];
@Entity
public class Student {
@Id
private int rollNo;
private String name;
private int marks;
// Getters and Setters
public int getRollNo() { return rollNo; }
public void setRollNo(int rollNo) { [Link] = rollNo; }
public String getName() { return name; }
public void setName(String name) { [Link] = name; }
public int getMarks() { return marks; }
public void setMarks(int marks) { [Link] = marks; }
}
Explanation:
@Entity → ye batata hai ki class ek Entity Bean hai.
@Id → primary key field.
EJB container is bean ke data ko database table ke sath map karta hai.
� Advantages of Entity Beans
Automatic database management
Reusability and modularity
Secure and transactional
Less code for persistence
� Disadvantages
Thoda complex setup (especially in older EJB versions)
Slower performance for simple CRUD operations (compared to direct JDBC)
� English Definition:
An Entity JavaBean (Entity Bean) is an Enterprise JavaBean that represents persistent data stored in a
database. It models a single database entity (such as a table row) and can be managed either by the container
(CMP) or by the developer (BMP).
Perfect �
Chalo ab samajhte hain Message-Driven Bean (MDB) — poore 15–20 marks ke Hinglish notes ke format
me, exam likhne layak explanation ke sath �
� Message-Driven Bean (MDB)
�Basic Concept:
Message-Driven Bean ek asynchronous enterprise bean hoti hai jo Java Message Service (JMS) ke
messages ko handle karti hai.
Iska matlab — ye bean messages ko background me receive aur process karti hai bina client ke directly
interact kiye.
�Simple Explanation (Hinglish + English)
Jab bhi koi client ya system JMS message queue/topic par ek message bhejta hai,
toh Message-Driven Bean us message ko receive karke automatically execute hoti hai.
Client ko directly EJB call karne ki zarurat nahi hoti — communication asynchronous (non-blocking) hota hai.
Yaani agar ek system message bhej raha hai aur dusra receive kar raha hai,
toh dono ek hi time par kaam kar sakte hain bina delay ke.
� Key Features of Message-Driven Bean
1. Asynchronous Communication:
Sender aur receiver alag-alag time par kaam karte hain.
2. No Client Interface:
MDB ke paas koi remote ya local interface nahi hoti (ye directly message receive karti hai).
3. Transactional Support:
MDB transaction ke andar kaam kar sakti hai (for example, database update ke sath).
4. Automatic Invocation:
Message aate hi bean activate ho jati hai — manually call karne ki zarurat nahi.
5. Scalable:
Multiple messages ek sath process kar sakte hain.
� Architecture of Message-Driven Bean
Client (Sender)
↓
JMS Message Queue / Topic
↓
Message-Driven Bean
↓
Business Logic / Database Operation
Client: message bhejta hai
JMS Provider: message ko queue/topic me rakhta hai
MDB: message receive karke process karti hai
� Example: Simple Message-Driven Bean
import [Link];
import [Link];
import [Link];
import [Link];
@MessageDriven
public class OrderMessageBean implements MessageListener {
public void onMessage(Message message) {
try {
TextMessage textMsg = (TextMessage) message;
String orderInfo = [Link]();
[Link]("Order Received: " + orderInfo);
} catch (Exception e) {
[Link]();
}
}
}
Explanation:
@MessageDriven → batata hai ki ye ek Message-Driven Bean hai.
MessageListener interface implement karti hai.
onMessage() method automatic call hota hai jab queue me message aata hai.
� Lifecycle of Message-Driven Bean
1. Bean Creation: Container bean ka instance banata hai.
2. Message Listener Registration: Bean ko JMS destination ke sath register kiya jata hai.
3. Message Arrival: Jab message aata hai → onMessage() call hota hai.
4. Message Processing: Bean message process karti hai.
5. Destruction: Container bean ko destroy karta hai jab kaam khatam ho jata hai.
� Advantages of Message-Driven Beans
Supports asynchronous communication
Decouples sender and receiver (both work independently)
Can handle large number of messages efficiently
Transactional and secure
Perfect for real-time systems (like banking, e-commerce)
� Disadvantages
Debugging asynchronous code is difficult
More setup required (JMS configuration)
No direct client response (fire and forget)
� English Definition:
A Message-Driven Bean (MDB) is an Enterprise JavaBean (EJB) that enables asynchronous message
processing using Java Message Service (JMS). It receives and processes messages automatically without
direct client interaction, making it suitable for distributed and real-time applications.