1. What are the main components of a J2EE application?

Answer:
A J2EE application consists of:

• Client Tier: Web browsers, mobile apps, or desktop clients.

• Web Tier: Servlets, JSPs, or JSF for handling HTTP requests.

• Business Tier: EJBs or Spring beans for business logic.

• Persistence Tier: JPA, Hibernate, or JDBC for database interactions.

 

2. How does J2EE handle request processing in a web application?

Answer:
J2EE follows the MVC pattern:

1. Client sends an HTTP request.

2. Servlet (Controller) processes request and interacts with the model.

3. Model (EJB, POJO, DAO) fetches data from the database.

4. View (JSP, JSF) renders the response.

Example Servlet handling requests:

java

CopyEdit

@WebServlet("/hello") public class HelloServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException { response.getWriter().println("Hello, J2EE!"); } }

 

3. How does J2EE handle transactions?

Answer:
J2EE supports Container-Managed Transactions (CMT) and Bean-Managed Transactions (BMT) using JDBC or JPA.

Example of a declarative transaction in an EJB:

java

CopyEdit

@Stateless public class TransactionService { @Transactional public void transferMoney(Account from, Account to, double amount) { from.debit(amount); to.credit(amount); } }

 

4. What is the difference between a Session Bean and an Entity Bean?

Answer:

FeatureSession BeanEntity Bean (Deprecated)

PurposeBusiness logicPersistence

State ManagementStateless/StatefulPersistent state

LifecycleCreated per requestManaged by container

ReplacementExists in Jakarta EEReplaced by JPA

 

5. What are the different types of J2EE Design Patterns?

Answer:

• Front Controller: Centralized request handling (e.g., Servlets).

• DAO (Data Access Object): Separates database logic from business logic.

• Service Locator: Optimizes JNDI lookups.

• Business Delegate: Hides remote service complexity.

• Factory Pattern: Creates objects dynamically.

Example of DAO pattern:

java

CopyEdit

public class UserDAO { public User getUserById(int id) { return entityManager.find(User.class, id); } }

 

6. How does J2EE support asynchronous processing?

Answer:

• JMS (Java Messaging Service): Handles message queues for background tasks.

• @Asynchronous annotation: Executes methods asynchronously in EJB.

Example of asynchronous EJB method:

java

CopyEdit

@Stateless public class AsyncService { @Asynchronous public Future<String> processTask() { return new AsyncResult<>("Task Completed!"); } }

 

7. What are the different types of J2EE security mechanisms?

Answer:

• Declarative Security: Configured via web.xml or annotations.

• Programmatic Security: Managed manually in Java code.

• JAAS (Java Authentication and Authorization Service): Handles custom authentication.

Example of programmatic security in a Servlet:

java

CopyEdit

if (request.isUserInRole("admin")) { response.getWriter().println("Welcome, Admin!"); } else { response.sendError(HttpServletResponse.SC_FORBIDDEN); }

 

8. How does J2EE implement session management?

Answer:

• HTTP Sessions (HttpSession): Stores user data on the server.

• Cookies: Stores session ID in the browser.

• URL Rewriting: Appends session ID to the URL.

Example of session tracking:

java

CopyEdit

HttpSession session = request.getSession(); session.setAttribute("user", "JohnDoe");

 

9. What are Enterprise JavaBeans (EJB) and their types?

Answer:
EJB is a component used for developing scalable Java EE applications. Types:

• Stateless Session Beans: No client-specific state.

• Stateful Session Beans: Maintain client state.

• Message-Driven Beans: Handle asynchronous messaging.

Example of a Stateless EJB:

java

CopyEdit

@Stateless public class CalculatorBean { public int add(int a, int b) { return a + b; } }

 

10. What is JPA and how does it differ from Hibernate?

Answer:

• JPA (Java Persistence API) is a specification for ORM.

• Hibernate is a JPA implementation with extra features like caching.

Example of JPA Entity:

java

CopyEdit

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private int id; @Column(name="name") private String name; }

11. What is the role of a ServletContext in a J2EE application?

Answer: ServletContext is an interface that defines a set of methods for interaction between the servlet container and the servlet. It provides information about the environment in which the servlet is running.

• Responsibilities:

  • It allows the servlet to access initialization parameters and configuration data.

  • Provides a mechanism to set attributes that are accessible by all servlets within the same web application.

  • It allows the servlet to log messages and access the context's absolute path.

Example:

ServletContext context = getServletContext(); context.setAttribute("key", "value");

 

12. How can you handle session management in a J2EE application?

Answer: In J2EE applications, session management is primarily handled using HTTP sessions and cookies.

• HTTP Session:

  • A HttpSession object is created to maintain session state between client requests. It can store session-related data (e.g., user information).

  • The session ID can be passed to the client in a cookie or via URL rewriting.

• Session Management in Servlets:

  • You can create a session by calling request.getSession() and store objects in the session using session.setAttribute().

Example:

HttpSession session = request.getSession(true); session.setAttribute("username", "john");

 

13. What is the role of ServletFilter in a J2EE application?

Answer: ServletFilter is used to preprocess or postprocess requests and responses in a J2EE application. It allows developers to modify request and response objects, log information, and apply security checks before or after the servlet processes the request.

• Filter Chain: A filter can pass the request to another filter or servlet in the chain.

Common Uses:

• Logging: Logging request details.

• Authentication and Authorization: Checking user roles or credentials before reaching the servlet.

• Compression: Compressing responses before sending them to the client.

Example:

public class MyFilter implements Filter { public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // Preprocessing chain.doFilter(request, response); // Continue the chain // Postprocessing } }

 

14. What are the differences between RequestDispatcher.forward() and RequestDispatcher.include() methods?

Answer:

• forward():

  • Forwards the request from one servlet to another.

  • The response content is replaced by the forwarded servlet's response.

  • After forwarding, the current servlet's request and response cycle is complete.

• include():

  • Includes the output of another servlet into the response of the current servlet.

  • The response from the included servlet is appended to the current response, and the response cycle continues.

Example:

RequestDispatcher dispatcher = request.getRequestDispatcher("/anotherServlet"); dispatcher.forward(request, response); // Forwarding request dispatcher.include(request, response); // Including response

 

15. How does the EJB container handle transaction management?

Answer: In EJB, transaction management can be handled either container-managed or bean-managed:

• Container-Managed Transactions (CMT):

  • The EJB container automatically handles transaction boundaries based on annotations or deployment descriptors.

  • The developer specifies the transaction attributes using the @TransactionAttribute annotation (e.g., REQUIRED, REQUIRES_NEW, SUPPORTS).

• Bean-Managed Transactions (BMT):

  • The bean itself is responsible for managing transactions by using the UserTransaction interface.

  • The developer must explicitly start, commit, or roll back transactions.

 

16. What is the difference between JSP and Servlet in a J2EE application?

Answer:

• Servlet: A servlet is a Java class that handles HTTP requests and generates dynamic responses. Servlets are more programmatic and are usually written for handling business logic or controlling the flow of the application.

• JSP (JavaServer Pages): JSP is a view technology, which allows embedding Java code directly within HTML pages. JSPs are used for presenting content to the client (HTML, CSS) and usually delegate business logic to servlets or EJBs.

Difference:

• Servlets are more suitable for processing requests, while JSPs are for displaying dynamic content.

 

17. What is EJB container and what are its responsibilities?

Answer: The EJB container is a runtime environment for enterprise beans in J2EE. It is responsible for managing the life cycle, security, transactions, concurrency, and other services for EJBs.

Responsibilities:

• Lifecycle Management: Creating, destroying, and managing the beans.

• Transaction Management: Automatically handling transactions (if using container-managed transactions).

• Security: Managing authentication and authorization for EJBs.

• Concurrency Management: Handling multiple concurrent client requests to a single EJB instance.

• Interception: Allows interceptors for pre- and post-method invocation.

 

18. What is a DataSource in J2EE, and how is it different from DriverManager?

Answer: A DataSource is an abstraction used for obtaining database connections. It is a more flexible and efficient way of establishing a connection to a database compared to DriverManager. DataSource is commonly used in J2EE environments where connection pooling and transaction management are required.

• DriverManager: Provides a simple way to get a connection from a specific database driver, but does not provide features like connection pooling.

• DataSource: Managed by the application server or J2EE container, supporting connection pooling and better resource management.

Example:

DataSource dataSource = (DataSource) context.lookup("java:/comp/env/jdbc/myDB"); Connection connection = dataSource.getConnection();

 

19. What is JNDI in J2EE, and how is it used?

Answer: JNDI (Java Naming and Directory Interface) is an API used for locating resources in a J2EE environment, such as data sources, EJBs, mail sessions, and more. It provides a unified interface for accessing various naming and directory services.

Usage:

• Looking up Resources: Resources such as DataSources, JMS queues, EJBs, and more can be looked up from the JNDI context.

Example:

InitialContext context = new InitialContext(); DataSource ds = (DataSource) context.lookup("java:/comp/env/jdbc/MyDataSource");

 

20. What is the web.xml file and what configurations can it include?

Answer: The web.xml file is the deployment descriptor for a web application in J2EE. It contains configuration information about servlets, filters, listeners, and security roles for the web application.

Key Configurations:

• Servlets: Mapping URL patterns to servlets.

• Filters: Configuring filters for preprocessing requests.

• Security Constraints: Defining security roles and constraints for specific URLs.

• Listener Configuration: Specifying listeners for application or session lifecycle events.

 

21. Q: How does J2EE support distributed computing and what protocols are involved?
A:
J2EE supports distributed computing through components like EJBs and JMS. These allow communication across networked systems using protocols like:

• RMI-IIOP (Remote Method Invocation over Internet Inter-ORB Protocol)

• HTTP/HTTPS (for Servlets and JSP)

• SOAP/REST (for Web Services)

• JMS (for asynchronous messaging)

This architecture enables enterprise systems to scale and interoperate over networks.

 

22. Q: How is connection pooling implemented in J2EE and why is it important?
A:
Connection pooling allows multiple clients to reuse a set of pre-established database connections, reducing overhead and improving performance.

Configured via:

• DataSource objects managed by the application server

• JNDI lookups for connection factories

Example (JNDI lookup):

Context ctx = new InitialContext(); DataSource ds = (DataSource) ctx.lookup("java:/comp/env/jdbc/MyDB"); Connection conn = ds.getConnection();

This avoids the cost of repeatedly opening and closing database connections.

 

23. Q: How is thread safety managed in Servlets and EJBs?
A:

• Servlets are inherently multi-threaded; the container creates one instance per servlet and multiple threads may access it. Developers must synchronize shared resources to ensure thread safety.

• EJBs are managed by the container, and stateless EJBs are pooled and reused, so concurrent access is safely managed by the container itself.

Best Practices:

• Avoid using instance variables in Servlets.

• Use local variables or synchronization where necessary.

 

24. Q: What is the role of deployment descriptors (web.xml, ejb-jar.xml) in J2EE applications?
A:
Deployment descriptors are XML files used to configure components, define security, mapping, and lifecycle details.

• web.xml configures Servlets, filters, listeners, and security constraints.

• ejb-jar.xml configures EJBs including transaction types, security roles, and references.

Example (web.xml):

<servlet> <servlet-name>LoginServlet</servlet-name> <servlet-class>com.example.LoginServlet</servlet-class> </servlet>

 

25. Q: How do you ensure security (authentication & authorization) in a J2EE web application?
A:
Security can be implemented using:

• Declarative Security (in web.xml):

<security-constraint> <web-resource-collection> <web-resource-name>Secure Area</web-resource-name> <url-pattern>/admin/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>admin</role-name> </auth-constraint> </security-constraint> <login-config> <auth-method>BASIC</auth-method> </login-config>

• Programmatic Security using HttpServletRequest methods like:

request.isUserInRole("admin"); request.getRemoteUser();

Security realms (defined in the app server) authenticate users and map them to roles.

​