Spring MVC 3.1 and JasperReports: Using iReport and AJAX (Part 2)

Review

In the previous section, we have laid down the functional specs of the application. In this section, we will discuss the project's structure and write the Java classes in layers.

Table of Contents

Part 1: Introduction and Functional Specs
Part 2: Java classes
Part 3: Jasper layout with iReport
Part 4: HTML and jqGrid
Part 5: XML configuration
Part 6: Running the Application

Project Structure

Our application is a Maven project and therefore follows Maven structure. As we create the classes, we've organized them in logical layers: domain, repository, service, and controller.

Here's a preview of our project's structure:

The Layers

Domain

This layer contains two domain classes, User and Role. They represent our database tables, user and role respectively. Because we're developing a JPA-based repository, both classes must be annotated with JPA annotations.

	package org.krams.domain;
	import javax.persistence.CascadeType;
	import javax.persistence.Column;
	import javax.persistence.Entity;
	import javax.persistence.GeneratedValue;
	import javax.persistence.GenerationType;
	import javax.persistence.Id;
	import javax.persistence.OneToOne;
	@Entity(name="user")
	public class User {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;
	private String firstName;
	private String lastName;
	@Column(unique=true)
	private String username;
	private String password;
	@OneToOne(mappedBy="user", cascade={CascadeType.ALL})
	private Role role;
	public User() {}
	public User(String username, String password, String firstName, String lastName, Role role) {
	this.username = username;
	this.password = password;
	this.firstName = firstName;
	this.lastName = lastName;
	this.role = role;
	}
	public User(String username, String firstName, String lastName, Role role) {
	this.username = username;
	this.firstName = firstName;
	this.lastName = lastName;
	this.role = role;
	}
	public User(String username) {
	this.username = username;
	}
	...getters/setters
	}

view raw User.java hosted with ❤ by GitHub

	package org.krams.domain;
	import javax.persistence.Entity;
	import javax.persistence.GeneratedValue;
	import javax.persistence.GenerationType;
	import javax.persistence.Id;
	import javax.persistence.OneToOne;
	@Entity(name="role")
	public class Role {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;
	@OneToOne
	private User user;
	private Integer role;
	public Role() {}
	public Role(Integer role) {
	this.role = role;
	}
	...getters/setters
	}

view raw Role.java hosted with ❤ by GitHub

Data Transfer Object (DTO)

This layer contains four DTO classes:

• UserDto is a POJO for mapping User objects to and from the presentation layer
• StatusResponse is a POJO for sending boolean responses to the presentation layer
• JqgridResponse is a container for UserDto objects for sending records to the jqGrid table. It contains information regarding the number of rows, current page, and total pages.
• JasperDto is a POJO for mapping User objects into something that Jasper can process easily (This is used for reporting purposes only.)

Note: We won't display the contents of UserDto, StatusReponse, and JqgridResponse here since we've already discussed that on a different tutorial (see Spring MVC 3.1, jqGrid, and Spring Data JPA Integration Guide (Part 2))

	package org.krams.response;
	import java.io.Serializable;
	public class JasperDto implements Serializable {
	private Long id;
	private String firstName;
	private String lastName;
	private String username;
	private String role;
	...getters/setters
	}

view raw JasperDto.java hosted with ❤ by GitHub

Controller

This layer contains two controllers, MediatorController and UserController.

• MediatorController is responsible for redirecting requests from the root path to the Users page
• UserController is responsible for handling user related requests, including download requests

	package org.krams.controller;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.RequestMapping;
	@Controller
	@RequestMapping("/")
	public class MediatorController {
	@RequestMapping
	public String getHomePage() {
	return "redirect:/users";
	}
	}

view raw MediatorController.java hosted with ❤ by GitHub

	package org.krams.controller;
	import java.util.List;
	import javax.servlet.http.HttpServletResponse;
	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.krams.response.JqgridResponse;
	import org.krams.response.StatusResponse;
	import org.krams.response.UserDto;
	import org.krams.service.DownloadService;
	import org.krams.service.TokenService;
	import org.krams.util.UserMapper;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.data.domain.Page;
	import org.springframework.data.domain.PageRequest;
	import org.springframework.data.domain.Pageable;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestParam;
	import org.springframework.web.bind.annotation.ResponseBody;
	@Controller
	@RequestMapping("/users")
	public class UserController {
	@Autowired
	private UserRepository repository;
	@Autowired
	private DownloadService downloadService;
	@Autowired
	private TokenService tokenService;
	@RequestMapping
	public String getUsersPage() {
	return "users";
	}
	@RequestMapping(value="/records", produces="application/json")
	public @ResponseBody JqgridResponse<UserDto> records(
	@RequestParam(value="page", required=false) Integer page,
	@RequestParam(value="rows", required=false) Integer rows) {
	Pageable pageRequest = new PageRequest(page-1, rows);
	Page<User> users = repository.findAll(pageRequest);
	List<UserDto> userDtos = UserMapper.map(users);
	JqgridResponse<UserDto> response = new JqgridResponse<UserDto>();
	response.setRows(userDtos);
	response.setRecords(Long.valueOf(users.getTotalElements()).toString());
	response.setTotal(Integer.valueOf(users.getTotalPages()).toString());
	response.setPage(Integer.valueOf(users.getNumber()+1).toString());
	return response;
	}
	@RequestMapping(value="/download/progress")
	public @ResponseBody StatusResponse checkDownloadProgress(@RequestParam String token) {
	return new StatusResponse(true, tokenService.check(token));
	}
	@RequestMapping(value="/download/token")
	public @ResponseBody StatusResponse getDownloadToken() {
	return new StatusResponse(true, tokenService.generate());
	}
	@RequestMapping(value="/download")
	public void download(@RequestParam String type,
	@RequestParam String token,
	HttpServletResponse response) {
	downloadService.download(type, token, response);
	}
	}

view raw UserController.java hosted with ❤ by GitHub

Let's describe the methods available from UserController:

• The records() method returns a list of UserDto objects as JSON strings. This will be displayed on the presentation layer as an interactive grid of data with the help of jqGrid plugin.
• checkDownloadProgress() method is used to check if a download token is present or not. See Download Token Algorithm below
• getDownloadToken() method is used to retrieve a download token. See Download Token Algorithm below
• download() method performs the actual report download by delegating it to the DownloadService.

Download Token Algorithm
(Inspired by Detect when browser receives file download)

This is basically a fancy way of adding a progress box in an AJAX environment, so that we can display the status of a download requests. In a typical AJAX requests, the call is perform asynchronously, and the user does not know if the requests is being processed unless we provide a progress report. Unfortunately, you can't use AJAX directly for file downloads.

However, you can provide an illusion of a progress report through the Download Token Algorithm:

1. User clicks on download button. A progress box appears.
2. Download button performs an AJAX requests to retrieve a download token
3. Once a download token has been received, a call to the actual download URL is performed. (This is not an AJAX requests)
4. Periodically perform an AJAX requests to check if the download token retrieved earlier still exists. If not, the download has started.
5. If the download token does not exists anymore, close the progress box.

Repository

This layer contains a single interface, UserRepository. This is our data access object (DAO). With the help of Spring Data JPA, Spring will automatically provide the actual implementation.

What is Spring Data JPA?

Spring JPA is part of the umbrella Spring Data project that makes it easy to easily implement JPA based repositories.

Implementing a data access layer of an application has been cumbersome for quite a while. Too much boilerplate code has to be written to execute simple queries as well as perform pagination, and auditing. Spring JPA aims to significantly improve the implementation of data access layers by reducing the effort to the amount that's actually needed. As a developer you write your repository interfaces, including custom finder methods, and Spring will provide the implementation automatically.

Source: http://www.springsource.org/spring-data/jpa

	package org.krams.repository;
	import org.krams.domain.User;
	import org.springframework.data.jpa.repository.JpaRepository;
	public interface UserRepository extends JpaRepository<User, Long> {
	}

view raw UserRepository.java hosted with ❤ by GitHub

Service

This layer contains the following services:

• TokenService: This is responsible for providing and managing download tokens. See the Download Token Algorithm above.
• JasperDatasourceService: Wraps a list of objects into a JRBeanCollectionDataSource. This is the datasource for our Jasper reports.
• ExporterService: This is responsible for exporting a Jasper report into different formats, such as Pdf and Excel.
• DownloadService: This is responsible for the actual download requests and writing of reports to the output stream

	package org.krams.service;
	import java.util.HashMap;
	import java.util.UUID;
	import org.springframework.stereotype.Service;
	/**
	* Produces UUID-based tokens. </br>
	* This is inpired by the following article
	* <a href="http://stackoverflow.com/questions/1106377/detect-when-browser-receives-file-download">
	* Detect when browser receives file download</a> from stackoverflow.com. Instead of using a
	* cookie, we use a {@link HashMap} to store the tokens.
	*/
	@Service
	public class TokenService {
	private HashMap<String,String> tokens = new HashMap<String, String>();
	public String check(String token) {
	return tokens.get(token);
	}
	public String generate() {
	String uid = UUID.randomUUID().toString();
	tokens.put(uid, uid);
	return uid;
	}
	public void remove(String token) {
	tokens.remove(token);
	}
	}

view raw TokenService.java hosted with ❤ by GitHub

	package org.krams.service;
	import java.util.ArrayList;
	import java.util.List;
	import net.sf.jasperreports.engine.JRDataSource;
	import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.krams.response.JasperDto;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Service;
	@Service
	public class JasperDatasourceService {
	@Autowired
	private UserRepository repository;
	/**
	* Returns a data source that's wrapped within {@link JRDataSource}
	* @return
	*/
	public JRDataSource getDataSource() {
	List<User> records = repository.findAll();
	List<JasperDto> dtos = new ArrayList<JasperDto>();
	// Map records
	for (User user: records) {
	JasperDto dto = new JasperDto();
	dto.setId(user.getId());
	dto.setUsername(user.getUsername());
	dto.setFirstName(user.getFirstName());
	dto.setLastName(user.getLastName());
	if (user.getRole().getRole() == 1)
	dto.setRole("Admin");
	else
	dto.setRole("Regular");
	dtos.add(dto);
	}
	// Return wrapped collection
	return new JRBeanCollectionDataSource(dtos);
	}
	}

view raw JasperDatasourceService.java hosted with ❤ by GitHub

	package org.krams.service;
	import java.io.ByteArrayOutputStream;
	import javax.servlet.http.HttpServletResponse;
	import net.sf.jasperreports.engine.JRException;
	import net.sf.jasperreports.engine.JRExporterParameter;
	import net.sf.jasperreports.engine.JasperPrint;
	import net.sf.jasperreports.engine.export.JRPdfExporter;
	import net.sf.jasperreports.engine.export.JRXlsAbstractExporterParameter;
	import net.sf.jasperreports.engine.export.JRXlsExporter;
	import org.springframework.stereotype.Service;
	@Service
	public class ExporterService {
	public static final String MEDIA_TYPE_EXCEL = "application/vnd.ms-excel";
	public static final String MEDIA_TYPE_PDF = "application/pdf";
	public static final String EXTENSION_TYPE_EXCEL = "xls";
	public static final String EXTENSION_TYPE_PDF = "pdf";
	public HttpServletResponse export(String type,
	JasperPrint jp,
	HttpServletResponse response,
	ByteArrayOutputStream baos) {
	if (type.equalsIgnoreCase(EXTENSION_TYPE_EXCEL)) {
	// Export to output stream
	exportXls(jp, baos);
	// Set our response properties
	// Here you can declare a custom filename
	String fileName = "UserReport.xls";
	response.setHeader("Content-Disposition", "inline; filename=" + fileName);
	// Set content type
	response.setContentType(MEDIA_TYPE_EXCEL);
	response.setContentLength(baos.size());
	return response;
	}
	if (type.equalsIgnoreCase(EXTENSION_TYPE_PDF)) {
	// Export to output stream
	exportPdf(jp, baos);
	// Set our response properties
	// Here you can declare a custom filename
	String fileName = "UserReport.pdf";
	response.setHeader("Content-Disposition", "inline; filename="+ fileName);
	// Set content type
	response.setContentType(MEDIA_TYPE_PDF);
	response.setContentLength(baos.size());
	return response;
	}
	throw new RuntimeException("No type set for type " + type);
	}
	public void exportXls(JasperPrint jp, ByteArrayOutputStream baos) {
	// Create a JRXlsExporter instance
	JRXlsExporter exporter = new JRXlsExporter();
	// Here we assign the parameters jp and baos to the exporter
	exporter.setParameter(JRExporterParameter.JASPER_PRINT, jp);
	exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, baos);
	// Excel specific parameters
	exporter.setParameter(JRXlsAbstractExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);
	exporter.setParameter(JRXlsAbstractExporterParameter.IS_REMOVE_EMPTY_SPACE_BETWEEN_ROWS, Boolean.TRUE);
	exporter.setParameter(JRXlsAbstractExporterParameter.IS_WHITE_PAGE_BACKGROUND, Boolean.FALSE);
	try {
	exporter.exportReport();
	} catch (JRException e) {
	throw new RuntimeException(e);
	}
	}
	public void exportPdf(JasperPrint jp, ByteArrayOutputStream baos) {
	// Create a JRXlsExporter instance
	JRPdfExporter exporter = new JRPdfExporter();
	// Here we assign the parameters jp and baos to the exporter
	exporter.setParameter(JRExporterParameter.JASPER_PRINT, jp);
	exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, baos);
	try {
	exporter.exportReport();
	} catch (JRException e) {
	throw new RuntimeException(e);
	}
	}
	}

view raw ExporterService.java hosted with ❤ by GitHub

	package org.krams.service;
	import java.io.ByteArrayOutputStream;
	import java.io.InputStream;
	import java.util.HashMap;
	import javax.servlet.ServletOutputStream;
	import javax.servlet.http.HttpServletResponse;
	import net.sf.jasperreports.engine.JRException;
	import net.sf.jasperreports.engine.JasperCompileManager;
	import net.sf.jasperreports.engine.JasperFillManager;
	import net.sf.jasperreports.engine.JasperPrint;
	import net.sf.jasperreports.engine.JasperReport;
	import net.sf.jasperreports.engine.design.JasperDesign;
	import net.sf.jasperreports.engine.xml.JRXmlLoader;
	import org.apache.log4j.Logger;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Service;
	@Service
	public class DownloadService {
	public static final String TEMPLATE = "/users.jrxml";
	protected static Logger logger = Logger.getLogger("service");
	@Autowired
	private JasperDatasourceService datasource;
	@Autowired
	private ExporterService exporter;
	@Autowired
	private TokenService tokenService;
	public void download(String type, String token, HttpServletResponse response) {
	try {
	// 1. Add report parameters
	HashMap<String, Object> params = new HashMap<String, Object>();
	params.put("Title", "User Report");
	// 2. Retrieve template
	InputStream reportStream = this.getClass().getResourceAsStream(TEMPLATE);
	// 3. Convert template to JasperDesign
	JasperDesign jd = JRXmlLoader.load(reportStream);
	// 4. Compile design to JasperReport
	JasperReport jr = JasperCompileManager.compileReport(jd);
	// 5. Create the JasperPrint object
	// Make sure to pass the JasperReport, report parameters, and data source
	JasperPrint jp = JasperFillManager.fillReport(jr, params, datasource.getDataSource());
	// 6. Create an output byte stream where data will be written
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	// 7. Export report
	exporter.export(type, jp, response, baos);
	// 8. Write to reponse stream
	write(token, response, baos);
	} catch (JRException jre) {
	logger.error("Unable to process download");
	throw new RuntimeException(jre);
	}
	}
	/**
	* Writes the report to the output stream
	*/
	private void write(String token, HttpServletResponse response,
	ByteArrayOutputStream baos) {
	try {
	logger.debug(baos.size());
	// Retrieve output stream
	ServletOutputStream outputStream = response.getOutputStream();
	// Write to output stream
	baos.writeTo(outputStream);
	// Flush the stream
	outputStream.flush();
	// Remove download token
	tokenService.remove(token);
	} catch (Exception e) {
	logger.error("Unable to write report to the output stream");
	throw new RuntimeException(e);
	}
	}
	}

view raw DownloadService.java hosted with ❤ by GitHub

The DownloadService is the heart of the download process. The algorithm is as follows:

1. Add report parameters
2. Retrieve template
3. Convert template to JasperDesign
4. Compile design to JasperReport
5. Create the JasperPrint object
6. Create an output byte stream where data will be written
7. Export report
8. Write to reponse stream

Utilities

• JqgridFilter is a Java representation of a jqGrid filter
• JqgridObjectMapper is used to convert a jqGrid filter to a JqgridFilter object
• UserMapper is used to map User objects to UserDto objects
• TraceInterceptor is an AOP-based utility class to help us debug our application. This is a subclass of CustomizableTraceInterceptor. See Spring Data JPA FAQ

Note: We won't display the contents of JqgridFilter, JqgridObjectMapper, UserMapper, and TraceInterceptor here since we've already discussed them on a different tutorial. See Spring Data JPA FAQ

Next

In the next section, we will create the Jasper report layout and design it using iReport. Click here to proceed.

---

Share the joy: blogger tutorials Social Bookmarking Blogger Widget I'm reading: Spring MVC 3.1 and JasperReports: Using iReport and AJAX (Part 2) ~

Subscribe by reader Subscribe by email Share