Advanced Programming and Technologies
Assignment: Contact Book Application with JDBC, Servlets, and JSP
Module Code: CS5054NT
Module Leader: Binay Koirala (
[email protected])
Module Tutor: Sujan Subedi (
[email protected])
1. Introduction
In this assignment, you will develop a basic Contact Book Application that allows users to store and
manage their contacts. You will implement the fundamental CRUD (Create, Read, Update, Delete)
operations using JDBC for database connectivity, and create a simple user interface using Servlets and
JSP.
This project will help you understand:
How web applications interact with databases
The MVC (Model-View-Controller) architectural pattern
Basic web application development in Java
1.1 Learning Objectives
By completing this assignment, you will be able to:
Implement the MVC architecture in a Java web application
Use JDBC to connect to and manipulate a database
Create Servlets as controllers to handle user requests
Design JSP pages to display information to users
Apply CRUD operations in a practical application
2. The MVC Architecture
The MVC (Model-View-Controller) pattern is a design pattern that separates an application into three
main components:
2.1 Model
Represents the data and business logic
Handles data storage, retrieval, and validation
Communicates with the database
In this assignment: Java classes that represent contacts and handle database operations
2.2 View
Presents the data to users
Handles the user interface
In this assignment: JSP pages that display forms and contact information
2.3 Controller
Processes user input
Coordinates between Model and View
In this assignment: Servlets that handle HTTP requests and responses
3. Project Requirements
3.1 Functional Requirements
Your Contact Book Application must include the following features:
1. Contact Management
Add new contacts with basic details (name, phone, email, address)
View a list of all saved contacts
View details of a specific contact
Update contact information
Delete contacts
Search for contacts by name
2. User Interface
A clean, easy-to-use interface for all operations
Forms for adding and updating contacts
Confirmation before deleting contacts
3.2 Technical Requirements
1. Database
Use MySQL database
Create a table for storing contact information
Implement appropriate constraints
2. Application Structure
Strictly follow the MVC architecture with three packages:
model : Contact class and database operations
view : JSP pages
controller : Servlet classes
3. Java Technologies
JDBC for database connectivity
Servlets for handling HTTP requests
JSP for the user interface and basic CSS for styling
4. Project Structure
Organize your project with the following structure:
ContactBookApp/
├── src/
│ └── main/
│ ├── java/
│ │ ├── model/
│ │ │ ├── Contact.java
│ │ │ └── ContactDAO.java
│ │ └── controller/
│ │ └── ContactServlet.java
│ └── webapp/
│ ├── WEB-INF/
│ │ └── web.xml
│ ├── view/
│ │ ├── contact-list.jsp
│ │ ├── add-contact.jsp
│ │ ├── edit-contact.jsp
│ │ └── view-contact.jsp
│ └── css/
│ └── style.css
└── pom.xml (or build.gradle)
5. Implementation Guide
5.1 Database Setup
First, create your database and the contacts table:
CREATE DATABASE contactbook;
USE contactbook;
CREATE TABLE contacts (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
phone VARCHAR(20),
email VARCHAR(100),
address VARCHAR(255)
);
5.2 Model Layer
The Model layer will consist of two main components:
1. Contact Class: Represents the data structure
package model;
public class Contact {
private int id;
private String name;
private String phone;
private String email;
private String address;
// Constructor, getters and setters
// ...
}
2. ContactDAO (Data Access Object): Handles database operations
package model;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class ContactDAO {
private Connection connection;
// Constructor that establishes database connection
public ContactDAO() {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
connection = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/contactbook",
"username", "password");
} catch (Exception e) {
e.printStackTrace();
}
}
// Example method for adding a contact
public void addContact(Contact contact) {
try {
String sql = "INSERT INTO contacts (name, phone, email, address) VALUES (?, ?, ?, ?)"
PreparedStatement statement = connection.prepareStatement(sql);
statement.setString(1, contact.getName());
statement.setString(2, contact.getPhone());
statement.setString(3, contact.getEmail());
statement.setString(4, contact.getAddress());
statement.executeUpdate();
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// Add other methods for:
// - getContactById(int id)
// - getAllContacts()
// - updateContact(Contact contact)
// - deleteContact(int id)
// - searchContacts(String name)
}
5.3 Controller Layer
The Controller layer will consist of servlets that handle HTTP requests:
package controller;
import model.Contact;
import model.ContactDAO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
@WebServlet("/contacts/*")
public class ContactServlet extends HttpServlet {
private ContactDAO contactDAO;
public void init() {
contactDAO = new ContactDAO();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String action = request.getPathInfo();
if (action == null) {
action = "/list";
}
switch (action) {
case "/new":
showNewForm(request, response);
break;
case "/edit":
showEditForm(request, response);
break;
case "/delete":
deleteContact(request, response);
break;
case "/view":
viewContact(request, response);
break;
default:
listContacts(request, response);
break;
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String action = request.getPathInfo();
if (action == null) {
action = "/list";
}
switch (action) {
case "/insert":
insertContact(request, response);
break;
case "/update":
updateContact(request, response);
break;
default:
listContacts(request, response);
break;
}
}
// Implement each action method:
// - listContacts(request, response)
// - showNewForm(request, response)
// - showEditForm(request, response)
// - insertContact(request, response)
// - updateContact(request, response)
// - deleteContact(request, response)
// - viewContact(request, response)
}
5.4 View Layer
The View layer will consist of JSP pages:
contact-list.jsp (Example snippet):
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<title>Contact Book</title>
<link rel="stylesheet" href="../css/style.css">
</head>
<body>
<div class="container">
<h1>Contact List</h1>
<div class="search-box">
<form action="contacts/list" method="get">
<input type="text" name="search" placeholder="Search by name...">
<button type="submit">Search</button>
</form>
</div>
<a href="contacts/new" class="btn">Add New Contact</a>
<table>
<tr>
<th>Name</th>
<th>Phone</th>
<th>Email</th>
<th>Actions</th>
</tr>
<c:forEach var="contact" items="${contactList}">
<tr>
<td><c:out value="${contact.name}" /></td>
<td><c:out value="${contact.phone}" /></td>
<td><c:out value="${contact.email}" /></td>
<td>
<a href="contacts/view?id=<c:out value='${contact.id}' />">View</a>
<a href="contacts/edit?id=<c:out value='${contact.id}' />">Edit</a>
<a href="contacts/delete?id=<c:out value='${contact.id}' />"
onclick="return confirm('Are you sure you want to delete this contact?
</td>
</tr>
</c:forEach>
</table>
</div>
</body>
</html>
6. Step-by-Step Implementation Guide
6.1 Set Up Your Environment
1. Set up a Java development environment (Eclipse, IntelliJ, etc.)
2. Install MySQL and MySQL Workbench
3. Configure your web server (Tomcat, Jetty, etc.)
4. Create a new Dynamic Web Project
6.2 Create the Database
1. Run the SQL script from section 5.1 to create the database and table
6.3 Implement the Model Layer
1. Create the model package
2. Implement the Contact class
3. Implement the ContactDAO class with JDBC functionality
6.4 Implement the Controller Layer
1. Create the controller package
2. Implement the ContactServlet class
3. Define all the required action methods
6.5 Implement the View Layer
1. Create JSP pages in the view folder
2. Add CSS styling
3. Implement forms for adding and editing contacts
4. Create the list view for displaying all contacts
6.6 Test Your Application
1. Deploy the application to your web server
2. Test each CRUD operation
3. Verify that all functional requirements are met
7. Documentation Requirements
Along with your application, you must submit a short documentation (3-5 pages) that includes:
1. Project Overview
Brief description of your application
List of implemented features
2. System Architecture
Description of the MVC pattern implementation
Database schema diagram
3. Screenshots
Include screenshots of all main pages
Include screenshots showing each CRUD operation
4. Testing
Describe the testing process
Document at least 5 test cases with expected and actual results
5. Reflection
Challenges faced and solutions implemented
Learning outcomes
Possible future improvements
8. Key Concepts to Understand
8.1 JDBC (Java Database Connectivity)
JDBC is an API for connecting Java applications to databases. Key components include:
Connection: Establishes a connection to a database
Statement: Used to execute SQL queries
PreparedStatement: A more secure way to execute parameterized SQL queries
ResultSet: Contains data retrieved from a database
8.2 Servlets
Servlets are Java classes that handle HTTP requests and generate responses. Key points:
Extend HttpServlet class
Override doGet() and doPost() methods
Use RequestDispatcher to forward requests to JSP pages
8.3 JSP (JavaServer Pages)
JSP is a technology that allows you to embed Java code in HTML pages. Key features:
HTML-like syntax with Java code embedded in tags
JSTL (JSP Standard Tag Library) for common tasks
Expression Language (EL) for accessing data
8.4 MVC Pattern Benefits
Separation of concerns: Each component has a specific responsibility
Code reusability: Components can be reused in different contexts
Ease of maintenance: Changes to one component don't affect others
Parallel development: Different team members can work on different components
9. Submission Guidelines
1. Code Submission
Create a ZIP file containing your entire project
Include all source files, configuration files, and resources
Do not include compiled class files or .war files
2. Documentation Submission
Submit your documentation as a PDF file
Include a cover page with your name, student ID, and module details
Follow the documentation requirements in section 7
3. Deadline
Submit your assignment by [insert deadline]
Late submissions will be penalized according to university policy
10. Contact Information
If you have any questions or need assistance, please contact:
Name Role Email Office Hours
Binay Koirala Module Leader [email protected] Monday, Wednesday 2-4 PM
Sujan Subedi Module Tutor [email protected] Tuesday, Thursday 1-3 PM
11. Resources and References
12.1 JDBC Resources
Oracle JDBC Tutorial: https://docs.oracle.com/javase/tutorial/jdbc/
JDBC PreparedStatement:
https://docs.oracle.com/javase/8/docs/api/java/sql/PreparedStatement.html
12.2 Servlet and JSP Resources
Servlet API Documentation: https://javaee.github.io/javaee-spec/javadocs/
JSP Tutorial: https://docs.oracle.com/javaee/5/tutorial/doc/bnagx.html
JSTL Tutorial: https://www.tutorialspoint.com/jsp/jsp_standard_tag_library.htm
12.3 MVC Pattern Resources
MVC Pattern Overview: https://www.tutorialspoint.com/design_pattern/mvc_pattern.htm
MVC in Java Web Applications: https://www.javatpoint.com/mvc-architecture-in-java
12.4 MySQL Resources
MySQL Documentation: https://dev.mysql.com/doc/
MySQL Connector/J Documentation: https://dev.mysql.com/doc/connector-j/en/
Good luck with your assignment! Remember to start early and ask for help if you need it.
