Requirement

Create a RESTful service using Spring MVC and Hibernate for fetching, adding, updating and deleting product information.  The product information will be persisted in a database table. The service should be available to be consumed by any client like mobile, html, java application etc. using the REST url created.

GitHub Project URL

https://github.com/tech-freaks/catalog-service

Pre-requisites

• MySQL and Tomcat is already installed
• Eclipse with JEE support is already installed
• Basics about Spring and Hibernate framework
• Basics about RESTful service

Analysis and Design

We will use a bottom-up approach to design our application. We start from the database layer, then hibernate layer and finally the Spring layer.

Database

For implementing this requirement, we create a table PRODUCT. It has basic information about a product like name, description, partnumber, unit price etc. We do not have any more table for fulfilling this requirement. However, if you create a complex application, your product information might be normalized into multiple related tables.

Below is the CREATE table statement for creating the PRODUCT table.

 CREATE TABLE IF NOT EXISTS `product` (
  `product_id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  `partnumber` varchar(50) NOT NULL,
  `description` varchar(1024) NOT NULL,
  `thumbnail_url` varchar(240) DEFAULT NULL,
  `buyable` char(1) NOT NULL DEFAULT 'Y',
  `unitprice` decimal(8,2) NOT NULL,
  PRIMARY KEY (`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

There is two sql script in the github repository root folder create_tables.sql and product_load.sql. As the name suggests, the first sql can be used to create a database and PRODUCT table. The second sql can be run to insert some starter products.

Hibernate

Nothing to think about here! We will have a hibernate class Product.java which will be mapped to PRODUCT table. If you would want to reverse engineer the Product.java from the database table, review the steps in the article Reverse Engineering Hibernate objects using JBoss eclipse plugin

Spring

We will have a single Controller, which will have different methods for each verb like GET, PUT, POST and DELETE and will act upon Product table data. Following the Spring convention, we will interact with the database using the following layered approach

Spring Controller -> Service -> DAO -> Hibernate -> Database

Spring Controller:
CatalogRestController

Service:
ProductService
ProductServiceImpl

DAO:
ProductDAO
ProductDAOImpl

Furthermore, the Rest controller will have the following methods

@RequestMapping(method = RequestMethod.GET)
public List<Product> getProducts(); - Get all products

@RequestMapping(value = "/{productId}", method = RequestMethod.GET)
public ResponseEntity<?> getProduct(@PathVariable Integer productId) <- Get Products with ProductId

@RequestMapping(method = RequestMethod.POST)
public ResponseEntity<?> add(@RequestBody Product input) <- Insert a product for input received

@RequestMapping(value = "/{productId}", method = RequestMethod.PUT)
public ResponseEntity<?> update(@PathVariable Integer productId,
@RequestBody Product input) <- Update product information for productId

@RequestMapping(value = "/{productId}", method = RequestMethod.DELETE)
public ResponseEntity<?> remove(@PathVariable Integer productId) <- Delete product for the provided productId

The above also shows at a high level usage of Spring annotations for specifying different verbs.

Word of caution: This design allows a REST client to insert, delete or update records in database, without any authentication and authorization. For a production application, generally, the only verb which might allow access without authorization is the GET. All the other verbs which modify the database might be authenticated and authorized. Oauth is a commonly used open standard of authorization used to authorize client before they can make changes to the underlying data source.

We will need to further create XML configuration file for web application, Spring framework and add libraries. We will cover this in environment setup and development sections.

Environment Setup

• Open eclipse and create a “Dynamic Web Project” in eclipse with the name “catalog-service”.
• Click next, then next and finish.
• If you are using Maven or Gradle, setup to download libraries for Hibernate 4 or above, Spring 4.1 or above and MySQL drivers. If you are using Spring 4.1, make sure to also include the latest libraries for Jackson FastXML. The conversion of Object to JSON and vice versa is handle by Jackson library and it does not work without the latest libraries.
• If you are not using maven or gradle, make sure the following jars are in your WEB-INF/lib folder as provided in the below screenshot

The source code in the GitHub contains all required libraries.

Web.xml configuration

We configure Spring DispatcherServlet, specify the patch to Spring configuration file (if not using default path and file name) and map the request to a URL pattern. For this project, we use *.json mapping. Hence, all the request URL should have .json at the end. Note that, if you perform a partial URL mapping like /product/*, you will have to configuring the ViewResolver, so that it could use the appropriate resolvers for JSON. However, when an extension mapping like .json, no ViewResolver configuration is required.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>Catalog REST Services</display-name>
  <welcome-file-list>
    <welcome-file>Login.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <servlet-name>CatalogServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/Catalog-Servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>CatalogServlet</servlet-name>
    <url-pattern>*.json</url-pattern>
  </servlet-mapping>
</web-app>

WEB-INF/Catalog-Servlet.xml

Most of the tags are self-explanatory. Although this is a Spring configuration, it references Hibernate related files and hibernate.cfg.xml. The “datasource” needs to be updated with your username, password and dbname. Also, note the configuration for transactionManager. Once this is configured, Spring handles the hibernate transactions and you do not have to manually manage the transaction in your code. Just mark the service method with @Transactional annotation.

The ProductDao and ProductService is also declared. We have marked them as @Autowired and hence we do not have to pass the reference for productDao into productService in the XML.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">

	<mvc:annotation-driven />
<!-- Configure JDBC Connection - @TODO update url, username and password per your database configuration -->
      <bean id="dataSource"
            class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://localhost:3306/tfcom_articles" />
            <property name="username" value="admin" />
            <property name="password" value="admin*" />
      </bean>
      
    <tx:annotation-driven transaction-manager="transactionManager" />
    
     <bean id="transactionManager"
            class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
      
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="dataSource">
                  <ref bean="dataSource" />
            </property>
    <property name="configLocation" value="classpath:hibernate.cfg.xml" />
	</bean>
	
	<context:component-scan base-package="com.tech_freaks.catalog"/>
	
	<bean id="productDao"
   	class="com.tech_freaks.catalog.dao.ProductDAOImpl"/>
   	
   	<bean id="productService"
   	class="com.tech_freaks.catalog.service.ProductServiceImpl"/>
</beans>

src/hibernate.cfg.xml

We have used the XML configuration for hibernate and not annotations. This mainly declares the Product hibernate class and its mapping file Product.hbm.xml.

The commented fields in this file will need to be un-commented, if you are reverse engineering the hibernate object as explained in the article Reverse Engineering Hibernate objects using JBoss eclipse plugin

Development

Hibernate Object
Product.java – We reverse engineer this class from the database. It is the model for the application, which is mapped to the database table. It is self-explanatory.

DAO layer

AbstractDAO<T> – This is a generic class which contains common calls to hibernate API. All DAO can extend this class to reuse these pre-implemented class. Note, how the sessionFactory is injected by Spring framework into the DAO layer using @Autowired annotation. The sessionFactory is declared in the Catalog-Servlet.xml file which we defined earlier.

The JavaDoc comments on each of the method, explain the use of the function.

package com.tech_freaks.catalog.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * Generic Base class which encapsulates hibernate specific calls which will be available from the 
 * extending DAO which is mapped to the database table.
 * @author Tech Freaks
 *
 * @param <T> - The Hibernate object which it works on
 */
public class AbstractDAO <T> {
	
	@Autowired
    private SessionFactory sessionFactory;
 
	/**
	 * Gets a current session from the hibernate factory
	 * @return
	 */
    protected Session getSession(){
        return sessionFactory.getCurrentSession();
    }
    
    /**
     * Generic method for finding by primary key. 
     * @param id  - Primary key value in integer
     * @param myClass - Type of Class which will be loaded
     * @return T representing instance of the loaded hibernate class instance
     */
    public <T>  T findById(Integer id, Class myClass) {
    	return (T) getSession().load(myClass, id);
    }
 
    /**
     * Inserts record into database
     * @param t - Instance of the Hibernate object which needs to be persisted in the db
     * @return - Key value of the newly inserted record
     */
    public Integer persist(T t) {
       return (Integer) getSession().save(t);
    }
    
    /**
     * Updates the database for provided generic type
     * @param t Generic type for the hibernate object
     */
    public void update(T t) {
    	getSession().update(t);
    	getSession().flush();
    }
     
    /**
     * Deletes the entity from the database for the provided generic type
     * @param t  Generic type for the hibernate object
     */
    public void delete(T t) {
        getSession().delete(t);
        getSession().flush();
    }
}

ProductDAOImpl & ProductDAO
This is the actual DAO interface and its implementation. It extends the AbstractDAO<Product> and utilizes the methods defined there.

package com.tech_freaks.catalog.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.tech_freaks.catalog.model.Product;

public class ProductDAOImpl extends AbstractDAO<Product> implements ProductDAO {
	
	
	/**
	 * Fetches all the product from the PRODUCT table
	 */
	@Override
	public List<Product> getAllProducts() {
		Session session = getSession();
        List<Product> productList = session.createQuery("from Product").list();
        return productList;
	}
	
	/**
	 * Fetches product based on the primary key productId
	 */
	@Override
	public Product findById(Integer id) {
		return (Product) getSession().get(Product.class, id);
	}
	
	/**
	 * Inserts a new record in the product table.
	 */
	@Override
	public Integer insert(Product product) {
		return persist(product);
	}
	
	/**
	 * Loads the product using the primary key and then removes it from the database.
	 */
	@Override
	public boolean remove(Integer id)  {
		boolean deleted = false;
		Product delProduct = findById(id);
		if(delProduct!=null) {
			delete(delProduct);
			deleted = true;
		} 
		return deleted;
	}
}

ProductServiceImpl & ProductService

The is the Service layer interface and its implementation for the Product manipulation. It internally calls the DAO layer. The Service layer is called from the Controller class. The methods are self-explanatory.

The below excerpt from ProductServiceImpl shows @Autowiring annotation on productDAO, which is injected in by the Spring framework. Also, each method is marked with annotation @Transactional. This is the reason, you do not see any code related to transaction management in the DAO layer. Spring manages the transaction code for you.

...
@Autowired
	private ProductDAO productDAO;
	
	@Override
	@Transactional
	public List<Product> listProducts() {
		
		return productDAO.getAllProducts();
	}
...

CatalogRestController is the entry point into the code for all REST service verbs. The @RestController annotation eliminates the need to mark each method with @ResponseBody when it returns an Object or a Collection of objects. Now even without @ResponseBody, when an object or collection of object is returned, it is automatically converted into JSON. The class is also marked with @RequestMapping(“/products”). This means the REST URL for every verb call will have ‘/products’ in it, after the application context name. Now, each method is marked with @RequestMethod. We follow the REST specification by mapping GET to retrieve data, POST for insert data, PUT for update data and DELETE for deleting data.

If we look at the method “add”, there are certain points worth noticing.

First, after every REST call, we return a HttpStatusCode. If the insert is successful, we return CREATED status or 201. If it fails, because the Product object was not populated, it means, the JSON was not well formed. In this case, we return BAD_REQUEST or 400. This helps the client to read the HttpHeader in the response and take appropriate action.

Second, after insert, the method create a REST URL to fetching the newly inserted record. This is set in the Location HttpHeader.

The private method isValid() is called internally to perform some basic validation before the service layer is invoked.

Similarly, all the other method are developed. The complete CatalogRestController code is below.

package com.tech_freaks.catalog.controller;

import java.net.URI;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import com.tech_freaks.catalog.model.Product;
import com.tech_freaks.catalog.service.ProductService;

@RestController
@RequestMapping("/products")
/**
 * Entry point for REST service calls. Different method for handling insert, update, delete and get
 */
public class CatalogRestController {

	protected final Log logger = LogFactory.getLog(getClass());

	@Autowired
	private ProductService productService;

	@RequestMapping(method = RequestMethod.GET)
	public List<Product> getProducts() {
		return productService.listProducts();

	}

	@RequestMapping(value = "/{productId}", method = RequestMethod.DELETE)
	public ResponseEntity<?> remove(@PathVariable Integer productId) {
		boolean deleted = false;
		ResponseEntity<?> response = null;
		try {
			deleted = productService.removeProduct(productId);
		} catch (Exception e) {
			logger.error("Error deleting product from database: "
					+ e.getMessage());
		}
		if (deleted)
			response = new ResponseEntity<>(HttpStatus.OK);
		else
			response = new ResponseEntity<>(HttpStatus.NO_CONTENT);
		return response;
	}

	@RequestMapping(value = "/{productId}", method = RequestMethod.GET)
	public ResponseEntity<?> getProduct(@PathVariable Integer productId) {
		ResponseEntity<Product> response = null;
		Product product = productService.getProduct(productId);
		if (product != null) {
			response = new ResponseEntity<>(product, HttpStatus.OK);
		} else {
			response = new ResponseEntity<>(HttpStatus.NO_CONTENT);
		}
		return response;
	}

	@RequestMapping(value = "/{productId}", method = RequestMethod.PUT)
	public ResponseEntity<?> update(@PathVariable Integer productId,
			@RequestBody Product input) {
		ResponseEntity<?> response = new ResponseEntity<>(HttpStatus.OK);
		logger.info("Product Id to be updated is " + productId);
		logger.info("New Product Name will be " + input.getName());
		try {
			if (productId > 0 && isValid(input)) {
				input.setProductId(productId);
				productService.updateProduct(input);
				response = new ResponseEntity<>(HttpStatus.OK);
				
			} else {
				response = new ResponseEntity<>(HttpStatus.BAD_REQUEST);
			}
		} catch (HibernateException he) {
			logger.error("Unable to update product in database: "+ he.getMessage());
			response = new ResponseEntity<>(HttpStatus.NO_CONTENT);
		} catch (Exception e) {
			logger.error("Unable to update product in database: "+ e.getMessage());
			response = new ResponseEntity<>(HttpStatus.BAD_REQUEST);
		}
		return response;
	}

	@RequestMapping(method = RequestMethod.POST)
	public ResponseEntity<?> add(@RequestBody Product input) {
		HttpHeaders httpHeaders = new HttpHeaders();
		ResponseEntity<?> response = null;
		if (isValid(input)) {
			logger.info("Product description is " + input.getDescription());
			try {
				Integer productId = productService.createProduct(input);
				URI location = ServletUriComponentsBuilder
						.fromCurrentServletMapping()
						.path("/products/{productId}.json").build()
						.expand(productId).toUri();
				logger.info("Location uri is " + location.toString());
				httpHeaders.setLocation(location);
				response = new ResponseEntity<>(null, httpHeaders,
						HttpStatus.CREATED);
			} catch (Exception e) {
				logger.error("Unable to insert new product in database: "
						+ e.getMessage());

				response = new ResponseEntity<>(null, httpHeaders,
						HttpStatus.UNPROCESSABLE_ENTITY);
			}
		} else {
			response = new ResponseEntity<>(null, httpHeaders,
					HttpStatus.BAD_REQUEST);
		}
		return response;
	}

	/*
	 * Internally used to validate the fields to make sure, all required fields
	 * are present before calling the service layer for insert
	 */
	private boolean isValid(Product product) {
		boolean valid = false;
		if (product != null) {
			if (!StringUtils.isEmpty(product.getName())
					&& !StringUtils.isEmpty(product.getDescription())
					&& !StringUtils.isEmpty(product.getPartnumber())
					&& !StringUtils.isEmpty(product.getName()))
				valid = true;
		}
		return valid;
	}
}

At this point, you can download the complete project from GitHub at https://github.com/tech-freaks/catalog-service

Unit Testing

The first part of the unit test, is to figure out the REST URL to invoke. We can figure this out, if we look at the CatalogRestController and web.xml. Remember, web.xml maps *.json to the controller. Hence, for all verbs our URL will end with .json.

We used the following information:

Tomcat host: http://localhost:8080
Application Context: /catalog-service
CatalogRestController mapping: /products

Now, the method getProducts() do not have any value mapping. But, it needs to be a GET call. Hence, for accessing this method, you will use the URL http://localhost:8080/catalog-service/products.json and it needs to be a GET call. You can therefore, just paste the URL in a browser and it will show the JSON with all products.

Similarly, if you look at getProduct(), the request mapping has /{productId}. This is equivalent to the primary key, product_id value in the database. Hence, the URL will be http://localhost:8080/catalog-service/products/1.json , where product_id=1. This will be again a GET verb again, as we are fetching information.

Now, similarly, we can figure out the remaining URL for calling remove(), update() and add(). The below table provide the remaining URL and verbs.

Where {productId} will be replaced by product_id value in the database.

Now, there will be two question:
1. How to invoke DELETE, PUT and POST verb? When we paste the URL in the browser, they all are by default GET requests.
2. How to pass the product information for add() and update()?

For # 1, we can download a browser plugin called as Poster (Just search Poster plugin), which is available for Chrome and Firefox. The below screenshot shows, Poster in action for Firefox.

For # 2, we need to send an input json containing the product information to be insert or updated in the product table. The POST performs and insert, while PUT updates. The json format is exactly as the response received from http://localhost:8080/catalog-service/products/{productId}.json GET verb. However, we have provided an input file by the name POST_PUT_Input.json, which is in the root folder of the project.

In Poster plugin, you need to make sure, that to add a Header by the name “Content-Type” with value “application/json”.

For integration testing, we generally run the client code like the mobile application in same network and point to the URLs provided above. However, integration testing is beyond the scope of this article.

This completes the workshop for creating a simple product REST service using Spring MVC 4.

Happy RESTing!

Overview

When you are working on a web application development using Tomcat server and Eclipse IDE, it could be painful and inefficient to create a WAR file and deploy to Tomcat after every code change. There are multiple ways to make the development process efficient.

1. Create Tomcat Server within Eclipse
2. Create Ant or other build script to deploy to Tomcat webapps folder
3. Setup your Eclipse project to be within Tomcat/webapps folder

The simplest and most convenient is the creating a Tomcat Server within Eclipse. This article walks through the steps to configure Tomcat to run from within Eclipse.

This article uses Eclipse Kepler and Tomcat 8, but the process should be similar with other versions too.

The article does not walk through JDK, Tomcat and Eclipse installation.

Steps

1. Download and install Java JDK 7 or later from Oracle website: http://www.oracle.com/technetwork/java/javase/downloads/index.html
2. Download and install Tomcat 8 from Apache website: https://tomcat.apache.org/download-80.cgi

4. Download Eclipse for JEE developer from Eclipse website: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/keplersr1
5. Follow the URL https://wiki.eclipse.org/JDT/Eclipse_Java_8_Support_For_Kepler if you installed JDK 8 and want Eclipse to support JDK 8
6. Creating Tomcat 8 server in Eclipse

a. Open Java EE perspective and access the Server tab below. You should see as the below screenshot

b. Click the link to create new Server as highlighted in screen above.

c. In the window that opens, click Apache and check for Tomcat 8. If you do not see, Tomcat 8 option perform the steps d to e.

d. Go to Help -> Install New Software..

e. In the window that opens, enter the URL as – http://download.eclipse.org/webtools/repository/luna

 >> Under the Web Tools Platform (WTP) 3.6.0, select options “JST Server Adapters” and “JST Server Adapters Extensions”. Click Next and then Accept the license agreement and finish installation.

 >> Eclipse will prompt to restart and after restarting, you should be able to Tomcat 8 option

f. Now select Tomcat 8 and click next

g. In the next screen, select the location of Tomcat Installation and also JDK, as shown below

h. Click next and you should see the option to add your web application. Add a test application, if you have one and click finish.

i. You should see the new Tomcat 8 server and displayed in the Server window as shown below

j. Double click the new Server definition and in the file which opens in Eclipse make the settings as highlighted in the below screen. The selected option uses the Tomcat installation path to work with, instead of create a separate set of files in the user folder. If you do not want Eclipse to work on the installation folder of Tomcat, you might want to select the first option ‘Use Workspace Metadata’.

k. Next right click and Server and click Start. This should start your Tomcat server without any errors, in the Console.

l. Verify the Tomcat server by access the URL http://localhost:8080 and you should be able to see Tomcat screen.

This concludes the walk-through of configuring Tomcat to be access from within Eclipse IDE. Enjoy developing, deploying and testing on your development environment completely from within Eclipse !

If you notice error while starting Tomcat which says “Access Denied”, it means that Eclipse is not having permission to access file in the Tomcat installation folder. You can resolve this by giving required permission to the Tomcat installation folder or by running your Eclipse as Administrator. You can also use the option ‘Use Workspace Metadata’, in step j, if you are unable to resolve the access issue.

Writing hibernate class and xmls can be a pain, especially, if you have tons of tables in your database. One way to alleviate the pain is to use a reverse engineering tool, which would generate the xml and java files for hibernate by connecting to database. This article walks through the steps from installing the JBoss Tools Eclipse plugin to generate hibernate java and xml files.

Pre-requisites 

• MySQL and Eclipse are installed
• MySQL has a database with at least one table
• You have some basic knowledge about hibernate or any other ORM tool

Steps

Installing JBoss Eclipse Tools from marketplace

Open Eclipse and follow the menu, Help -> Eclipse Marketplace..

Search for ‘JBoss’ or ‘Hibernate’ and click install on the Jboss Tools

Un-select all options except “Hibernate Tools” as shown in the below screenshot

Click “Confirm” and then “Finish”. Accept the license agreement.

Eclipse will prompt to restart

Creating the hibernate configuration (hibernate.cfg.xml)

Once Eclipse has restarted, Open hibernate perspective. Windows -> Open Perspective -> Others

The perspective will be empty. Click on the “Add Configuration” to start the configuration process, as shown below

A window “Edit Configuration” will show up, as per the below screen shot. Select the Project by clicking Browse.

Next, click “Setup” from Configuration File section. This will open another windows as shown below.

Using this, we will be creating the hibernate.cfg.xml which has the information like the database dialect, database URL, drivers, database type, db user id and db password. Once you click “Finish”, this will generate the hibernate.cfg.xml. Then click the “OK” in the “Edit Configuration” window should be open.

Next, go to the Hibernate Configuration in the Hibernate perspective. Right click the new configuration which you added now and click “Rebuild Configuration”. You should now check the section under “Database” in the hibernate configuration.  You should see the tables from your database. If the tables are not showing and it shows an error, you should not proceed further and resolve this issue first. Below are some possible reasons for the error

• Database drivers are not in classpath:  Resolution: Put the driver jar file in the WEB-INF/lib folder to resolve this.
• Database service is not started: Resolution: Start your database and try connecting again.
  One or more information entered in the hibernate.cfg.xml is incorrect. Verify all the information entered in the hibernate.cfg.xml, anything which is incorrect.
• If you resolved the issue as explained above, you might want to “Rebuild Configuration” after resolving the issue.Once you can see the Database tables, you can proceed to the reverse engineering steps provided below.

  Create a new Hibernate Reverse Engineering file

  From the Hibernate Perspective click “File” -> “New” -> “Hibernate Reverse Engineering File (reveng.xml)”

In the Wizard that opens, select the project and click “Next”

Select the “Console Configuration” from the drop down in the next step and click the “Refresh” button. The Database Schema section will show your database and tables. Select all the tables and click include. Click the “Finish” button to generate hibernate.reveng.xml file.

If you are unable to generate the hibernate objects, check that you have included all individual tables instead of the whole database and re-generate the reveng.xml

Once you have the reverse engineering file generated, you need to do Run -> Hibernate Code Generation -> Hibernate Code Generation Configuration€¦

In the window that opens, create a new configuration and enter details as per the below screenshot and click “Run”.

Go back to Java EE perspective and you will see the hibernate xmls and java files generated in the package specified in the Main tab of the configuration before clicking Run.

You might want to modify some of the content in the xml or java files generated as per your needs. However, remember that, if you have to regenerated the hibernate objects, your manual changes might get lost.

One last step you would need to perform, is to add the mapping of the bean in the hibernate.cfg.xml. Below shows a screenshot of adding one mapping.

That completes the steps to reverse engineer hibernate objects using JBoss Tools in Eclipse.

Requirement

• Create a Login page to enter user name and password
• On submit, validate the user name / password against MySQL database
• If the authentication is successful, forward to home page showing welcome message along with the user name
• If the authentication fails, return back to the login page with appropriate error message
• If there is exception / errors during authentication process return back to login page with appropriate error message.

Pre-requisites

• MySQL and Tomcat is already installed
• MySQL is setup with database and tables for use. Refer Simple Login Application for details
• You have basic knowledge of Java and J2EE web applications
• Basic idea about Struts 1 or 2 or at least about MVC design

Concepts Covered

• IDE set up for Struts 2
• Struts2 key components
• Difference between struts 1 and struts 2 highlighted

Environment Setup

• Download Eclipse for Java EE which is all ready to go with JEE features and install it. Download from Eclipse for JEE Download
• Create a “Dynamic Web Project” in eclipse with the name Struts2LoginApp.
  Click next, then next and finish.
• Download latest Struts2 binaries from Struts 2 Binaries Download. At the time of writing this article, struts 2.3.24 was used.
• Unzip the binaries and copy the following JAR files to the lib directory(<workspace>\Struts2LoginApp\WebContent\WEB-INF\lib) of the newly created project:

commons-fileupload-1.3.1.jar
commons-io-2.2.jar
commons-lang3-3.2.jar
commons-logging-1.1.3.jar
commons-logging-api-1.1.jar
freemarker-2.3.22.jar
javassist-3.11.0.GA.jar
ognl-3.0.6.jar
struts2-core-2.3.24.jar
xwork-core-2.3.24.jar

Since we make connections to MySQL using JDBC, we would also need to put the JAR for the MySQL JDBC driver (mysql-connector-java-5.1.20-bin.jar). You can download the latest version of the jar from MySQL JDBC Driver Download.

web.xml configuration:
A blank web.xml might have been added to your project under WEB-INF folder. This file is the JSP deployment descriptor. We need to configure the struts 2 controller, which is a servlet filter by the name FilterDispatcher. If you are familiar with Struts1, you will recollect that in the web.xml, we used to make an entry for the ActionServlet which was the controller in struts1.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://java.sun.com/xml/ns/javaee" 
   xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id="WebApp_ID" version="3.0">
   
   <display-name>Struts 2 Login App</display-name>
   <welcome-file-list>
      <welcome-file>Login.jsp</welcome-file>
   </welcome-file-list>
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Analysis and Design

If you do not have the database table created or do not have any user in that table, please refer the analysis and design from the article Simple Login Application for details.

Taking inspiration from the previous article, we will create similar components for our simple login app using struts 2.

So, below are the identified components:

Login.jsp
Home.jsp
LogonAction.java

Let us look at each identified component and its role in our application:

• Login.jsp -> It would present the login screen to enter user id and password. It also displays any validation errors and login failure message.
• Home.jsp -> Simple JSP which displays a welcome message after successful login
• com.tech_freaks.action.LogonAction.java
  While we take inspiration from LogonServlet of our previous example, we improve the design to not include any database connectivity code in our Action class. To achieve this, we will refactor all the DB access / calls to a Helper class by the name DBHelper.java. This also helps in modifying the code, if we tomorrow decide to use Entity Beans (EJB) or hibernate to access the database instead of raw JDBC code with minimum impact on our Action class. The LogonAction performs the following tasks.
  – Perform basic empty check on server side before calling the database
  – Call our DB Helper class, with user name and password to check, if the combination exists.
• com.tech_freaks.utils.DBHelper.java
  It will perform all task related to getting connection to the DB, executing a query and method to return Boolean indicating, if record was available or not in the DB. We do not write method like, isUserPasswordValid in this class, as it is a generic low level class, and should not be aware about the logic implemented in the classes calling it. Below would be the methods:

public boolean containsResults(String query, String[] params) -> The params we have created as a String array, which will have both user name and password. If the values required for the where clause of the SQL query are of different datatype, we might need a different approach. This method is invoked by the LogonAction

private Connection getConnection() -> Internally used to get a Connection object for the DB call.

private void closeConnection(Connection conn) – Closes an open connection after the query has been executed.

Development

We will first start by adding a struts.xml for our project. In eclipse, you will have to create a folder ‘classes’ under \workspace\Struts2LoginApp\WebContent\WEB-INF\ and add struts.xml in that folder.

Below is the struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name="struts.devMode" value="true" />
   <package name="loginapp" extends="struts-default">
     
      <action name="logon" 
            class="com.tech_freaks.action.LogonAction" 
            method="execute">
            <result name="success">/Home.jsp</result>
            <result name="input">/Login.jsp</result>
            <result name="error">/Login.jsp</result>
      </action>
   </package>
</struts>

 The configuration file is straightforward and easy to understand. <constant> is setting the project in a development mode. This will give helpful errors in the logs / screen while debugging issues.

<package> is applicable when we divide the configure into multiple logical parts instead of having all action definition inside single file.
Let us take a careful look at the entry for <action> and ensure all mapping components are named to match the entries in here.

€¢ €œname€ attribute needs to be mapped to the <form action=€â‚¬> in the Login.jsp. This is how struts knows which Action class to invoke. We leave the method to €œexecute€ as our Action class will extend ActionSupport class and override the execute method.
€¢ €œclass€ should be fully qualified class name of the Action class.
€¢ When the Action executes, we can configure different JSPs / views to invoke after completion. The String value returned from Action.execute() method should match the €œname€ attribute in one of the €œresult€. However, it is important to note that, if we are using struts validation framework, we need to have an <result> with name=€input€. The framework will redirect to the view configured for <result> name=”input” with the error message. If you do not have entry for €œinput€ you will see an error saying that €œNo result defined for action and result input – action €“€œ

Next, we take a look at the LogonAction.java.
As we plan to validate for empty fields, we need to extend the ActionSupport class. Once extended, we need to override the methods execute() and validate(). The next thing is we need to have instance variables for user fields in the Login.jsp. Note that the instance variable (mainly the getter/ setters for the instance variables) must match exactly to the €œname€ attribute on the <input> fields on the JSP. This is also a difference between struts 1.1 were we had separate ActionForms which had the fields mapped to the <input>.
The complete java code is below

 package com.tech_freaks.action;

import java.util.HashMap;
import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.util.ValueStack;
import com.tech_freaks.utils.DBHelper;

public class LogonAction extends ActionSupport {
	
	public static final String LOGIN_SUCCESS = "success";
	public static final String LOGIN_FAILED = "error";
	
	private static final String LOGIN_QUERY = "select * from users where user_name=? and password=?";
	
	private String userName;
	private String password;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String execute() throws Exception {
		ValueStack stack = ActionContext.getContext().getValueStack();
		String[] params = new String[] {userName, password};
		DBHelper dbHelper = new DBHelper();
		
		boolean isSuccess = dbHelper.containsResult(LOGIN_QUERY, params);
		if(isSuccess)
			return LOGIN_SUCCESS;
		else {
			Map<String, Object> context = new HashMap<String, Object>();
			context.put("errorMsg", new String("Invalid user name or password. Try again.")); 
			stack.push(context);
			return LOGIN_FAILED;
		}
	}

	@Override
	public void validate() {
		 if (userName == null || userName.trim().equals(""))
	      {
	         addFieldError("userName","Please enter a user name to login with.");
	      }
		 if (password == null || password.trim().equals(""))
	      {
	         addFieldError("password","Please enter a password.");
	      }
	}
}
 

Let”s take a close look at validate(). Use the addFieldError() method with the first parameter matching the field name which has the validation error. Again, this name needs to exactly match with <input> name attribute in the JSP. If we use the struts taglib in the JSP, it also takes care of showing the error message for each field inline to the field.

Next, we take a look at the execute() method. It is fairly straightforward. It calls the DBHelper class to verify in the database, if a record exists for the supplied userName and password combination. Based on the result, it returns €œsuccess€ or €œerror€. The value returned needs to match with the <result> name attribute defined in the struts.xml which we examined before. The appropriate view will be displayed.

For the failed login attempt, we have to go back to the login page and display an error message. We use this requirement to explain ActionContext and ValueStack concept in struts 2. The ActionContext has access to variables like session, request params etc. It also contains a value stack. You can put objects into value stack. As the name suggests, it is a stack with push, pop, peek methods in it. In the JSP, when you want to access the variables in the ActionContext using the struts taglib, you use #<attribute> say #session. However, for accessing value stack, we do not have to use the #. As you can see, we are pushing a Map with key errorMsg into the value stack, with value containing the error message which needs to be displayed to the user on failed login attempt.

Login.jsp
This page is modified from our previous version of Login.jsp. The main change is the struts taglib usage. We use the <s:property> to pull the attribute from the value stack which we previously discussed. This is used where the login attempt fails. We have used <s:form>, <s:textfield> etc. They help giving inline errors for each field as per the login in the validate() method.

Below is the complete Login.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
   pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>
Tech-freaks.com - Struts2 - SimpleLogin App Login Page
</title>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
</head>
<body>
<s:property value="errorMsg"/><br/>
<s:form method="POST" action="logon">
	<s:textfield  name="userName" label="User Name"/>
	<s:password  name="password" label="Password" />
	<s:submit name="submit" label="Submit" align="center" />
		
</s:form>
</body>
</html>

Home.jsp
Simple page, which when requested due to successful login, fetches the €œusername€ field and displays the welcome message. Below is the complete JSP

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><%@page
	language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
	<head>
		<title>
		Tech-freaks.com - Struts 2 SimpleLogin App Home Page
		</title>
		<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
	</head>
	<body>
	 	<h1> Welcome to Tech-freaks.com - Struts2 Simple Logon App, <s:property value="userName"/></h1>
	</body>
</html>

Testing

Once you have all the components put in, right click the project in Eclipse and Export as WAR. Drop the generated WAR in <Tomcat>\webapps folder and start Tomcat. Verify Tomcat logs, if the deployment of the WAR was successful. 
Test by accessing the URL : http://localhost:8080/Struts2LoginApp/Login.jsp (Modify the port and context name as per your customization)
Run and verify each scenario mentioned in the requirement.

Congratulations, on completing your first “Non-Hello World” project using struts 2!

You can download the complete Eclipse project from Github by clicking the link below.

Download complete Struts 2 Login App Source code from Github

Requirement

• Create a Registration Form to enter user name, password, first name, last name, email address, secret question, answer and register a new user to system.
• Validate if the user name and password is not blank. Display error message to user, if either of them is blank.
• Validate if the user name already exists and display an error message to the user
• In the event of an error, ensure that registration form is displayed again with all prefilled information
• On successful registration, set the user name in session and forward to home page.

Pre-requisites

• MySQL and Tomcat is already installed
• You have basic knowledge of MySQL to create tables and insert / update records
• You have basic knowledge of Java and J2EE web applications
• Have your favorite IDE for developing / reviewing code
• This workshop adds the registration functionality to the previous article Simple Login Application. Reviewing that article prior to this article would help.

Concepts Covered

• JDBC connectivity to MySQL from Servlet
• Simple application of JSTL tag
• Using request attribute and request parameters
• Basic error handling concepts

NOTE: Don’t even think of using the code as is for a production environment
This is just for education purpose but you can take inspiration from this code.

Analysis and Design

We start with the Simple Login application article as a baseline. First, we need to update the database to add more fields and constraints. We will make the user_name field as the primary key for the USERS table.

We create a new class for database connectivity code unlike in the simple login application and refactor the connectivity code out of the Servlet code. This is a good design practice to keep the servlet layer uncoupled to the database code layer. We would still following the MVC design model.

Below is a list of elements identified as part of the design:

• com.techfreaks.db.util.ConnectionUtil – Utility class for getting connection, closing connection and executing insert / update query
• com.techfreaks.registration.servlet.RegistrationServlet – This servlet is the controller. It calls the ConnectionUtil and forwards to the home page or Registration page
• RegistrationForm.jsp – UI page with fields for registration form
• Home.jsp – UI page picked up after successful registration. It is the same page taken from Login Application
• web.xml – Deployment Descriptor in which the servlet is registered.

Development

Setup the database:

We alter the USERS table to add the new fields. However, for quick reference we provide the create USERS table DDL. You will have to drop and recreate the table using the below DML, if you already have an USER table. You could very well manually edit the existing table based on the below DDL.

CREATE TABLE `users` (
	`first_name` VARCHAR(100) NOT NULL,
	`last_name` VARCHAR(100) NOT NULL,
	`email_address` VARCHAR(50) NOT NULL,
	`secret_question` VARCHAR(200) NULL DEFAULT NULL,
	`secret_answer` VARCHAR(200) NULL DEFAULT NULL,
	`user_name` VARCHAR(100) NOT NULL,
	`password` VARCHAR(100) NOT NULL,
	PRIMARY KEY (`user_name`)
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB;

A screenshot of the development environment is provided below. Make sure the mysql drivers, jstl libraries and tlds are all available. For making your life easy, we have included a hot deployable WAR file at the end of the workshop.

Coding and Unit testing:

First, we would look at the ConnectionUtil. Below are the methods we would need for the ConnectionUtil. Note that we create this class as a static class (A class with static methods). 

– getConnection()
– closeConnection()
– executeQuery(String strQuery)

If you have read the article about simple login application, you would have already noticed thatt we just refactored the first two methods out of the LoginServlet. We prevent the code to be spread across multiple servlets this way. It is used to get a SQL Connection object and to close an open connection respectively.

In this example, we would use java.sql.Statement instead of java.sql.PrepareStatement which we used in LoginServlet, to spice things up. We need to pass the complete query to the Statement object to execute a query. The executeQuery can take an insert / update query and execute it. It would internally call getConnection() and closeConnection() to fetch and close a connection.

Below is the method executeQuery:

public static void executeQuery(String strQuery) throws Exception {
		Connection conn = null;
		
		try {
			conn = getConnection();
			Statement stmt  = conn.createStatement();
			stmt.executeUpdate(strQuery);
			
		} catch (SQLException sqle) {
			System.out.println("SQLException: Unable to execute query : "+strQuery);
			throw sqle;
		} catch (Exception e) {
			System.out.println("Exception: Unable to execute query: "+strQuery);
			throw e;
		} finally {
			closeConnection(conn);
		}
	}

We also moved the static variables like database name, db user name and db password from the servlet to the ConnectionUtil.

        private static final String DBNAME = "tf_loginappdb";
	private static final String DB_USERNAME = "root";
	private static final String DB_PASSWORD = "admin*";

If your database has different dbname, username or password, you will need to update this and recompile you java file for the application to be able to connect to MySQL database.

Next, we would look at the code in the RegistrationServlet. It gets all the fields from the RegistrationForm in the request parameters. Below are the methods which we would add to this servlet.

– doPost()
– validateData()
– setRequestAttributes()
– generateInsertQuery()

The doPost is the entry point to the servlet for html form POST. We have all the controller logic in here. The other methods are in a way, do not do the controller work. We use them for simple tasks which do not warranty creating other classes in our case. However, in a real life application, if the task is complex we might want to create new classes to delegate the task.

validateData() is used to implement the requirement that the userName and password cannot be empty. It validates and returns a boolean indicating success or failure of the validation.

generateInsertQuery() fetches the request parameters and generates the insert query which will be passed on to the executeQuery method of the ConnectionUtil. Below is the code for the method:

 private String generateInsertQuery(HttpServletRequest request) {
		String strUserName = request.getParameter("userName");
		String strPassword = request.getParameter("password");
		String strFirstName = request.getParameter("firstName");
		String strLastName = request.getParameter("lastName");
		String strEmail = request.getParameter("email");
		String strSecretQuestion = request.getParameter("secretQuestion");
		String strSecretAnswer = request.getParameter("secretAnswer");

		StringBuffer strQuery = new StringBuffer(INSERT_QUERY_START);
		strQuery.append(strFirstName);
		strQuery.append("', '");
		strQuery.append(strLastName);
		strQuery.append("', '");
		strQuery.append(strEmail);
		strQuery.append("', '");
		strQuery.append(strSecretQuestion);
		strQuery.append("', '");
		strQuery.append(strSecretAnswer);
		strQuery.append("', '");
		strQuery.append(strUserName);
		strQuery.append("', '");
		strQuery.append(strPassword);
		strQuery.append("')");
		
		System.out.println("Insert query : "+strQuery.toString());
		
		return strQuery.toString();

	}
 

setRequestAttributes() is used to implement the requirement about maintaining the data entered in the registration form in the even of an error. Do you remember banging your head against the keyboard after filling up a long registration form and clicking submit, only to find the form reloading with an error message and all the data you entered spending hours, boom! gone!

Instead of the classic get each parameter and set to attribute, we would just do a generic loop through. This would keep the code small. Imagine your registration form is 100 fields instead, the below code will not require any modification. Below is the code:

	private void setRequestAttributes(HttpServletRequest request) {
		Enumeration  enumKeys =  request.getParameterNames();
		while(enumKeys.hasMoreElements()) {
			String key  = enumKeys.nextElement();
			request.setAttribute(key, request.getParameter(key))  ;
		}
	} 

The doPost() method is provided below. It has inline comment to explain key control logic. Once the insert in the database is successful, we set the userName is session and redirect to Home.jsp.

The error messages are managed by putting a request attribute on error situation and forwarding back to RegistrationForm. You will see the difference between the redirect and forward. You will see that the request attributes are available and also the URL of the servlet remains the same after the request is forwarded to the JSP. Also, note how we utilize the primary key duplicate error message and set the error message. We use the same pattern to set error message, set the request attributes and forward to registration page on all the error conditions.

protected void doPost(HttpServletRequest request, HttpServletResponse 
			response) throws ServletException, IOException {
		
		String strUserMsg = null;
		HttpSession session = request.getSession();
		RequestDispatcher reqDisp =  request.getRequestDispatcher(REGISTRATION_PAGE);
		
		try {
			//Check if data is valid
			if(validateData(request)) {
				ConnectionUtil.executeQuery(generateInsertQuery(request));
				System.out.println("Insert into database successful");
				session.setAttribute("userName", request.getParameter("userName"));
				response.sendRedirect(getServletContext().getContextPath()+HOME_PAGE);
			} else {//If data is invalid
				strUserMsg = "User Name and Password cannot be empty";
				setRequestAttributes(request);
				request.setAttribute("userMsg", strUserMsg);
				reqDisp.forward(request, response);
			}
			
		} catch(SQLException sqle ) {
			System.out.println("Unable to register user: "+sqle.getMessage());
			//Check if we are getting duplicate key exception on userName
			if(sqle.getMessage().indexOf("Duplicate entry")!=-1) {
				System.out.println("User already exists");
				strUserMsg = "User name "+request.getParameter("userName")+" already " +
						"exists. Please try another user name.";
			} else { //If other SQLException than dup key exception
				strUserMsg = "Unable to register user "+request.getParameter("userName")+
				". Please try again later.";
			}
			setRequestAttributes(request);
			request.setAttribute("userMsg", strUserMsg);
			reqDisp.forward(request, response);

		} catch(Exception e) {//If it goes into Exception other than SQLException
			System.out.println("Unable to register user: "+e.getMessage());
			strUserMsg = "Unable to register user "+request.getParameter("userName")
			+". Please try again later.";
			setRequestAttributes(request);
			request.setAttribute("userMsg", strUserMsg);
			reqDisp.forward(request, response);

		}
		
		

	}

Next, let us look at our RegistrationForm.jsp. We highlight small snippet of code here

<p><font color="#ff0000"><c:out value="${userMsg}"/></font></p>
<form name="frmRegistration" method="post" action="<c:out value="${pageContext.servletContext.contextPath}" />/servlet/RegistrationServlet">
<table border="1">
<tbody>
<tr>
<td>First Name</td>
<td><input type="text" name="firstName" value ="<c:out value="${firstName}"/>" size="20"></td>

• JSTL is used display the userMsg which we set in the request attribute in our servlet.
• JSTL is used to pick the contextPath from servletContext
• JSTL is used to display user entered data in the event of an error

We picked up the Home.jsp from the simple login application. You can get the complete WAR file to the simple registration application by clicking SimpleRegistrationApp.war.

You just need to hot deploy SimpleRegistrationApp.war to webapps folder in the Tomcat program file and it would explode. Verify the application by accessing http://localhost:8080/SimpleRegistrationApp/RegistrationForm.jsp and run some tests to figure out how it works for you.

Feel free to leave a comment below, if you run into any issues. Enjoy!

Requirement

• Create a Login page to enter user name and password
• On submit, validate the user name / password against MySQL database
• If the authentication is successful, forward to home page showing welcome message along with the user name
• If the authentication fails, return back to the login page with appropriate error message.
• If there is exception / errors during authentication process return back to login page with appropriate error message.

Pre-requisites

• MySQL and Tomcat is already installed
• You have basic knowledge of MySQL to create tables and insert / update records
• You have basic knowledge of Java and J2EE web applications
• Have your favorite IDE for developing / reviewing code.

Concepts Covered

• JDBC connectivity to MySQL from Servlet
• Simple application of JSTL tag
• Using session variable in Servlet
• Polymorphism concept using JDBC
• Basic error handling concepts

NOTE: Don’t even think of using the code as is for a production environment
This is just for education purpose but you can take inspiration from this code.

Checkout our similar article on simple login application using Struts 2 Framework

Analysis and Design

The application is pretty straightforward and it is not too hard to design. Looking through the requirement, we need a database instance in MySQL which has a table. We would name this table as USERS.

USERS table needs to have user_name and password field but can have other fields.

For the login screen, we will create a JSP. For the home page after successful login, we will create another JSP. Following MVC, we will let Servlet handle the request. The connectivity with DB should be extracted out of the Servlet for a complex application. However, for simplicity we have maintained it within the servlet.

Below are the identified elements:

Login.jsp
Home.jsp
LogonServlet.java

Development

Setup the database:

You can create a new database in MySQL or create the below table in an already existing database. Below is the script which you will have to execute in MySQL prompt for create the table.

CREATE TABLE `USERS` (
`first_name` VARCHAR(100) NOT NULL,
`last_name` VARCHAR(100) NOT NULL,
`user_name` VARCHAR(100) NOT NULL,
`password` VARCHAR(100) NOT NULL
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB;

You can use the below insert to add users to the USERS table. You can add as many users as you want in this table.

INSERT INTO `users` (`first_name`, `last_name`, `user_name`, `password`) VALUES ('Tech', 'Freaks', 'tech_freaks', 'Passw0rd');

For Connecting to MySQL database from Servlet, you would require MySQL JDBC drivers. Below is the link to download the latest and greatest version of the drivers.
MySQL Driver : http://dev.mysql.com/downloads/connector/j/

Once we have this we are good to start the Java side development. Below screen explains how the directory structure will look in your development environment.

Coding the Servlet:

Our servlet has is the work horse and does most of the work. We will just implement the doPost method of the servlet, as we will POST the information from the HTML Form.

We will write three private methods in the Servlet for doing the work internally.

– getConnection()
– authenticateLogin()
– closeConnection()

The getConnection() will have the code for low level connectivity with MySQL using the JDBC driver. It will return a java.sql.Connection object. For a real life application, we might have a custom Connection pool implementation or use the Connection pool implementation managed by the Application Server / Web Container. It will use the javax.sql.Datasource object to reach to Connection object.

private Connection getConnection() throws Exception {
   Connection conn = null;
   try {
     String url = "jdbc:mysql://localhost/"+DBNAME+"?user="+DB_USERNAME+"&password="+DB_PASSWORD;
     Class.forName("com.mysql.jdbc.Driver");
     conn = DriverManager.getConnection(url);
   } catch (SQLException sqle) {
      System.out.println("SQLException: Unable to open connection to db: "+sqle.getMessage());
      throw sqle;
   } catch(Exception e) {
      System.out.println("Exception: Unable to open connection to db: "+e.getMessage());
      throw e;
   }
   return conn;
}

The above code is pretty straight forward for fetching Connection object. However, it has some key polymorphism concepts which are generally not clearly understood.

Question 1: Connection, Statement, ResultSet are all interface. We all know, that interface cannot be instantiated. From where do we get the implementation? Who is instantiating it?
Answer: All the interface provided above are specification or contract provided as part of JDBC specification. The driver JAR which we added has implementation classes. So, if we look at Oracle DB driver JAR, it would be different. The implementation classes will be different but it would be implementing the interfaces provided in JDBC. Our code should always ‘code to the interface’ and NEVER to the implementation class. This will help us make our code generic for using with other JDBC drivers and with other databases. Ofcourse, this is just a step to make the code database independent. Neverthless this is an awesome example of Polymorphism. Try this in your next interview when they ask you about a real life example about polymorphism, instead of giving the bookish examples. You might just have the interviewer’s mouth wide open! 😎

Question 2: Thanks for explaining. However, it still does not explain how the implementation class is instantiated and what the name of the implementation class is.
Answer: The string as a parameter to the Class.forName (“com.mysql.jdbc.Driver”) is the Driver class for the MySQL JDBC driver. It is loaded in memory. The further calls on the DriverManager works with the Driver instance com.mysql.jdbc.Driver. If you unjar the JDBC driver, you will see a implementation class for all Connection, Statement, ResultSet and so on. Once the JDBC driver is registered, the DriverManager.getConnection will give the Connection instance specific to the MySQL JDBC driver.

Let us get back from the interview mode, to development mode again

The authenticateLogin() method will look something like this:

private boolean authenticateLogin(String strUserName, String strPassword) throws Exception {
   boolean isValid = false;
   Connection conn = null;
   try {
     conn = getConnection();
     PreparedStatement prepStmt = conn.prepareStatement(LOGIN_QUERY);
     prepStmt.setString(1, strUserName);
     prepStmt.setString(2, strPassword);
     ResultSet rs = prepStmt.executeQuery();
     if(rs.next()) {
       System.out.println("User login is valid in DB");
       isValid = true; 
     }
  } catch(Exception e) {
    System.out.println("validateLogon: Error while validating password: "+e.getMessage());
    throw e;
  } finally {
     closeConnection(conn);
  }
  return isValid;
}

Notice that we have used PreparedStatement instead of Statement. We have purposely used PreparedStatement, as simple query using Statement might be easily prone to SQL Injection. For a Select query, the threat is relatively less, however, this needs to be taken care for update and delete operations.
We have maintained the queries, passwords as static variables in the Servlet as it will not change. Ideally, they should be taken from some properties or XML file.

private static final String DBNAME = "tf_loginappdb";
private static final String DB_USERNAME = "root";
private static final String DB_PASSWORD = "admin*";

private static final String LOGIN_QUERY = "select * from users where user_name=? and password=?";
private static final String HOME_PAGE = "../Home.jsp";
private static final String LOGIN_PAGE = "../Login.jsp";

You might have to update the value specific to your database instance.

Another important aspect is the error handling. Any exception occurring which will impact processing should be intimated to the end user. However, it should hide the technical issues to prevent panic amongst the end user. Imagine as an end user trying to login to your bank account in which you have all your fortune and seeing the error message which reads, “Sorry the database has been deleted. All your money is gone!”

The approach which we use is to provide the end user with error message as “Unable to validate your login in our database”. However, in the System.out you might want to add more information about the error for debugging. You can even put the stackTrace. Using Log4J or similar libraries in high quality application is recommended for logs which can be enabled / disabled at component level depending on the environment. The approach is indicated in the doPost method of the servlet.

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
   String strUserName = request.getParameter("userName");
   String strPassword = request.getParameter("password");
   String strErrMsg = null;
   HttpSession session = request.getSession();
   boolean isValidLogon = false;
   try {
     isValidLogon = authenticateLogin(strUserName, strPassword);
     if(isValidLogon) {
        session.setAttribute("userName", strUserName);
     } else {
        strErrMsg = "User name or Password is invalid. Please try again.";
     }
   } catch(Exception e) {
     strErrMsg = "Unable to validate user / password in database";
   }

   if(isValidLogon) {
     response.sendRedirect(HOME_PAGE);
   } else {
     session.setAttribute("errorMsg", strErrMsg);
     response.sendRedirect(LOGIN_PAGE);
   }

}

See how we get the username and password from the request and pass to the method for authentication. Also, at the end we do a send redirect with either the errorMsg or username in session for displaying in Login.jsp or Home.jsp respectively. Ideally, the errorMsg should be put in requestScope and forwarded to JSP. However, since we are doing a redirect, we had to put it in session scope. Try changing the code for forwarding and using the requestScope instead. If you have queries, please feel free to add your comments / queries in the comments section at the end of the article.

Once the Servlet is ready, we need to registered and map it in the Web application’s deployment descriptor, web.xml. The web.xml is pretty straightforward.

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>SimpleLoginApp</display-name>
  <servlet>
    <description>
    </description>
    <display-name>LogonServlet</display-name>
    <servlet-name>LogonServlet</servlet-name>
    <servlet-class>in.techfreaks.login.servlet.LogonServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LogonServlet</servlet-name>
    <url-pattern>/servlet/LogonServlet</url-pattern>
   </servlet-mapping>
</web-app>

Login.jsp:
The JSP code is pretty straightforward. The call of Form POST to Servlet and use of c:out tag to display errorMsg from the servlet is shown in the below snippet.

<form name="frmLogin" method="POST" action="servlet/LogonServlet">
 <table border="1">
  <tbody>
    <tr>
      <td colspan="2"><c:out value="${errorMsg}"/> </td>
    </tr>
    <tr>
....

Home.jsp
The JSP is pretty straightforward. It uses the c:out exactly the same way as in Login.jsp to display the logged in username.

That completes our simple login application. You can test it by deploying the WAR file in Tomcat or any other favorite Application Server. The complete WAR along with the source code can be downloaded by clicking here.

Bugs are inevitable! There is a complaint that you can go the Home.jsp by directly typing the URL. Also, after you login and reach the Home.jsp, if you leave the session open for a long time and then refresh the username disappears. We leave the privilege of fixing the bug with you However, your approach would be to add a check in Home.jsp for session variable “userName”. If not available, redirect to Login.jsp. If you have any queries or need assistance, feel free to add your comments in the section below.

Try similar article which extends to the login application and adds Registration functionality by clicking Simple Registration Application using JSP, Servlet and MySQL.

Purpose

The purpose of this workshop is to migrate the shopping cart which we created in Session Based Shopping Cart Article and use Struts 1 framework for MVC. The article is not intended to explain all struts features like localization, validation framework, error handling etc.

Prerequisites

• Knowledge about struts1 application framework
• This articles assume that a session based shopping cart is already developed as explained in Session Based Shopping Cart Article . All requirements are same as the previous article.

Analysis and design

Our analysis and design will not be as exhaustive as the previous session based shopping cart. We already have the components designed and responsibility assigned (Also have code available). We will use the previous components and review the changes required.

Based on the previous article below are the list of components:
1. ModelList.jsp
2. ShoppingCart.jsp
3. CartBean.java
4. CartItemBean.java
5. CartController.java

We will move most of the logic from CartController which was a servlet and implement a Struts Action class instead. Hence, we create a new class CartAction which extends Action class.

If you look at the ModelList or ShoppingCart form(HTML Form), each form submits details of an Item or Model. ModelList has Add action on Item and ShoppingCart.jsp has Update and Delete action on Item. Based on this information, we can modify the CartItemBean into CartItemForm which extends Struts ActionForm class. Instance of the ActionForm will be provided as input to CartAction.

Hence, the revised list of components would look something like:
1. ModelList.jsp
2. ShoppingCart.jsp
3. CartBean.java
4. CartItemForm.java
5. CartAction.java

Development environment structure:

I prefer starting a struts 1 application by publishing the struts-blank application to Tomcat. The struts-blank application can be download from Apache website. The published struts-blank application provides a sample of struts-config.xml and all the required libraries to run a struts application.

However, at the end of the application we have provided a link to down the Web Archive (WAR) file of the whole StrutsShoppingCart application (with Source code).

StrutsShoppingCart
– ModelList.jsp
– ShoppingCart.jsp
WEB-INF
– struts-config.xml
– web.xml
src
– in.techfreaks.struts.cart.bean.CartBean.java
– in.techfreaks.struts.cart.form.CartItemForm.java
– in.techfreaks.struts.cart.action.CartAction.java
classes
lib
– jstl.jar
-standard.jar
– <ALL Struts required Lib >

Coding and Unit Testing:

web.xml
The deployment descriptor for the Web application. It has an entry for the struts ActionServlet which the generic Controller. It also maps all *.do extension through the ActionServlet. The struts-config.xml should be available in the path specified relative to the web application context.

<web-app>
   <display-name>Struts Shopping Cart Application</display-name>

   <!-- Standard Action Servlet Configuration -->
   <servlet>
      <servlet-name>action</servlet-name>
      <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
      <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
      </init-param>
      <load-on-startup>2</load-on-startup>
   </servlet>

    <!-- Standard Action Servlet Mapping -->
    <servlet-mapping>
       <servlet-name>action</servlet-name>
       <url-pattern>*.do</url-pattern>
     </servlet-mapping>

 </web-app>

struts-config.xml:

For our application we just need to declare the ActionForm and  add an ActionMapping.

<form-beans>
    <form-bean
        name="CartItemForm"
                    type="in.techfreaks.struts.cart.form.CartItemForm"/>
</form-beans>

<action-mappings>
    <action path="/Cart" type="in.techfreaks.struts.cart.action.CartAction" name="CartItemForm">
           <forward name="success" path="/ShoppingCart.jsp" />
    </action>
</action-mappings>

The action maps the Path to the Action class. It also has a forward to ShoppingCart.jsp on success. We do not have a failure forward but it would be required for a more robust production quality application. The ActionForm associated with the request is also provided. It maps to the ActionForm defined by the form-bean tag. The path when called from the JSP would call the Action class. Note that in the path which is in the action mapping, we do not have .do added but when we declare in the html form action, we would have the Cart.do.

CartAction :

The below code is excerpt from the CartAction class. The CartItemForm is passed in as a parameter to execute() method. Also, we moved the action into the CartItemForm. The CartItemForm is automatically populated by the Struts framework. We just need to make sure that the parameter name in the ActionForm is exactly same as the html form input fields in JSP.

public class CartAction extends Action {

   public static final String ADD = "Add";
   public static final String DELETE = "Delete";
   public static final String UPDATE = "Update";

   public static final String CART_SESSION = "Cart";

   public ActionForward execute(ActionMapping mapping, ActionForm form,
           HttpServletRequest request, HttpServletResponse response) throws Exception {
        CartItemForm cartItemForm = (CartItemForm) form;
        String strAction = cartItemForm.getAction();
        if(strAction!=null && !strAction.equals("")) {
          if(strAction.equals(ADD)) {
              addToCart(request, cartItemForm);
          } else if (strAction.equals(UPDATE)) {
              updateCart(request, cartItemForm);
          } else if (strAction.equals(DELETE)) {
              deleteCart(request, cartItemForm);
          }
   }

   return mapping.findForward("success");
}

CartItemForm:

Below is an excerpt of CartItemForm. Note that we moved itemIndex and action fields into the CartItemForm and hence we do not used the request.getParameter() to fetch these values in Action class, like we did the previous version of the controller.

 public class CartItemForm extends ActionForm {
    private String strPartNumber;
    private String strModelDescription;
    private double dblUnitCost;
    private int iQuantity;
    private double dblTotalCost;
    private String action ;
    private String itemIndex ;
}
 

ModelList.jsp and ShoppingCart.jsp:

The main change is calling the Action class instead of the Servlet. Below code explains how the Action class is called:

<form name="modelDetail3" method="POST" action="Cart.do">

Apart from that the JSP needs to be modified to use the web 2.0 div structure and have external CSS applied. However, we would defer to you as a home work ;)

Putting the cart to test:
We mainly want to test the below three functionalities:
1. Add to cart
2. Update the quantity
3. Remove an item from cart

Start Tomcat and access URL http://localhost:8080/StrutsShoppingCart/ModelList.jsp to test the above functionality.

You can download the WAR file by clicking StrutsShoppingCart download application link.

This WAR file can be directly deploy into Tomcat Web container. Adding the WAR to the webapps folder of Tomcat will automatically perform a Hot deployment.

This concludes the development of session based shopping cart using Struts 1 Framework.

Problem Statement

Write a simple servlet which counts the total number of hits on itself and display it in the web page.

Assumptions

• The web container will not be restarted. If it is restarted or servlet destroyed, the hit counter will be reset.
• The servlet is not loaded in a distributed environment.

We will be using this example to explain certain key concepts of servlet technology. We will also explain what will happen if the above assumption is not in place.

The below code shows a servlet which will display the number of hits on it.

package in.techfreaks.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SimpleCounterServlet extends HttpServlet {

	//Instance variable used for counting hits on this servlet
	private int iHitCounter;

	/**
	* init method just initializes the hitCounter to zero
	*/

	public void init() throws ServletException {
		iHitCounter = 0;
	}

	/**
	* Work horse of this servlet
	* Displays a welcome msg along with hitCounter
	* Increments the hitCounter
	*/

	public void doGet(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {

	PrintWriter out =  response.getWriter();
		out.println("<h2>Welcome to SimpleCounterServlet.java</h2>");
		out.println("Hits on this servlet so far: "+ (++iHitCounter)); 
	}

	/**
	* Passes the call to doGet method. 
	* Thus, works similar to doGet
	*/

	public void doPost(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {
		doGet(request, response);
	}
}

Below is the excerpt from web.xml which shows the servlet registration and servlet URL mapping.  

  ...
  <servlet>
    <servlet-name>SimpleCounterServlet</servlet-name>
    <servlet-class>in.techfreaks.servlet.SimpleCounterServlet</servlet-class>
  </servlet>
  ...
  <servlet-mapping>
    <servlet-name>SimpleCounterServlet</servlet-name>
    <url-pattern>/servlet/SimpleCounterServlet</url-pattern>
  </servlet-mapping>
  ....

http://localhost:8080/<contextName>/servlet/SimpleCounterServlet

Everytime the above URL is access, the hit counter shows an incremented value. You may like to try by closing the browser window and accessing from a different browser window.

Key Servlet Concept

We were able to achieve the counter functionality using a single instance variable. Why?

• Only one instance of the servlet is created
• init() method is called only once. This explains the reason why the counter is not reset to 0 with every hit

What will happen if the assumptions are removed?

• If the web container is restarted, the old servlet instance will be destroyed. New servlet instance will be instantiated and init() will be called. Thus, we will lose the counter is the old servlet.
• In a distributed environment, there may be multiple JVMs. For each node in which the web container is distributed, a different servlet instance may be created. Hence, the instance variable approach will fail.

For fixing the first issue, we could modify the servlet code to persist the hitCounter into a database or file. The init() would be loading the hitCounter from the file/database.

For fixing the second issue, we need to stored the hitCounter variable somewhere else… well, that somewhere is ‘ApplicationScope’.

Try the above two fixes for self study and post your solution in the comments below.

This workshop is for you, if:

• You want to get hands on feel of JSP and Servlets in real life scenarios
• You are dying to write some code and see it work
• You have heard enough about shopping carts and finally want to see what the heck, they are made of!

This workshop is not for you, if:

• You do not have any idea about JSP, Servlets or core Java
• You are looking for a production quality or ready to use shopping cart

Pre-requisites:

• Knowledge of Java fundamentals and collection framework
• JSP and servlet knowledge, especially, about session handling and JSTL
• Setup of environment: Tomcat and IDE. Check article
  Eclipse Tomcat integration

Requirement:

• Create simple catalog page with hard coded list of models with an “Add to Cart” button.
• The catalog model list page should contain a list of models with model number, description and price.
• On clicking the “Add to Cart” button, the model should get added to the shopping cart.
• The cart should display all the models added to it. For each line item, it should display model number, description and unit price of item and total price. It should also display the total price for the whole order.
• For each item in the cart, there should be a delete button next to it for removing the item from cart.
• For each item in the cart, there should be a text input to enter a quantity value with update button to update the quantity of item in the cart.
• The cart should have a link back to catalog model list page.

Shopping Cart overview:

Shopping cart is the heart of any e-commerce application. It is something highly talked about. But, what do you mean by a session based shopping cart? Well, shopping carts can be mainly session based or database based. As the name indicates, session based carts are completely maintained in the user”s session. Only after the checkout is completed, the information is persisted in the database. On the other hand, a database based shopping cart is maintained in the database. Every time cart items are added or updated, it gets persisted in the database. Both of them have their own advantages and disadvantages. For each add or update in database based cart, there will be a hit in the database. On the other hand, it gives us the advantage of cart persistence. You can leave your shopping halfway and come back after sometime and resume the shopping session.

Analysis and Design:

Designing the components prior to coding is pretty useful. Better the designing, easier it is to code and lesser the rework. We will be digging pretty deep into the design to throw light on some of the design principles. If you are not interested in designing and stuff, you may want to glance through the UML diagrams and move on to code.

Identifying components:
Let us analyze the requirements, and try to identify the different components needed for this workshop. For our analysis, we try to identify components based on Model-View-Controller (MVC) design.

We need to create a ModelList page, with “Add to cart” button.

Technically speaking, what does a cart comprise? It is a collection of items added to the session. Let us use, ArrayList for our cart. So, the basic idea is to have an ArrayList added to session object.

We will refine this a bit. Going forward, we may need the cart item to hold other things than just CartItems. Something like Promotion code data. So, we will maintain a special cart object. And the cart will contain ArrayList of cart items.

But, what will the ArrayList comprise? String will not do for sure. Probably, we need a special item bean. Right, so we will have ItemBean added to ArrayList, and the ArrayList will be added to session. This sounds great!

We need a shopping cart jsp. It would need to pull ArrayList out of the session and iterate this, and display it in the JSP.

Aren’t we missing something? We need something to control the events coming from the “Add to cart”, “Update Item” and “Delete Item”. We need a rocking controller to handle these events. The servlet should be the one to do this job.

Based on the above analysis, let us summarize the components we had identified:
1. ModelList.jsp
2. ShoppingCart.jsp
3. CartBean.java
4. CartItemBean.java
5. CartController.java

Identifying attributes for cart:
Now, let us try to identify more information for the cart related classes.

CartBean:

• ArrayList of CartItemBean
• totalCost of items in cart

CartItemBean:

• Part number for the model
• Model description
• Unit cost
• Quantity
• Total item cost

Identifying methods:
CartController:
This servlet controller needs to implement the doGet/doPost methods. It needs to handle the events for addToCart, updateCart and deleteCart. It is a better design to handle each of these events separately. So, based on this discussion, the CartController will need to have the following methods:

• doGet/doPost – Delegates request to different event methods like addToCart etc.
• addToCart – Handle the add to cart functionality
• updateCart – Handle the update cart item functionality
• deleteCart – Handle delete cart item from cart functionality

Let us work through the “Calculate the cart total” and “Add to cart” functionality to analyze and come up with methods related to it.

Calculating the cart total:
This is a major functionality, which needs to be utilized every time an item is added, removed or updated. Let us discuss considering different design principles and try to come up with a realization for this functionality.

Information expert principle says that, any object which has the information to perform an operation should do the job.
For calculating the total price, we need to first know the total for each line item. So, let us apply expert principle to get the line item total. Since, CartItemBean has both quantity and unit cost, based on expert, it is the right candidate.

Just to understand the association between the different objects, we know, that CartBean houses a list of CartItemBean. The CartController on the other hand will be one to add the CartBean in session. Now, this means, CartBean is associated with CartItemBean and CartBean is associated also with CartController.

Coupling design principle says that, the association or coupling between different objects should be as less as possible. More the coupling, more spaghetti code syndrome. You make changes to code in one class; all the associated classes need changes.

Since CartController has access to CartBean, we can write a calculateTotal method in the CartController, where we will have to pull the list of CartItemBeans from CartBean in this method and calculate the total price. However, this means, iterating through the CartItemBean list in CartController and also calls on CartItemBean.getSubtotal(). This introduces CartItemBean to CartController coupling.

Hmmmm! Not that good news isn’t it?

But, do we have a choice? Going again by expert, CartBean does have access to all CartItemBeans. So, it is an expert to calculate the order total. Also, it does not have a CartItemBean to CartController coupling. So, this is a better choice.

Add to Cart functionality:

We said that CartBean will house an ArrayList of CartItemBeans. So, we will have a getter/setter for setting this ArrayList inside CartBean. But, who will create the ArrayList of CartItemBeans and then call setCartItems? It has to be CartController. This intern means, CartItemBean creation, setting values and adding to ArrayList, needs to be performed in CartController. Hmmm….But, we have been working so hard eliminate the CartController to CartItemBean coupling while designing the “calculate order total” functionality. Even with this, creating the ArrayList of CartItemBeans and setting it in CartBean everytime is a tall order. We need something like addCartItem(CartItemBean) in CartBean. This will add to the ArrayList of CartItemBeans everytime this is called. So, the CartController does not have to worry above the ArrayList and setting the ArrayList using the setCartItem method. That is a great relief!!

Hey, hold on! But, when we still will call setters in CartItemBean from CartController and then call the CartBean.addCartItem(CartItemBean). Isn”t it not adding coupling between CartController and CartItemBean. Well, sad but true! Let us try to look for any some more options.

It would be dreamy, if CartBean can take complete control of the CartItemBean, without any CartController intervention.  Let us try to delegate the task of creating CartItemBean and setting values into it to CartBean. But, is it possible; is the question to be answered? How will the CartBean know, what should be the state of the CartItemBean created? Well, since the CartController has this information, it can pass on this information to CartBeans method as parameters. Like

• addCartItem(String strModelNo, String strDescription, String strUnitCost, String strQuantity)

Passing 4 parameters in the method call may not be that bad! But, in a real production cart scenario, we may need more parameters. We can generally work around this by using a value object. But for our example this is fine.

Party time! We just designed the addToCart without increasing the coupling. Note here that, CartController is the information expert. The CartBean may be considered as a partial expert. However, we considered both coupling and expert to come up with this design. This leads us to something very important while using design principles. No single design principle can be used in isolation to design functionality. We need to consider different design principles to come up with a design.

We will use the same principle for updateCartItem and deleteCartItem functionality. You may want to think over it.

So, based on the above discussion, below the class diagram for our cart sub-system.

Sequence diagram for Add To Cart:

Setting up the environment for development:

We will be using Tomcat 6.x for running and testing our shopping cart. Refer “First JSP/Servlet workshop” for Tomcat installation details.
We will be developing using Eclipse 3.x integrated with Tomcat via Sysdeo plugin. Refer “Integration of Eclipse with Tomcat” article for details.

Let us create a new Tomcat Project, with context name as /ShoppingCart.
Set the source path and build path correctly. We will need JSTL libraries (jstl.jar and standard.jar) as we will be using JSTL/EL for the shopping cart page.

We should be able to start Tomcat from Eclipse, and access the any JSP page inside /ShoppingCart context which we created using the URL http://localhost:8080/ShoppingCart/<AnyFile.jsp>

The following will be approximate directory structure of the ShoppingCart project.

ShoppingCart
- ModelList.jsp
- ShoppingCart.jsp
     WEB-INF
        src
        - in.techfreaks.shoppingcart.beans.CartBean.java
        - in.techfreaks.shoppingcart.beans.CartItemBean.java
        - in.techfreaks.shoppingcart.servlet.CartController.java
        classes
        lib
        - jstl.jar
        -standard.jar

Coding the Cart:
Such detailed design generally makes coding just a formality. Below is the code for each of the element identified during design. The code is pretty straight forward.

CartItemBean:

package in.techfreaks.shoppingcart.beans;

public class CartItemBean {
    private String strPartNumber;
    private String strModelDescription;
    private double dblUnitCost;
    private int iQuantity;
    private double dblTotalCost;
    
    public String getPartNumber() {
        return strPartNumber;
    }
    public void setPartNumber(String strPartNumber) {
        this.strPartNumber = strPartNumber;
    }
    public String getModelDescription() {
        return strModelDescription;
    }
    public void setModelDescription(String strModelDescription) {
        this.strModelDescription = strModelDescription;
    }
    public double getUnitCost() {
        return dblUnitCost;
    }
    public void setUnitCost(double dblUnitCost) {
        this.dblUnitCost = dblUnitCost;
    }
    public int getQuantity() {
        return iQuantity;
    }
    public void setQuantity(int quantity) {
        iQuantity = quantity;
    }
    public double getTotalCost() {
        return dblTotalCost;
    }
    public void setTotalCost(double dblTotalCost) {
        this.dblTotalCost = dblTotalCost;
    }
}

CartBean:

 package in.techfreaks.shoppingcart.beans;

import java.util.ArrayList;


public class CartBean {
 private ArrayList alCartItems = new ArrayList();
 private double dblOrderTotal ;
 
 public int getLineItemCount() {
  return alCartItems.size();
 }
 
 public void deleteCartItem(String strItemIndex) {
  int iItemIndex = 0;
  try {
   iItemIndex = Integer.parseInt(strItemIndex);
   alCartItems.remove(iItemIndex - 1);
   calculateOrderTotal();
  } catch(NumberFormatException nfe) {
   System.out.println("Error while deleting cart item: "+nfe.getMessage());
   nfe.printStackTrace();
  }
 }
 
 public void updateCartItem(String strItemIndex, String strQuantity) {
  double dblTotalCost = 0.0;
  double dblUnitCost = 0.0;
  int iQuantity = 0;
  int iItemIndex = 0;
  CartItemBean cartItem = null;
  try {
   iItemIndex = Integer.parseInt(strItemIndex);
   iQuantity = Integer.parseInt(strQuantity);
   if(iQuantity>0) {
    cartItem = (CartItemBean)alCartItems.get(iItemIndex-1);
    dblUnitCost = cartItem.getUnitCost();
    dblTotalCost = dblUnitCost*iQuantity;
    cartItem.setQuantity(iQuantity);
    cartItem.setTotalCost(dblTotalCost);
    calculateOrderTotal();
   }
  } catch (NumberFormatException nfe) {
   System.out.println("Error while updating cart: "+nfe.getMessage());
   nfe.printStackTrace();
  }
  
 }
 
 public void addCartItem(String strModelNo, String strDescription,
String strUnitCost, String strQuantity) {
  double dblTotalCost = 0.0;
  double dblUnitCost = 0.0;
  int iQuantity = 0;
  CartItemBean cartItem = new CartItemBean();
  try {
   dblUnitCost = Double.parseDouble(strUnitCost);
   iQuantity = Integer.parseInt(strQuantity);
   if(iQuantity>0) {
    dblTotalCost = dblUnitCost*iQuantity;
    cartItem.setPartNumber(strModelNo);
    cartItem.setModelDescription(strDescription);
    cartItem.setUnitCost(dblUnitCost);
    cartItem.setQuantity(iQuantity);
    cartItem.setTotalCost(dblTotalCost);
    alCartItems.add(cartItem);
    calculateOrderTotal();
   }
   
  } catch (NumberFormatException nfe) {
   System.out.println("Error while parsing from String to primitive types: "+nfe.getMessage());
   nfe.printStackTrace();
  }
 }
 
 public void addCartItem(CartItemBean cartItem) {
  alCartItems.add(cartItem);
 }
 
 public CartItemBean getCartItem(int iItemIndex) {
  CartItemBean cartItem = null;
  if(alCartItems.size()>iItemIndex) {
   cartItem = (CartItemBean) alCartItems.get(iItemIndex);
  }
  return cartItem;
 }
 
 public ArrayList getCartItems() {
  return alCartItems;
 }
 public void setCartItems(ArrayList alCartItems) {
  this.alCartItems = alCartItems;
 }
 public double getOrderTotal() {
  return dblOrderTotal;
 }
 public void setOrderTotal(double dblOrderTotal) {
  this.dblOrderTotal = dblOrderTotal;
 }
 
 protected void calculateOrderTotal() {
  double dblTotal = 0;
  for(int counter=0;counter<alCartItems.size();counter++) {
   CartItemBean cartItem = (CartItemBean) alCartItems.get(counter);
   dblTotal+=cartItem.getTotalCost();
   
  }
  setOrderTotal(dblTotal);
 }

}
 

CartController:

package in.techfreaks.shoppingcart.servlet;

import in.techfreaks.shoppingcart.beans.CartBean;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class CartController extends HttpServlet {
 
 //public static final String addToCart
 
 public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

  String strAction = request.getParameter("action");
  
  
  if(strAction!=null && !strAction.equals("")) {
   if(strAction.equals("add")) {
    addToCart(request);
   } else if (strAction.equals("Update")) {
    updateCart(request);
   } else if (strAction.equals("Delete")) {
    deleteCart(request);
   }
  }
  response.sendRedirect("../ShoppingCart.jsp");
 }
 
 protected void deleteCart(HttpServletRequest request) {
  HttpSession session = request.getSession();
  String strItemIndex = request.getParameter("itemIndex");
  CartBean cartBean = null;
  
  Object objCartBean = session.getAttribute("cart");
  if(objCartBean!=null) {
   cartBean = (CartBean) objCartBean ;
  } else {
   cartBean = new CartBean();
  }
  cartBean.deleteCartItem(strItemIndex);
 }
 
 protected void updateCart(HttpServletRequest request) {
  HttpSession session = request.getSession();
  String strQuantity = request.getParameter("quantity");
  String strItemIndex = request.getParameter("itemIndex");
 
  CartBean cartBean = null;
  
  Object objCartBean = session.getAttribute("cart");
  if(objCartBean!=null) {
   cartBean = (CartBean) objCartBean ;
  } else {
   cartBean = new CartBean();
  }
  cartBean.updateCartItem(strItemIndex, strQuantity);
 }
 
 protected void addToCart(HttpServletRequest request) {
  HttpSession session = request.getSession();
  String strModelNo = request.getParameter("modelNo");
  String strDescription = request.getParameter("description");
  String strPrice = request.getParameter("price");
  String strQuantity = request.getParameter("quantity");
  
  CartBean cartBean = null;
  
  Object objCartBean = session.getAttribute("cart");

  if(objCartBean!=null) {
   cartBean = (CartBean) objCartBean ;
  } else {
   cartBean = new CartBean();
   session.setAttribute("cart", cartBean);
  }
  
  cartBean.addCartItem(strModelNo, strDescription, strPrice, strQuantity);
 }

}

• Do not ever maintain any state in servlet”s instance variables. You may find mixing of data between requests or user sessions. The best part of this is that, it will only happen in a production environment and you win a severity 1 ticket and that too completely free!

 ModelList.jsp

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>www.tech-freaks.in - Model List</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>

<body>
<p><font size="3" face="Verdana, Arial, Helvetica, sans-serif"><strong>Model List
  </strong></font></p>
<a href="ShoppingCart.jsp" mce_href="ShoppingCart.jsp">View Cart</a>
<p/>    
<table width="75%" border="1">
  <tr>
    <td><form name="modelDetail1" method="POST" action="servlet/CartController">
 <font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Model:</strong>
        TF-Model1</font><input type="hidden" name="modelNo" value="TF-MODEL1">
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Description:</strong>
        Tech-Freaks imaginary model 1. </font><input type="hidden" name="description" value="Tech-Freaks imaginary model 1."></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Quantity:<input type="text" size="2" value="1" name="quantity"></strong></font></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Price:</strong>
        $10.00</font><input type="hidden" name="price" value="10"></p><input type="hidden" name="action" value="add"><input type="submit" name="addToCart" value="Add To Cart">
      </form></td>
    <td><form name="modelDetail2" method="POST" action="servlet/CartController"><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Model</strong>:
      TF-Model2 </font><input type="hidden" name="modelNo" value="TF-MODEL2">
<font face="Verdana, Arial, Helvetica, sans-serif">
      <p><font size="2"><strong>Description</strong>: Tech-Freaks imaginary model
        2. </font><input type="hidden" name="description" value="Tech-Freaks imaginary model 2."></p>
      <p><font size="2"><strong>Quantity</strong>: <input type="text" size="2" value="1" name="quantity"></font></p>
      <p><font size="2"><strong>Price</strong>: $20.00<input type="hidden" name="price" value="20"></font></p>
           <input type="hidden" name="action" value="add">
             <input type="submit" name="addToCart" value="Add To Cart">
      </font></form></td>
  </tr>
  <tr>
    <td><form name="modelDetail3" method="POST" action="servlet/CartController"><p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Model:</strong>
        TF-Model3</font><input type="hidden" name="modelNo" value="TF-MODEL3"></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Description:</strong>
        Tech-Freaks imaginary model 3. </font><input type="hidden" name="description" value="Tech-Freaks imaginary model 3."></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Quantity:</strong></font> <input type="text" size="2" value="1" name="quantity"></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Price: $30.00</strong></font><input type="hidden" name="price" value="30"></p>        <input type="hidden" name="action" value="add">
        <input type="submit" name="addToCart" value="Add To Cart">
</form></td>
    <td><form name="modelDetail4" method="POST" action="servlet/CartController"><p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Model</strong>:
        TF-Model4</font><input type="hidden" name="modelNo" value="TF-MODEL4"></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Description</strong>:
        Tech-Freaks imaginary model 4. </font><input type="hidden" name="description" value="Tech-Freaks imaginary model 4."></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Quantity</strong>:</font> <input type="text" size="2" value="1" name="quantity"></p>
      <p><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><strong>Price</strong>: $40.00</font><input type="hidden" name="price" value="40"></p>
   <input type="hidden" name="action" value="add"><input type="submit" name="addToCart" value="Add To Cart"></form></td>
  </tr>
</table>
<p> </p>
</body>
</html>

ShoppingCart.jsp

For iterating the elements in the cart session, we are using simple JSTL tags with EL.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>www.tech-freaks.in - Shopping Cart</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>

<body>
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<p><font face="Verdana, Arial, Helvetica, sans-serif"><strong>Shopping Cart</strong></font></p>
<p><a href="ModelList.jsp" mce_href="ModelList.jsp">Model List</a> </p>
<table width="75%" border="1">
  <tr bgcolor="#CCCCCC">
    <td><strong><font size="2" face="Verdana, Arial, Helvetica, sans-serif">Model
      Description</font></strong></td>
    <td><strong><font size="2" face="Verdana, Arial, Helvetica, sans-serif">Quantity</font></strong></td>
    <td><strong><font size="2" face="Verdana, Arial, Helvetica, sans-serif">Unit
      Price</font></strong></td>
    <td><strong><font size="2" face="Verdana, Arial, Helvetica, sans-serif">Total</font></strong></td>
  </tr>
  <jsp:useBean id="cart" scope="session" class="in.techfreaks.shoppingcart.beans.CartBean" />
  <c:if test="${cart.lineItemCount==0}">
  <tr>
  <td colspan="4"><font size="2" face="Verdana, Arial, Helvetica, sans-serif">- Cart is currently empty -<br/>
  </tr>
  </c:if>
  <c:forEach var="cartItem" items="${cart.cartItems}" varStatus="counter">
  <form name="item" method="POST" action="servlet/CartController">
  <tr>
    <td><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><b><c:out value="${cartItem.partNumber}"/></b><br/>
      <c:out value="${cartItem.modelDescription}"/></font></td>
    <td><font size="2" face="Verdana, Arial, Helvetica, sans-serif"><input type='hidden' name='itemIndex' value='<c:out value="${counter.count}"/>'><input type='text' name="quantity" value='<c:out value="${cartItem.quantity}"/>' size='2'> <input type="submit" name="action" value="Update">
 <br/>         <input type="submit" name="action" value="Delete"></font></td>
    <td><font size="2" face="Verdana, Arial, Helvetica, sans-serif">

lt;c:out value="${cartItem.unitCost}"/></font></td> <td><font size="2" face="Verdana, Arial, Helvetica, sans-serif">

lt;c:out value="${cartItem.totalCost}"/></font></td> </tr> </form> </c:forEach> <tr> <td colspan="2"> </td> <td> </td> <td><font size="2" face="Verdana, Arial, Helvetica, sans-serif">Subtotal:

lt;c:out value="${cart.orderTotal}"/></font></td> </tr> </table> </body> </html>

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">

  <display-name>Shopping Cart</display-name>
  <description>
    Simple Shopping Cart
  </description>

  <servlet>
    <servlet-name>CartController</servlet-name>
    <servlet-class>in.techfreaks.shoppingcart.servlet.CartController</servlet-class>
  </servlet>

  <!-- Define the Manager Servlet Mapping -->
  <servlet-mapping>
    <servlet-name>CartController</servlet-name>
      <url-pattern>/servlet/*</url-pattern>
  </servlet-mapping>

</web-app>

Putting the cart to test:
We mainly want to test the below three functionalities:
1. Add to cart
2. Update the quantity
3. Remove an item from cart

Start Tomcat from Eclipse and access URL http://localhost:8080/ShoppingCart/ModelList.jsp to test the above functionality.

Change requests:
Change is the essence of life! Same happens to business requirements and code. This means, that a “hardly working” developer has to become “hardworking”. So, we would like you to be the “hardworking” programmer to add the below functionality in this existing cart.
1. Currently, if the same item is again added to cart, a new line item is added. Modify this in such a way that, if the same item is added again, the existing item’s quantity should be incremented by one. All other state of the cart/cart items should be adjusted accordingly.
2. In the cart page, provide a new text box for redeeming promotion codes. The discount of 5% should be provided on the order total, when any of the promotion code from a list of pre-defined codes is used.

Feel free to write to us at programmer@tech-freaks.com for any queries regarding this change request.

Enjoy! Coding and rock n roll, always rulz!

UPDATE: Checkout our latest article on Session Based Shopping Cart using Struts 1 Framework.

This workshop is for you, if:

• You are looking to use an IDE for writing your JSP and Servlet code
• You are trying to figure out, how to integrate your Eclipse IDE with Tomcat

This workshop is not for you, if:

• You do not have any clue what JSP or Servlet is and you are trying to understand it

Introduction:

Writing endless JSP/Servlet code using Notepad, compiling it from command line and then deploying them in Tomcat can be a tedious job. Using an IDE like Eclipse for web development, does make life easy. It takes up the work of finding compilation errors before even you start to compile, which is a big relief. Also, no need to go back to the command line… set the CLASSPATH for each new library which you want to use. But, won’t it be an icing on the cake, if we could just write the code compile it and test it, without deploying the compiled file to Tomcat server, for every change we do to the file?

Yes, that will be awesome! This is what we are trying to do in the workshop. Have our work environment configured such that, we will just make changes, compile it and test in browser without having to worry about deploying etc again and again.

Software requirement:

For this workshop the below mentioned versions of the software will be necessary. It may be possible to work with a different version, as long as the versions of different softwares are compatible with each other.

• J2SE 1.5 or above
• Eclipse 3.4 – It can be download and installed from Eclipse website
• Tomcat 6.x – Download and install from Apache website
• Sysdeo Eclipse Tomcat Launcher plugin – Download the latest version of Sysdeo Eclipse Tomcat Launcher plugin from the Eclipsetotale website

Installing Tomcat and Eclipse:

• Refer article Java Hello World using Eclipse for details regarding installing and setting up Eclipse
• Refer article First JSP/Servlet Workshop for details regarding installing and setting up Tomcat

Integrating Tomcat with Eclipse using Tomcat Launcher Plugin

Let us see, how we can bell the Tomcat within the Eclipse environment

• First, let us unzip the downloaded Sysdeo Tomcat plugin and extract to the location <Eclipse Installation Directory>/dropins folder.

• For Eclipse version 3.1, 3.2 and 3.3 you need to extract the plugin zip contents to <Eclipse Installation Directory>/plugins folder 

• Restart Eclipse if it already open.
• You will see three tomcat icon on the eclipse toolbar. Tomcat start, Tomcat stop and Tomcat restart. Yippie!! Let us try starting Tomcat. It looks like eclipse was unable to locate certain information for Tomcat. The error message reads, “Tomcat settings should be set in Tomcat Preference Page”.

•  So, let us check this preference page. From the top menu, select Windows –> Preference (See image above).
• We need to set the correct values here:
  Select Version 6.x
  Browse and Select Tomcat Home
  Other information will get automatically populated
• In this window, there are other tabs like Advanced, JVM settings, Source Path etc under Tomcat tree expand icon. You may want to verify the JVM settings. Ensure that the JRE is set to 1.5 or above. Once done, just click Ok to save and exit that window.
• Now, click the Tomcat start button and you should be able to startup logs in the console. 
• Let check, if Tomcat is working now. In the web browser, type http://localhost:8080/
  You should be able to see Tomcat standing proudly!

Well, we are done! But, let us try a simple web context, a servlet and a JSP, all using Eclipse.

Simple web app using Eclipse:

• We need to create a new project in Eclipse. From the menu, we need to select File –> New –> Project

• In the new project window, expand the Java section and you will be able to see Tomcat Project (See image above). Select it and click Next.

• In the Java Project settings, provide a Project Name. You can also override the location where you want the project files to be present (see image above). Click Next when done.

• In this step, you will have to provide a context name. This is the same context name by which the web application will be created in Tomcat. You can verify this from the manager console later. So, provide a context name and move ahead. Do not forget to put a slash (/) before the context name (see image above). We are done! Let us click finish.
• You will notice that, the creation of the project itself creates most of the directories and files needed.
• Let us now verify, if build path and libraries are present for compiling our servlet.
• We can get the details in the Project Properties window and Java Build Path section
  Source tab:
  The Default output folder should be <ContextRoot>/WEB-INF/classes folder. This means, all compiled classes will be added to this folder.
  The Source folder on build path, should have the folder listed where you are planning to have your Java source files. < ContextRoot >/WEB-INF/src will be the folder by default.
  Library tab:
  We will have to add any external libraries which we are planning to use in our web application. You will see, servlet-api.jar already listed there. This means, we are good to compile our simple servlet.

The only missing thing for the web application is the heart! The web.xml! It would have been great, if the web.xml was added automatically, however, it does not happen. We will have to manually create the web.xml and add it under WEB-INF folder.

• So, let us create the JSP, Servlet and web.xml file using Eclipse:

JSP: We will create the MyFirstJspPage.jsp and place it under <ContextRoot>/ folder

<html>
  <head>
    <title>First JSP</title>
  </head>
  <body>
  <div id="error" style="display:block;"><font color="red">
    <%if(request.getAttribute("errMsg")!=null) { out.println(request.getAttribute("errMsg"));} %>
  </font></div>
  <form name="form" action="servlet/MyFirstServlet">
  First Name: <input type="text" name="firstName" ><br>
  Last Name: <input type="text" name="lastName" ><br><br>
  <input type="submit" name="submit" value="Submit" >
  </form>
  </body>
</html>

Servlet: We will create the MyFirstServlet.java under <ContextRoot>/WEB-INF/src/. Ofcourse, under appropriate package structure in.techfreaks.servlet.

package in.techfreaks.servlet;

import java.io.*;
import javax.servlet.http.*;
import javax.servlet.*;

public class MyFirstServlet extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
 String strErrMsg = "Please enter first name and last name";
 String strFirstName = request.getParameter("firstName");
 String strLastName = request.getParameter("lastName");
 if(strFirstName!=null && !strFirstName.equals("") && strLastName!=null && !strLastName.equals("")) {
  PrintWriter out = response.getWriter();
  out.println("Name : "+strFirstName+" "+strLastName);
  } else {
   request.setAttribute("errMsg", strErrMsg);
   request.getRequestDispatcher("../MyFirstJspPage.jsp").forward(request, response);
  }
}

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
  doPost(request, response);
 }
}

web.xml: We will create the web.xml under <ContextRoot>/WEB-INF/

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation=http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
 <display-name>Simple WebApp</display-name>
  <description>
    Simple Web Application
  </description>  <servlet>
    <servlet-name>MyFirstServlet</servlet-name>
    <servlet-class>in.techfreaks.servlet.MyFirstServlet</servlet-class>
  </servlet>  <!-- Define the Manager Servlet Mapping -->
  <servlet-mapping>
    <servlet-name>MyFirstServlet</servlet-name>
      <url-pattern>/servlet/*</url-pattern>
  </servlet-mapping>
</web-app>

 

After you write the servlet, without compilation error and save, if you peep in the file system, you will find the class file automatically compiled at <ContextRoot>/WEB-INF/classes.

Restart Tomcat from Eclipse and we are all ready!

Testing:

We are not testing the complete logic of the servlet here. We will just test to see, if the servlet and JSP are getting called, as expected.

http://localhost:8080/FirstJspServlet/MyFirstJspPage.jsp

The JSP file with first name and last name input should open.
Enter first name and last name and click enter, it should display the name in the next page, which is our servlet.

We are all set now for doing bigger things, using Eclipse IDE! So, sit back€¦. get a cup of coffee€¦ and enjoy writing your JSP and servlet code!

Check the latest article Quick Tomcat and Eclipse Integration €“ Deploying Web apps to Tomcat from within Eclipse which walks through step by step for configuring Tomcat 8 with the latest Eclipse Kepler version