Scribd
Upload
24 views4 pages

MVC Example with Servlets and JSP

This document describes an example of implementing the Model-View-Controller (MVC) pattern in a web application using Servlets and JSPs. The MVC pattern separates an application into three layers: the Model layer contains the business logic and data, the Controller layer manages application flow and communication between the Model and View layers, and the View layer defines the presentation and user interface. The example implements a student record application with a Student model class, StudentService model class, StudentServlet controller servlet, and student-record.jsp view JSP. The servlet acts as the controller to retrieve student data from the model and pass it to the JSP view for display.

Uploaded by

Tran Duc Duy (K16HL)
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
24 views4 pages

MVC Example with Servlets and JSP

This document describes an example of implementing the Model-View-Controller (MVC) pattern in a web application using Servlets and JSPs. The MVC pattern separates an application into three layers: the Model layer contains the business logic and data, the Controller layer manages application flow and communication between the Model and View layers, and the View layer defines the presentation and user interface. The example implements a student record application with a Student model class, StudentService model class, StudentServlet controller servlet, and student-record.jsp view JSP. The servlet acts as the controller to retrieve student data from the model and pass it to the JSP view for display.

Uploaded by

Tran Duc Duy (K16HL)
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd

MVC example with Servlet and JSP

1. Overview
In this quick article, we'll create a small web application that implements the Model View Controller (MVC)
design pattern, using basic Servlets and JSPs.

We'll explore a little bit about how MVC works, and its key features before we move on to the implementation.

2. Introduction to MVC
Model-View-Controller (MVC) is a pattern used in software engineering to separate the application logic from
the user interface. As the name implies, the MVC pattern has three layers.

The Model defines the business layer of the application, the Controller manages the flow of the
application, and the View defines the presentation layer of the application.

Although the MVC pattern isn't specific to web applications, it fits very well in this type of applications. In a
Java context, the Model consists of simple Java classes, the Controller consists of servlets and the View consists
of JSP pages.

Here're some key features of the pattern:

 It separates the presentation layer from the business layer


 The Controller performs the action of invoking the Model and sending data to View
 The Model is not even aware that it is used by some web application or a desktop application

Let's have a look at each layer.

2.1. The Model Layer

This is the data layer which contains business logic of the system, and also represents the state of the
application.

It's independent of the presentation layer, the controller fetches the data from the Model layer and sends it to the
View layer.

2.2. The Controller Layer

Controller layer acts as an interface between View and Model. It receives requests from the View layer and
processes them, including the necessary validations.

The requests are further sent to Model layer for data processing, and once they are processed, the data is sent
back to the Controller and then displayed on the View.

2.3. The View Layer

1
This layer represents the output of the application, usually some form of UI. The presentation layer is used to
display the Model data fetched by the Controller.

3. MVC With Servlets and JSP


To implement a web application based on MVC design pattern, we'll create the Student and StudentService
classes – which will act as our Model layer.

StudentServlet class will act as a Controller, and for the presentation layer, we'll create [Link] page.

Now, let's write these layers one by one and start with Student class:

public class Student {


private int id;
private String firstName;
private String lastName;

// constructors, getters and setters goes here


}

Let's now write our StudentService which will process our business logic:

public class StudentService {

public Optional<Student> getStudent(int id) {


switch (id) {
case 1:
return [Link](new Student(1, "John", "Doe"));
case 2:
return [Link](new Student(2, "Jane", "Goodall"));
case 3:
return [Link](new Student(3, "Max", "Born"));
default:
return [Link]();
}
}
}

Now let's create our Controller class StudentServlet:

@WebServlet(
name = "StudentServlet",
urlPatterns = "/student-record")
public class StudentServlet extends HttpServlet {

2
private StudentService studentService = new StudentService();

private void processRequest(


HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String studentID = [Link]("id");


if (studentID != null) {
int id = [Link](studentID);
[Link](id)
.ifPresent(s -> [Link]("studentRecord", s));
}

RequestDispatcher dispatcher = [Link](


"/WEB-INF/jsp/[Link]");
[Link](request, response);
}

@Override
protected void doGet(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

processRequest(request, response);
}

@Override
protected void doPost(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

processRequest(request, response);
}
}

This servlet is the controller of our web application.

First, it reads a parameter id from the request. If the id is submitted, a Student object is fetched from the
business layer.

Once it retrieves the necessary data from the Model, it puts this data in the request using the setAttribute()
method.

Finally, the Controller forwards the request and response objects to a JSP, the view of the application.

3
Next, let's write our presentation layer [Link]:

<html>
<head>
<title>Student Record</title>
</head>
<body>
<%
if ([Link]("studentRecord") != null) {
Student student = (Student) [Link]("studentRecord");
%>

<h1>Student Record</h1>
<div>ID: <%= [Link]()%></div>
<div>First Name: <%= [Link]()%></div>
<div>Last Name: <%= [Link]()%></div>

<%
} else {
%>

<h1>No student record found.</h1>

<% } %>
</body>
</html>

And, of course, the JSP is the view of the application; it receives all the information it needs from the
Controller, it doesn’t need to interact with the business layer directly.

4. Conclusion
In this tutorial, we've learned about the MVC i.e. Model View Controller architecture, and we focused on how
to implement a simple example.

As usual, the code presented here can be found over on GitHub.

Common questions

Powered by AI

The MVC pattern enhances maintainability by separating concerns within a web application. With Servlets handling the Controller logic and JSPs managing the View, business logic is isolated in the Model layer. This separation allows for independent modification of the user interface or business logic without affecting the other components. Additionally, it simplifies debugging and testing by ensuring each layer focuses on a specific aspect of the application, promoting organized and modular code .

In an MVC-based application using Servlets and JSPs, a request is handled as follows: the user submits a request to the Controller, typically a Servlet, via the View, often a JSP. The Controller reads parameters from the request, processes them, and performs validations. It then interacts with the Model to obtain necessary data. The retrieved data is set as attributes on the request, which the Controller forwards to a JSP for rendering the output. The JSP uses this data to generate the UI, displaying either the relevant data or, if no data is found, an appropriate message .

Utilizing Java classes in the Model layer offers type safety, encapsulation, and object-oriented principles, allowing for structured representation of data and business logic. This enables the implementation of complex business rules directly within Java objects, simplifying debugging and testing. Java's robust standard library aids in processing and manipulating data efficiently, providing reliable data storage and retrieval mechanisms within the application .

To implement a feature listing all students, first extend the Model by adding a method in StudentService to return a list of students, possibly stored in a collection. Modify the StudentServlet (Controller) to handle a new request mapping, e.g., '/student-list', and call this method to fetch the data. Set the list as a request attribute and dispatch the request to a new JSP (e.g., student-list.jsp), which iterates over the list to display each student's details in a formatted table .

The Model layer's independence from the application type ensures its reusability and flexibility. This ignorance of the surrounding context allows the same Model code to be used irrespective of whether the application is web-based or desktop-based, fostering code reuse and reducing duplication. It also simplifies testing and maintenance since the business logic can be developed and tested independently of the user interface .

A developer might choose Java Servlets and JSPs for simplicity and greater control over the application process, suitable for learning or small-scale projects. This approach provides a ground-up understanding of web application flow without abstracting complexities through frameworks, which can be beneficial for educational purposes or when fine-tuning performance is necessary. Additionally, it offers flexibility to design the application structure without being constrained by a specific framework's conventions .

The Controller layer acts as an intermediary between the Model and the View layers. It receives requests from the View layer and processes them, including necessary validations. It then communicates these requests to the Model layer for data processing. Once the data is ready, the Controller receives it from the Model and sends it back to the View for display, maintaining a separation between the business logic and presentation .

One challenge is ensuring clean separation of concerns, as manual handling of data flow through Servlets and JSPs can easily lead to coupling between the View and the Controller layers. Additionally, JSPs may inadvertently have logic embedded, which should remain strictly in the Controller. As projects grow larger, maintaining this architecture without dedicated frameworks can become cumbersome, increasing the risk of errors during enhancements or maintenance. Another potential issue is scalability, as manual management of the three layers might not efficiently handle a large number of concurrent users without optimization .

In the implementation of MVC with Servlets, the Servlet functions as the Controller, directly handling HTTP requests and dispatching to JSPs for the View. This contrasts with other MVC implementations which may use more abstract MVC frameworks, like Spring MVC, where the framework itself manages much of the request handling. This direct approach with Servlets requires more manual coding and management of request dispatching, while more evolved frameworks provide features like dependency injection and automatic URL routing, simplifying development and promoting better modularization .

The Model layer in MVC design pattern acts as the data layer containing the business logic and representing the state of the application. It is independent of the presentation layer. The Controller interacts with this layer to fetch data and send it to the View layer for presentation, without the Model being aware of its use in a web or desktop application .

You might also like