Skip to content
CampusPrep
IT-505 · Advanced Java Lab/Quick Revision Short Notes

Advanced Java Lab (IT-505) - Unit 1 Short Notes

IT-505: Advanced Java Lab - UNIT 1 Short Notes

Core Theme: Foundation of Java Web Application Development using Servlets & JSP.

1.0 Introduction to Java EE / Jakarta EE Platform & Web Applications

  • 1.1 Evolution: Transition from Core Java (desktop apps) to Enterprise Java (Java EE / Jakarta EE) for building scalable, distributed, multi-tier web applications. Java EE provides specifications (Servlets, JSP, EJB, JPA) implemented by vendors (Tomcat, WildFly).

  • 1.2 n-Tier Architecture:

    • Client Tier: Browser (HTTP client).

    • Web Tier: Servlets & JSP (presentation logic, request handling).

    • Business Tier (EJB): (Optional in basic apps) Business logic.

    • Integration Tier: JMS, web services.

    • Resource Tier: Database, ERP systems.

    [!TIP] For RGPV exams, focus on the Web Tier (Servlets/JSP) as the primary controller and view components.

  • 1.3 Web Container / Servlet Container: Runtime environment (e.g., Apache Tomcat, Jetty) that manages Servlet/JSP lifecycle, provides JSP engine, connection pooling, and security. Tomcat implements Servlet/JSP specifications.

  • 1.4 HTTP/HTTPS Fundamentals:

    • Request Methods: GET (fetch data, idempotent, URL visible), POST (submit data, non-idempotent, body), PUT, DELETE.

    • Structure: Request (Line: Method, URI, Version; Headers; Body) & Response (Line: Version, Status Code; Headers; Body).

    • Status Codes: 200 OK, 302 Found (Redirect), 404 Not Found, 500 Internal Server Error.

  • 1.5 Development Environment Setup:

    • Servlet Container: Download & configure Apache Tomcat. Set CATALINA_HOME, JAVA_HOME.

    • IDE Integration: In Eclipse/IntelliJ, add Tomcat server runtime. Create Dynamic Web Project.

    • Project Structure:

      
ProjectName/

├── src/                    (Java source - Servlets, POJOs)

├── WebContent/

│   ├── WEB-INF/

│   │   ├── web.xml        (Deployment Descriptor)

│   │   └── lib/           (JARs)

│   └── *.jsp, *.html      (Public resources)

2.0 Java Servlet Technology

  • 2.1 What is a Servlet? A Java class that extends server capabilities, handles HTTP requests, and generates dynamic web content. Follows request-response model.

  • 2.2 Key Interfaces/Classes:

    • Servlet (interface): Core lifecycle methods.

    • GenericServlet (abstract class): Protocol-independent implementation.

    • HttpServlet (abstract class): Most used. Provides doGet(), doPost() for HTTP.

  • 2.3 Servlet Lifecycle:

    1. Loading & Instantiation: Container loads class & creates instance.

    2. Initialization (init()): Called once. For one-time setup.

    3. Request Handling (service()): For each request, container calls service(), which by default in HttpServlet routes to doGet()/doPost().

    4. Destruction (destroy()): Called once before removal. For cleanup.

    [!TIP] init() & destroy() execute once; doGet()/doPost() execute per request.

  • 2.4 Handling HTTP Requests/Responses:

    • HttpServletRequest: getParameter(), getHeader(), getSession(), getMethod().

    • HttpServletResponse: setContentType(), getWriter(), sendRedirect(), setStatus().

  • 2.5 Passing Data (Client ↔ Servlet):

    • Query String (GET): url?name=value. Accessed via request.getParameter().

    • HTML Form (POST): <form method="post">. Data in request body.

  • 2.6 Servlet Collaboration:

    • RequestDispatcher (Server-side):

      • forward(request, response): Transfers control & request/response objects to another resource. URL does not change. Used in MVC (Controller → View).

      • include(request, response): Includes response of another resource in current response.

    • sendRedirect() (Client-side): Sends 302 status & Location header. Browser makes new request. URL changes. Used for PRG pattern or redirecting to external site.

    [!TIP] Forward vs Redirect: Forward is faster (single request), Redirect is slower (two requests) but URL updates and avoids form resubmission.

  • 2.7 Servlet Attributes (Scopes):

    • Request Scope: request.setAttribute(name, obj). Lives for one forward/include.

    • Session Scope: session.setAttribute(name, obj). Lives for user session.

    • Context (Application) Scope: getServletContext().setAttribute(name, obj). Lives for entire web app.

  • 2.8 Deployment Descriptor (web.xml):

    • Servlet Declaration: <servlet><servlet-name>...</servlet-name><servlet-class>...</servlet-class></servlet>

    • Servlet Mapping: <servlet-mapping><servlet-name>...</servlet-name><url-pattern>/url</url-pattern></servlet-mapping>

    • Initialization Parameters: <init-param><param-name>...</param-name><param-value>...</param-value></init-param> (Access via getServletConfig().getInitParameter()).

    • Welcome File List: <welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list>.

3.0 JavaServer Pages (JSP) Technology

  • 3.1 What is JSP? Technology for creating dynamic web pages with HTML/XML and Java code. Separates presentation (view) from business logic (servlet/model). JSP is translated to Servlet by container.

  • 3.2 JSP Lifecycle:

    1. Translation: .jsp → .java (Servlet source).

    2. Compilation: .java → .class (Servlet bytecode).

    3. Execution: Servlet service() method handles requests.

    [!TIP] First request is slow (translation/compilation). Subsequent requests are fast.

  • 3.3 JSP Elements:

    | Element Type | Syntax | Purpose | Example | | :--- | :--- | :--- | :--- | | Directive | <%@ directive ... %> | Page-level settings, imports, includes. | <%@ page import="java.util.*" %> | | Declaration | <%! declaration %> | Declare class-level variables/methods. | <%! int count=0; %> | | Scriptlet | <% scriptlet %> | Embed Java code in _jspService() method. Avoid in JSP 2.0+. | <% out.println("Hi"); %> | | Expression | <%= expression %> | Evaluate & print result (converted to out.print()). | <%= new Date() %> | | Action | <jsp:action ...> | Use predefined tags for common tasks. | <jsp:include page="header.jsp" /> |

  • 3.4 Implicit Objects in JSP: Pre-defined variables available in _jspService().

    • request, response, session, application (ServletContext)

    • out (JspWriter), pageContext (central object), config (ServletConfig)

    • page (Object), exception (Throwable, only in error pages).

  • 3.5 JSP Expression Language (EL):

    • Syntax: ${expression}. Evaluates to a value.

    • Accessing Data: ${scope.attribute}`, `${bean.property}, ${map['key']}`, `${list[0]}.

    • Operators: Arithmetic (+, -, *, /, %), Relational (==, !=, <, >), Logical (&&, ||, !), Empty (empty).

    [!TIP] EL implicitly searches scopes in order: page → request → session → application.

  • 3.6 JSP Standard Tag Library (JSTL):

    • Setup: Add jstl.jar & standard.jar to WEB-INF/lib. Use <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>.

    • Core Tags (c):

      • <c:set var="x" value="10" scope="session"/> (Set attribute).

      • <c:out value="${user.name}"/> (Print, escape XML).

      • <c:if test="${user.age > 18}">Adult</c:if>.

      • <c:choose><c:when test="${...}">...</c:when><c:otherwise>...</c:otherwise></c:choose>.

      • <c:forEach var="item" items="${list}">...</c:forEach>.

      • <c:forTokens items="a,b,c" delims="," var="token">...</c:forTokens>.

    • Formatting Tags (fmt): <fmt:formatNumber value="$$\displaystyle {price}" type="currency"/>`, `<fmt:formatDate value=" $${date}" pattern="dd/MM/yyyy"/>.

4.0 Session Management & State Tracking

  • 4.1 HTTP is Stateless: Each request is independent. Server doesn't remember previous requests from same client.

  • 4.2 Session Management Techniques:

    • Cookies: response.addCookie(new Cookie("name", "value")). request.getCookies(). Client-side, limited size, user can disable.

    • URL Rewriting: response.encodeURL("url") appends ;jsessionid=.... Fallback when cookies disabled.

    • Hidden Form Fields: <input type="hidden" name="sessionId" value="...">. Less common.

  • 4.3 HttpSession Object (Primary Method):

    • HttpSession session = request.getSession(); (creates if doesn't exist).

    • session.setAttribute("user", userObj);

    • Object user = session.getAttribute("user");

    • session.removeAttribute("user");

    • session.invalidate(); (Destroy session).

    • Timeout: Configure in web.xml: <session-config><session-timeout>30</session-timeout></session-config> (minutes). Inactivity expires session.

5.0 Advanced Servlet Features

  • 5.1 Filters (javax.servlet.Filter):

    • Purpose: Pre-process request before Servlet & post-process response after Servlet. Used for authentication, logging, compression, encoding.

    • Lifecycle: init(FilterConfig), doFilter(request, response, chain), destroy().

    • Filter Chain: Multiple filters configured in web.xml. chain.doFilter() passes control to next filter/servlet.

  • 5.2 Listeners:

    • ServletContextListener: contextInitialized(), contextDestroyed(). (App startup/shutdown).

    • HttpSessionListener: sessionCreated(), sessionDestroyed().

    • ServletRequestListener: requestInitialized(), requestDestroyed().

  • 5.3 Error Handling:

    • web.xml error-page:

      
<error-page>

    <exception-type>java.lang.Exception</exception-type>

    <location>/error.jsp</location>

</error-page>

    • Page Directive: <%@ page errorPage="error.jsp" %> in JSP.

    • Error JSP: Has implicit object exception (Throwable).

6.0 Database Connectivity (JDBC in Web Apps)

  • 6.1 JDBC Core API Review: DriverManager.getConnection(), Connection, Statement, PreparedStatement (prevents SQL Injection), ResultSet.

  • 6.2 Best Practices:

    • Connection Pooling: Crucial for performance. Use DataSource via JNDI lookup. Container manages pool.

      • Configure in context.xml (Tomcat) or server.xml.

      • Lookup: DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/MyDB");

    • Always use PreparedStatement for user input.

    • Close Resources: ResultSet, Statement, Connection in finally block or try-with-resources.

  • 6.3 MVC Integration:

    • Model: JavaBean/POJO (e.g., User) & DAO (e.g., UserDAO with CRUD methods using JDBC).

    • Controller: Servlet calls DAO, stores result in request/session attribute, uses RequestDispatcher to forward to JSP.

    • View: JSP (with JSTL/EL) only reads attributes & displays. No JDBC code in JSP.

7.0 Introduction to MVC Architecture

  • 7.1 MVC Pattern: Separates application into three components for maintainability, scalability, and separation of concerns.

  • 7.2 Roles:

    • Model: Data & Business Logic. JavaBeans (data holders) & DAO classes (DB operations). Independent of view/controller.

    • View: Presentation. JSP pages with minimal Java code (use JSTL/EL). Displays data from model.

    • Controller: Request Handler & Flow Control. Servlet receives request, invokes model, selects view, forwards.

  • 7.3 Simple CRUD Flow (MVC):

    1. Client → sends request to Controller Servlet (URL pattern).

    2. Servlet → calls DAO/Model method (e.g., userDAO.getAllUsers()).

    3. Servlet → stores List<User> in request attribute.

    4. Servlet → RequestDispatcher.forward("users.jsp").

    5. JSP (View) → uses <c:forEach> to iterate list & display.

    [!TIP] Golden Rule: JSP should NOT contain JDBC or business logic. All processing in Servlet/DAO.

\boxed{\text{Key Exam Focus: Servlet/JSP Lifecycle, RequestDispatcher vs sendRedirect, Scopes, JSTL Core Tags, MVC Flow, Session Management}}

Go to where you left off?

Quick Add to Notes

Save questions, your own notes and screenshots into notes filed by unit. It takes a free account.

Create free account

Have an account? Log in