1. Online Grocery Store
A SUMMER TRAINING PROJECT REPORT
Submitted by-
Kavita Sharma
In partial fulfillment for the award of the degree
Of
BACHELOR OF TECHNOLOGY
in
Branch: INFORMATION TECHNOLOGY
ANSAL INSTITUTE OF TECHNOLOGY
Affliated to
GURU GOBIND SINGH INDRAPRASTHA
UNIVERSITY, DELHI
August 2

2. ABSTRACT
An online Grocery Store permits a customer to submit online orders for
items and/or services from a store that serves both walk-in customers and
online customers. The online Store system presents an online display of
all the items they want to sell. This web based application helps
customers to choose their daily needs and add products to their shopping
cart. Customers provides their complete detail of address and contact
and they get their chosen products in their home.
This Web application saves lots of time of customers.

3. TABLE OF CONTENTS
CHAPTERNO. TITLE PAGENO.
ABSTRACT
LIST OF TABLES
LIST OF FIGURES
LIST OF TABLES
1. INTRODUCTION

4. LIST OF TABLES
1. Customer Table
2. Product Table
3. Category Table
4. Order_Product Table
5. Customer Order Table

5. Introduction to Servlets
Objective
Servlet technology was the original Java based solution for web development
however due to the problems of maintaining the HTML within the Java code
they were never a great success. JSP was the solution to this. However as we
will see later there is still a place for Servlets in Java Server development.
This topic looks at the architecture of a Servlet and how to go about writing
one.
Just What is a Servlet ?
A Servlet is quite simply a java class that adheres to the general model of a
Servlet as defined by the Servlet API. A Servlet Container, also known as a
Servlet Enginetranslates requests from whatever protocol is being used into
objects that the Servlet understands, and also gives the Servlet an object which
it can use to send a response. This container is also responsible for managing
the lifecycle of a Servlet.
Now we have already met the idea of a JSP Container which manages JSP
execution. In fact the JSP Container is only responsible for the rewriting of a
JSP page to a Servlet and then allows the Servlet Container handle the actual
execution.
The Servlet Lifecycle
Servlet containers are responsible for handling requests, passing that request to
the Servlet and then returning the response to the client. The actual
impementation of the container will vary from program to program but the
interface between Containers and Servlets is defined by the Servlet API much
in the same way as there are many JSP Containers all adhering the to JSP
Specification.

6. The basic lifecycle of a Servlet is,
The Servlet Container creates an instance of the Servlet.
The Container calls the instance's init() method.
If the Container has a request for the Servlet it will call the instance's service()
method.
Before the instance is destroyed the Container will call the destroy() method.
Finally the instance is destroyed and marked for garbage collection.
Typically the init() method is only called once and then the service()method is
called repeatedly for each request. This is much more efficient than executing
inti(),service(), destroy() for each request. What happens, you may ask yourself,
when a service() method is still executing when the Container receives another
request ? Typically this will involve the creation of another program execution
thread. In practice, Servlet Containers create a pool of threads to which
incoming requests are generally allocated.
A Basic Servlet
A Servlet is defined by the javax.servlet.Servlet interface. There is also a
GenericServletabstract class which provides a basic implementation of the Servlet
interface. However for this discusssion we will only look at the HttpServlet class
which extends the GenericServletclass. When you come to write a Servlet it will be
this class that you are most likely to extend.
The service() method
The service() method is implemented by the HttpServlet as a dispatcher of HTTP
Requests and therefore should never be overridden. When a request is made the

7. service()method will determine the type of request (GET, POST, etc) and dispacth
it to the appropriate method (doGet(), doPost(), etc). For the most part you will be
overridding doGet()and the doPost() methods. These have message signatures
similar to,
protected void do Post(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, java.io.IOException
We already know the two objects HttpServletRequest and HttpServletResponseas
these are just the implicit objects request and response and can be manipulated in
exactly the same way within the body of the doGet(), doPost()methods.
The init() method
The init() method is executed when the Servlet is first instantiated. The Servlet
container will pass an object of type ServletConfig to the method so that container
specific configuration data can be stored by that Servlet instance for leter use.
Not every Servlet requires that the init() method do something. The type of work
carried out by this method can include such activities as initiating database
connections, establishing default values or instantiating JavaBeans. If your Servlet
doesn't require any kind of initialiation activity then don't include an init() method
in your Servlet
The destroy() method
You can assume that at any given time the Servlet container will decide to remove
the Servlet. This might occur if the Container needs to free some memeory or the
Servlet hasn't been requested for some time. The destroy() method is called prior to
removing of the Servlet so you can use this method for any clean up activity that
may be required; releasing database connections etc.

8. Introduction to JSP
Java Server Pages or JSP for short is Sun's solution for developing dynamic web
sites. JSP provide excellent server side scripting support for creating database
driven web applications. JSP enable the developers to directly insert java code into
jsp file, this makes the development process very simple and its maintenance also
becomes very easy. JSP pages are efficient, it loads into the web servers memory
on receiving the request very first time and the subsequent calls are served within a
very short period of time.
In today's environment most web sites servers dynamic pages based on user
request. Database is very convenient way to store the data of users and other
things. JDBC provide excellent database connectivity in heterogeneous database
environment. Using JSP and JDBC its very easy to develop database driven web
application.
Java is known for its characteristic of "write once, run anywhere." JSP pages are
platform independent. Your port your .jsp pages to any platform.
The Components of JSPs
JSP syntax is almost similar to XML syntax. The following general rules are
applicable to all JSP tags.
1. Tags have either a start tag with optional attributes, an optional body, and a
matching end tag or they have an empty tag possibly with attributes.
2. Attribute values in the tag always appear quoted. The special strings ' and
" can be used if quotes are a part of the attribute value itself.

9. Everything in a JSP page can be divided into two categories:
1. Elements that are processed on the server
2. Template data or everything other than elements, that the engine processing the
JSP engines.
Element data or that part of the JSP which is processed on the server, can be
classified into the following categories:
1. Directives
2. Scripting elements
3. Standard actions
Benefits of JSP
One of the main reasons why the JavaServer Pages technology has evolved into
what it is today and it is still evolving is the overwhelming technical need to
simplify application design by separating dynamic content from static template
display data. Another benefit of utilizing JSP is that it allows to more cleanly
separate the roles of web application/HTML designer from a software developer.
The JSP technology is blessed with a number of exciting benefits, which are
chronicled as follows:
1. The JSP technology is platform independent, in its dynamic web pages, its web
servers, and its underlying server components. That is, JSP pages perform perfectly
without any hassle on any platform, run on any web server, and web-enabled
application server. The JSP pages can be accessed from any web server.

10. 2. The JSP technology emphasizes the use of reusable components. These
components can be combined or manipulated towards developing more purposeful
components and page design. This definitely reduces development time apart from
the At development time, JSPs are very different from Servlets, however, they are
precompiled into Servlets at run time and executed by a JSP engine which is
installed on a Web-enabled application server such as BEA WebLogic and IBM
WebSphere

11. INTRODUCTION TO PROJECT
Concepts:
o Front-end development
o Web application project structure
o Data modeling
o Database connectivity
o Session management
o Transactional business logic
o Client and server-side validation
o Web application Security.
Technologies:
o HTML, CSS, and JavaScript technologies
o Servlet and JavaServer Pages (JSP) technologies
o The JavaServer Pages Standard Tag Library (JSTL)
o Java Database Connectivity (JDBC)
Development Tools:
o NetBeans 6.9 IDE
o GlassFish, a Java EE application server

12. o MySQL, a relational database management server (RDBMS)
Designing the Application
Welcome Page:-
The welcome page is the website's home page, and entry point for the application.
It introduces the business and service to the user, and enables the user to navigate
to any of the four product categories.
category page
The category page provides a listing of all products within the selected category.
From this page, a user is able to view all product information, and add any of the
listed products to his or her shopping cart. A user can also navigate to any of the
provided categories.

13. cart page
The cart page lists all items held in the user's shopping cart. It displays product
details for each item, and tallies the subtotal for the items in the cart. From this
page, a user can:
Clear all items in his or her cart
(Clicking 'clear cart' causes the 'proceed to checkout' buttons and shopping cart
table to disappear.)
Remove item from the Shopping cart.
Return to the previous category by clicking 'continue shopping'
Proceed to checkout

14. checkout page
The checkout page collects information from the customer using a form. This page
also displays purchase conditions, and summarizes the order by providing
calculations for the total cost.
The user is able to send personal details over a secure channel.

15. Designing the Data Model
Entities of the data model:-
1. Customer
2. Category
3. Product
4. Order
Customer Table:-
Product Table:-
Category Table:-

16. Order:-
Connecting Application to the Database
This part focuses on database connectivity of our application to the database, add
the data to the different tables. Then, we need to setup connection pool and data
source on the Glassfish server. We need to retrieve data of category and product
table in our application JSP pages.
Adding data to the Category table:-
Adding data to the Product table:-

17. Creating a connection poll and Data source:-
1. Click the New File button in the IDE's toolbar
2. Select the GlassFish category, then select JDBC
Resource and click Next.
3. Enter details to set up the data source

18. 4.Click Next. In Step 4, Add Connection Pool Properties, specify the following
details:
o
Datasource Classname: com.mysql.jdbc.jdbc2.optional.MysqlDataSource
o
Resource Type: javax.sql.ConnectionPoolDataSource
o
Description: (Optional) Connects to the project database
5.Click Finish. The wizard generates a sun-resources.xml file for the project that
contains all information required to set up the connection pool and data source on
GlassFish. The sun-resources.xml file is a deployment descriptor specific to the
GlassFish application server. When the project next gets deployed, the server will
read in any configuration data contained in sun-resources.xml, and set up the
connection pool and data source accordingly. Note that once the connection pool
and data source exist on the server, your project no longer requires the sun-
resources.xml file.
Quering the Database from JSP:-
Setting Context Parameters:-
This section demonstrates how to configure context parameters for the application,
and how to access parameter values from JSP pages. The owner of an application
may want to be able to change certain settings without the need to make intrusive
changes to source code. Context parameters enable you application-wide access to

19. parameter values, and provide a convenient way to change parameter values from a
single location, should the need arise.
Setting up context parameters can be accomplished in two steps:
1. Listing parameter names and values in the web deployment descriptor
2. Calling the parameters in JSP pages using the initParam object
you create context parameters for the image paths to category and product images
used in the project. Begin by adding the provided image resources to the project,
then perform the two steps outlined above.
1.Import the img folder into the project. the img folder, then in the IDE's
Projects window, paste the folder into the project's Web Pages node.
Open the project's web deployment descriptor. In the Projects window,
expand the Configuration Files node and double-click web.xml.
Click the General tab, then expand Context Parameters and click the Add
button.
In the Add Context Parameter dialog, enter the following details:
o
Parameter Name: productImagePath
o
Parameter Value: img/products/

20. 1. Click OK.
2. Click the Add button again and enter the following details:
o
Parameter Name: categoryImagePath
o
Parameter Value: img/categories/
3. Click the XML tab to view the XML content that has been added to the
deployment descriptor. The following <context-param> entries have been
added:
4. <context-param>
5. <description>The relative path to product images</description>
6. <param-name>productImagePath</param-name>
7. <param-value>img/products/</param-value>
8. </context-param>
9. <context-param>
10. <description>The relative path to category images</description>

21. 11. <param-name>categoryImagePath</param-name>
12. <param-value>img/categories/</param-value>
</context-param>
Accessing database in index page:-
1. In the Projects window, double-click the index.jsp node to open it in the
editor.
2. At the top of the file, before the first <div> tag, place your cursor on a
blank line, then type 'db' and press Ctrl-Space. In the code-completion
pop-up window that displays, choose DB Query and write
<sql:query var="categories" dataSource="jdbc/myaffablebean">
SELECT * FROM category
</sql:query>
3. Then access, the category database using jstl for each loop, by using
following code.
<div id="indexRightColumn">
<c:forEach var="category" items="${categories.rows}">
<div class="categoryBox">

22. <a href="category.jsp?${category.id}">
<span class="categoryLabelText">${category.name}</span>
<img src="${initParam.categoryImagePath}${category.name}.jpg"
style="height:120px; width:180px;"
alt="${category.name}">
</a>
</div>
</c:forEach>
</div>
Accessing database in category page:-
Three aspects of the category page need to be handled dynamically. The left
column must indicate which category is selected, the table heading must display
the name of the selected category, and the table must list product details pertaining

23. to the selected category. In order to implement these aspects using JSTL, you can
follow a simple, 2-step pattern:
1. Retrieve data from the database using the JSTL sql tag library.
2. Display the data using the JSTL core library and EL syntax.
3. In the Projects window, double-click the category.jsp node to open it in the editor.
4. Add the following SQL query to the top of the file.
<sql:query var="categories" dataSource="jdbc/myaffablebean">
SELECT * FROM category
</sql:query>
5.Between the <div id="categoryLeftColumn"> tags, replace the existing static
placeholder content with the following <c:forEach> loop.
<div id="categoryLeftColumn">
<c:forEach var="category" items="${categories.rows}">
<c:choose>
<c:when test="${category.id==pageContext.request.queryString}">
<div class="categoryButton" id="selectedCategory">
<span class="categoryText">${category.name}</span>
</div>
</c:when>

24. <c:otherwise>
<a href="category.jsp?${category.id}" class="categoryButton">
<div class="categoryText">
${category.name}
</div>
</a>
</c:otherwise>
</c:choose>
</c:forEach>
</div>
5. Click on run project.
Session management in online Store:-
Every e-commerce application that offers some form of shopping cart functionality
needs to be able to remember user-specific data as users click through the website.
Unfortunately for you the developer, the HTTP protocol, over which
communication on the Internet takes place, is a stateless protocol. Each request

25. received by your server is an independent piece of information that has no relation
to previously received requests. Therefore, if a customer clicks a button to add an
item to his or her shopping cart, your application must take measures to ensure not
only that the state of the user's cart is updated, but that the action doesn't affect the
cart of another user who happens to be browsing the site at the same time.
Handling session data:-
Applications can manage user sessions with the HttpSession object. You can bind
user-specific data to the HttpSession object, then access this data at a later stage.
Both bind and access actions can be done from Java classes, as well as from
session-scoped variables in EL expressions.
The online store application uses the HttpSession object to identify users over
multiple requests. An HttpSession object is obtained using getSession() on a given
request:
HttpSession session=req.getSession();
For session management we have to to create shopping servlet and two java classes
1. Product class
2. Shopping cart class
Product class:-
In the product class we set and get all the detail of the product like product_id,
name, description, price, quantity.

26. Product class:-
package shopping;
/**
*
* @author kavita
*/
public class product {
String name;
String description;
int id;
float price;
int quantity;
public product()
{

27. name="";
description="";
price=0;
quantity=0;
}
public void setname(String pname)
{
name=pname;
}
public String getname()
{
return name;
}
public void setdescription(String desc)

28. {
description=desc;
}
public String getdescription()
{
return description;
}
public void setprice(float p)
{
price=p;
}
public float getprice()
{
return price;

29. }
public void setid(int pid)
{
id=pid;
}
public int getid()
{
return id;
}
public void setquantity(int q)
{
quantity=q;
}
public int getquantity()

30. {
return quantity;
}
}
Shopping servlet:-
Shopping servlet perform various operations on the cart-
1. Remove item from the cart.
2. Proceed to the check out.
3. Calculate annual amount of the customer
4. Manage session for each customer
After processing of shopping servlet control is transfer to the registration page, in
the registration page customer can enter his complete detail for complete
processing of his order.
Registration page:-

31. Register page:-
It contains following fields to enter:-
1. Name
2. Email
3. Address
4. Contact
5. Region

32. After filling registration page control is transfer to register servlet where it accepts
all the parameters of registration page and save it into the sql table customers.
Confirmation Page:-
Confirmation page generates a order reference number and order will start
processing by the store admin. You can enjoy home delievery of your daily needs
at your doorstep with in 30 minutes
Admin Login:-
Admin login page provides a login page in which admin of the store has to enter
his login name and password and login successfully and view customers orders
detail, and start processing their order.

33. when admin enters his username and password control is transfer to the servlet,
servlet check given user name and password with the stored user name and
password if it matches then admin will be redirected to the welcome page.
If it does not matches then user is redirected to unsuccessful login page
Admin Page:-