Q1. What are directives? Explain different types of directives in JSP.

Directives in JSP are instructions given to the JSP container that influence the processing of the
entire JSP page. They do not produce any output but control how the JSP is compiled and executed.

Types of Directives:

1. Page Directive:

o Used to define attributes related to the JSP page, such as error handling, session
usage, and content type.

o Syntax: <%@ page attribute="value" %>

o Example:

<%@ page contentType="text/html" language="java" session="true" %>

o Common attributes: language, extends, import, session, isThreadSafe, errorPage,

etc.
2. Include Directive:

• Includes content from another file at page translation time.

• Syntax: <%@ include file="filename" %>

• Example:

<%@ include file="header.jsp" %>

• Use this when the included file's content does not change frequently.
3. Taglib Directive:

• Declares a custom tag library to use tag-based functionality in JSP.

• Syntax: <%@ taglib uri="uri" prefix="prefix" %>

• Example:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

Explanation:

Directives are critical for configuring the page's behavior, such as managing imports, including
reusable components, and using custom tags. They ensure the JSP is processed correctly by the
container.
Q2. Explain Types of Advices with suitable examples.

In Spring AOP (Aspect-Oriented Programming), advice refers to the action taken at a specific join
point. It is the logic that you apply to cross-cutting concerns like logging, security, or transaction
management.

Types of Advice:

1. Before Advice:

o Executes before the method execution.

o Example: Logging before a user logs in.

o Code:

@Before("execution(* com.example.service.*.*(..))")

public void logBefore(JoinPoint joinPoint) {

System.out.println("Executing Before Advice: " + joinPoint.getSignature());

2. After Advice:
• Executes after the method execution, regardless of its outcome.
• Example: Logging after a method completes.
• Code:
@After("execution(* com.example.service.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
System.out.println("Executed After Method: " + joinPoint.getSignature());
}
3. After Returning Advice:

• Executes if the method returns successfully.

• Example: Auditing method results.

• Code:

@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning =

"result")

public void logReturn(Object result) {

System.out.println("Method returned: " + result);

4. After Throwing Advice:

• Executes if the method throws an exception.

• Example: Logging errors during method execution.

• Code:
 @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing =
"exception")

public void logException(Exception exception) {

System.out.println("Exception occurred: " + exception.getMessage());

5. Around Advice:

• Executes before and after the method execution.

• Example: Measuring method execution time.

• Code:

@Around("execution(* com.example.service.*.*(..))")

public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {

long start = System.currentTimeMillis();

Object result = joinPoint.proceed();

long elapsedTime = System.currentTimeMillis() - start;

System.out.println("Execution time: " + elapsedTime + "ms");

return result;

Conclusion:

Advices in Spring AOP help modularize cross-cutting concerns, improving code reusability and
maintainability.
Q3. Explain Data Access operations with JdbcTemplate Class and RowMapper Interface.

JdbcTemplate Class:

The JdbcTemplate class in Spring simplifies database interactions by providing methods for executing
SQL queries, updates, and stored procedures without boilerplate code.

RowMapper Interface:

The RowMapper interface maps rows of a ResultSet to Java objects. It is used to extract data from
the database and map it to objects.

Features of JdbcTemplate:

1. Eliminates boilerplate code for managing connections and exceptions.

2. Provides methods for querying, updating, and batch processing.

3. Integrates with Spring's Data Access Exception hierarchy.

Example Using JdbcTemplate and RowMapper:

public class StudentDAO {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

public List<Student> getAllStudents() {

String sql = "SELECT * FROM students";

return jdbcTemplate.query(sql, new RowMapper<Student>() {

public Student mapRow(ResultSet rs, int rowNum) throws SQLException {

Student student = new Student();

student.setId(rs.getInt("id"));

student.setName(rs.getString("name"));

student.setAge(rs.getInt("age"));

return student;

});

}
Advantages of JdbcTemplate:

1. Reduces code complexity.

2. Handles exceptions automatically.

3. Makes it easier to manage transactions and resources.

Q4. What is Spring Boot? Explain Spring Boot RESTful WebService with example.

Spring Boot Overview:

Spring Boot is a framework built on top of the Spring Framework that simplifies application
development. It provides pre-configured settings for common features, reducing the need for
boilerplate code.

Key Features of Spring Boot:

1. Starter Dependencies: Simplify dependency management.

2. Auto Configuration: Automatically configures Spring components based on classpath

settings.

3. Embedded Servers: Built-in servers like Tomcat and Jetty for easy deployment.

4. Spring Boot CLI: A command-line tool for rapid application development.

Building a RESTful WebService:

A RESTful web service allows communication between systems using HTTP methods like GET, POST,
PUT, and DELETE.

Steps to Create a Spring Boot RESTful Web Service:

1. Add spring-boot-starter-web dependency in pom.xml.

2. Create a Spring Boot application class annotated with @SpringBootApplication.

3. Create a REST controller using @RestController.

4. Use annotations like @GetMapping, @PostMapping, etc., for handling HTTP requests.

Example:

@SpringBootApplication

public class RestServiceApplication {

public static void main(String[] args) {

SpringApplication.run(RestServiceApplication.class, args);

@RestController

@RequestMapping("/api")

public class MyController {

@GetMapping("/greet")

public String greet() {

 return "Hello, Welcome to Spring Boot!";

Explanation:

Spring Boot simplifies RESTful service development by reducing configuration overhead, enabling
developers to focus on business logic.
Q5. Explain all standard actions in JSP and write JSP code using these standard actions for a Login
Page.

Standard Actions in JSP:

Standard actions in JSP are predefined tags used to control runtime behavior.

1. <jsp:useBean>: Instantiates or accesses a JavaBean.

o Example:

<jsp:useBean id="user" class="com.example.User" scope="session" />

2. <jsp:setProperty>: Sets a property of a JavaBean.

• Example:

<jsp:setProperty name="user" property="username" value="John" />

3. <jsp:getProperty>: Retrieves a property value from a JavaBean.

• Example:

<jsp:getProperty name="user" property="username" />

4. <jsp:include>: Includes a resource at runtime.

• Example:

<jsp:include page="header.jsp" />

5. <jsp:forward>: Forwards the request to another resource.

• Example:

<jsp:forward page="home.jsp" />

Example: Login Page Using Standard Actions

<jsp:useBean id="user" class="com.example.User" scope="session" />

<jsp:setProperty name="user" property="*" />

<form method="post" action="login.jsp">

Username: <input type="text" name="username" /><br />

Password: <input type="password" name="password" /><br />

<input type="submit" value="Login" />

</form>

<jsp:getProperty name="user" property="username" />

Q6. What are actions in JSP? Explain any four actions in JSP with suitable examples.

What are JSP Actions?

Actions in JSP are XML-based tags that control the behavior of the JSP engine during request
processing.

Four Common JSP Actions:

1. <jsp:useBean>:

o Used to instantiate or locate a JavaBean.

o Example:

<jsp:useBean id="user" class="com.example.User" scope="session" />

2. <jsp:setProperty>:

o Used to set properties of a JavaBean.

o Example:

<jsp:setProperty name="user" property="username" value="Alice" />

3. <jsp:getProperty>:

o Used to retrieve the value of a property from a JavaBean.

o Example:

<jsp:getProperty name="user" property="username" />

4. <jsp:include>:

o Dynamically includes the content of another resource.

o Example:

<jsp:include page="footer.jsp" />

Explanation:

Actions in JSP are powerful tools to manage JavaBeans and dynamically include or forward resources.
Q7. Explain Dependency Injection with Spring via Setter Injection with suitable example.

What is Dependency Injection (DI)?

Dependency Injection is a design pattern where the dependencies (objects) required by a class are
provided by an external source rather than the class creating them.

Setter Injection:

In Setter Injection, dependencies are injected into a class via setter methods.

Example:

1. Student Class:

public class Student {

private String name;

public void setName(String name) {

this.name = name;

public void displayInfo() {

System.out.println("Student Name: " + name);

2. Spring Configuration (XML):

<bean id="student" class="com.example.Student">

<property name="name" value="John Doe" />

</bean>

3. Main Application:

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

Student student = (Student) context.getBean("student");

student.displayInfo();

Advantages of Setter Injection:

1. Provides flexibility to change dependencies at runtime.

2. Simplifies unit testing by allowing mock dependencies.

Q8. Why do we need Generics? Explain with an example of how Generics make a program more
flexible.

Why Do We Need Generics?

1. To ensure type safety during compile time.

2. To avoid ClassCastException.

3. To write reusable and flexible code.

Example Without Generics:

List list = new ArrayList();

list.add("Hello");

String s = (String) list.get(0); // Requires explicit casting

Example With Generics:

List<String> list = new ArrayList<>();

list.add("Hello");

String s = list.get(0); // No casting needed

Benefits of Generics:

1. Type-safe collections.

2. Reduces runtime errors.

3. Reusable code for different data types.

Q9. Explain JSP architecture with a suitable diagram.

JSP Architecture Overview:

JSP follows a Model-View-Controller (MVC) architecture and operates in the following phases:

1. Translation Phase:

o The JSP file is translated into a servlet by the JSP container.

o This servlet contains the dynamic content of the JSP.

2. Compilation Phase:

o The generated servlet is compiled into bytecode.

3. Execution Phase:

o The compiled servlet is executed, and dynamic content is generated based on the
request.

Components of JSP Architecture:

1. JSP Page:

o The entry point for the request containing static content (HTML/CSS) and dynamic
content (Java code).

2. JSP Container:

o Converts the JSP into a servlet, manages lifecycle, and processes requests.

3. Servlet Engine:

o Executes the servlet and generates the output.

4. Web Server:

o Sends the response back to the client.

Diagram of JSP Architecture:

Client (Browser)

HTTP Request

Web Server + JSP Container

JSP Page -> Translated into Servlet

Servlet Execution -> Generates Response

HTTP Response

Client (Browser)
Q10. Explain Spring AOP in detail.

What is Spring AOP?

Spring AOP (Aspect-Oriented Programming) is a programming paradigm in Spring Framework that

provides a way to modularize cross-cutting concerns such as logging, security, and transaction
management.

Core Concepts of AOP:

1. Aspect:

o A module that encapsulates cross-cutting concerns.

o Example: LoggingAspect, SecurityAspect.

2. Join Point:

o A specific point in the application where an action can be applied, such as method
execution or exception handling.

3. Advice:

o The action taken by an aspect at a join point.

o Types: Before, After, Around, AfterReturning, AfterThrowing.

4. Pointcut:

o A predicate that matches join points to determine where advice is applied.

5. Weaving:

o The process of applying aspects to the target object.

Benefits of AOP:

1. Modularizes cross-cutting concerns.

2. Reduces code duplication.

3. Improves code readability and maintainability.

Q11. Explain Spring Framework with a suitable diagram.

Spring Framework Overview:

Spring is an open-source framework used for building enterprise applications. It provides a

comprehensive infrastructure for dependency injection, AOP, data access, transaction management,
and more.

Core Modules of Spring:

1. Spring Core:

o Provides the foundation for dependency injection and bean lifecycle management.

2. Spring AOP:

o Supports aspect-oriented programming.

3. Spring Data Access:

o Includes JDBC, ORM, and transaction modules.

4. Spring Web:

o Facilitates web application development.

5. Spring Boot:

o Simplifies application setup with auto-configuration and embedded servers.

Diagram of Spring Framework:

-------------------------------------

| Spring Framework |

-------------------------------------

| Core | AOP | JDBC | Web MVC |

-------------------------------------

| Spring Boot |

-------------------------------------
Q12. What is Lambda Expression? Write code on it using Lambda Expression as an Object.

What is Lambda Expression?

Lambda expressions are introduced in Java 8 to provide a concise way to express functional
interfaces. They simplify code by replacing anonymous class implementations.

Syntax of Lambda Expression:

(parameters) -> expression_or_block

Example with Lambda Expression as an Object:

@FunctionalInterface

interface Greeting {

void sayHello(String name);

public class LambdaExample {

public static void main(String[] args) {

Greeting greeting = (name) -> System.out.println("Hello, " + name);

greeting.sayHello("Alice");

}
Q13. Explain Wildcards and its types.

Wildcards in Generics:

Wildcards in Java Generics are used to represent unknown types. They provide flexibility in handling
multiple data types.

Types of Wildcards:

1. Unbounded Wildcard (?):

o Represents any type.

o Example:

List<?> list = new ArrayList<>();

2. Upper-Bounded Wildcard (<? extends T>):

o Restricts the type to T or its subclasses.

o Example:

public void process(List<? extends Number> list) {

for (Number num : list) {

System.out.println(num);

3. Lower-Bounded Wildcard (<? super T>):

o Restricts the type to T or its superclasses.

o Example:

public void addElements(List<? super Integer> list) {

list.add(10);

}
Q14. What is Bean Autowiring and its types of mode?

What is Bean Autowiring?

Autowiring in Spring automatically injects dependencies into a bean by type, name, or constructor
without explicitly specifying them in the configuration.

Types of Autowiring Modes:

1. No Autowiring (no):

o Default mode; manual wiring is required.

2. By Type (autowire="byType"):

o Matches properties by type.

3. By Name (autowire="byName"):

o Matches properties by name.

4. Constructor (autowire="constructor"):

o Matches dependencies by constructor arguments.

5. Autodetect:

o Automatically chooses between constructor and byType.

Q15. Explain session management in JSP with its types. Write a variable value counter program
using cookies.

Session Management in JSP:

Session management is the process of maintaining user state across multiple HTTP requests.

Types of Session Management:

1. Cookies:

o Stores session data on the client side.

2. URL Rewriting:

o Appends session data in the URL.

3. Hidden Form Fields:

o Stores data in hidden fields within forms.

4. HTTP Session:

o Stores data on the server side.

Example: Counter Program Using Cookies

<%

Cookie[] cookies = request.getCookies();

int count = 1;

for (Cookie cookie : cookies) {

if (cookie.getName().equals("counter")) {

count = Integer.parseInt(cookie.getValue()) + 1;

Cookie newCookie = new Cookie("counter", String.valueOf(count));

response.addCookie(newCookie);

%>

<p>Page visited <%= count %> times.</p>

Q16. What is Collections? Explain Set, Map, HashMap, List, and Vector each with suitable code.

What is Collections?

The Collections framework in Java provides a standardized way to store and manipulate groups of
objects.

Examples:

1. Set:

Set<String> set = new HashSet<>();

set.add("A");

set.add("B");

2. Map:

Map<Integer, String> map = new HashMap<>();

map.put(1, "One");

3. HashMap:

HashMap<Integer, String> hashMap = new HashMap<>();

hashMap.put(1, "Value");

4. List:

List<String> list = new ArrayList<>();

list.add("Element");

5. Vector:

Vector<Integer> vector = new Vector<>();

vector.add(10);
Q17. Explain JSP Implicit Objects.

What are JSP Implicit Objects?

JSP implicit objects are pre-defined objects provided by the JSP container. These objects are
automatically available in JSP pages without requiring explicit declaration.

List of JSP Implicit Objects:

1. request: Represents the HTTP request object.

2. response: Represents the HTTP response object.

3. out: Used to send output to the client (browser).

4. session: Represents the session associated with the request.

5. application: Represents the servlet context.

6. config: Represents the servlet configuration.

7. pageContext: Provides access to all scoped objects.

8. page: Refers to the current JSP page instance.

9. exception: Represents the exception object in an error page.

Example: Using Implicit Objects

<%

String username = request.getParameter("username");

out.println("Hello, " + username);

%>
Q18. What is POJO Programming Model? Explain with a suitable example.

What is POJO?

POJO stands for Plain Old Java Object. It is a simple Java class with no special restrictions other than
following Java conventions.

Features of POJO:

1. Does not extend or implement specific classes or interfaces.

2. Contains fields, constructors, getters, and setters.

3. Easy to use and test.

Example of a POJO:

public class Student {

private int id;

private String name;

// Default Constructor

public Student() {}

// Parameterized Constructor

public Student(int id, String name) {

this.id = id;

this.name = name;

// Getters and Setters

public int getId() {

return id;

public void setId(int id) {

this.id = id;

}
 public String getName() {

return name;

public void setName(String name) {

this.name = name;

Advantages of POJO:

1. Increases code readability and maintainability.

2. Simplifies the development process.

3. Compatible with frameworks like Hibernate and Spring.