Code4java: November 2015

Thursday, 26 November 2015

Procedure Call Using Jasper Reports ,Spring MVC

Hello friends.today i am going to demonstrate you how we can call procedure through Jasper reports.

The Project Structure is given below :

The Code is as given below.

MODEL CLASS

package org.demo.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="student")
public class Student
{

@Id @Column(name="id")
private String studentid;
@Column
private String name;

public Student(){}
public String getStudentid() {
return studentid;
}

public void setStudentid(String studentid) {
this.studentid = studentid;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

CONTROLLER:

package org.demo.controller;

import java.sql.SQLException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.validation.Validator;

import org.apache.commons.dbcp.BasicDataSource;

import org.dao.StudentDAO;

import org.demo.model.Student;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.validation.BindingResult;

import org.springframework.validation.annotation.Validated;

import org.springframework.web.bind.annotation.ModelAttribute;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller

public class StudentController

{

@RequestMapping(value="/show_student", method=RequestMethod.GET)

public String showStudent(@ModelAttribute("student1") Student student) {

return "show_student";

}

@RequestMapping(method = RequestMethod.POST , value = "/GenerateReport")

public @ResponseBody void generatePdfReport(ModelAndView modelAndView,HttpServletRequest request,HttpServletResponse response) throws SQLException{

WebApplicationContext context =WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());

StudentDAO dao=(StudentDAO)context.getBean("studentDAO");

BasicDataSource dataSource = (BasicDataSource)context.getBean("myDataSource");

String contextPath = request.getServletContext().getRealPath("report/StudentReport.jrxml");

dao.generatePdfReport(dataSource,contextPath);

}

DAO LAYER:

package org.dao;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.sql.Connection;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import net.sf.jasperreports.engine.JasperCompileManager;

import net.sf.jasperreports.engine.JasperExportManager;

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.query.JRQueryExecuterFactory;

import net.sf.jasperreports.engine.util.JRProperties;

import net.sf.jasperreports.engine.xml.JRXmlLoader;

import org.apache.commons.dbcp.BasicDataSource;

import org.codehaus.jackson.map.ObjectMapper;

import org.demo.model.Student;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;

import org.springframework.jdbc.core.namedparam.SqlParameterSource;

import org.springframework.jdbc.core.simple.SimpleJdbcCall;

import org.springframework.orm.hibernate3.HibernateTemplate;

@SuppressWarnings("deprecation")

public class StudentDAO {

private HibernateTemplate template;

@Autowired

private BasicDataSource myDataSource;

public HibernateTemplate getTemplate() {

return template;

}

public void setTemplate(HibernateTemplate template) {

this.template = template;

}

public StudentDAO(HibernateTemplate template) {

this.template = template;

}

public void insert(Student student) {

template.save(student);

}

public List<Student> getStudents() {

return template.find("from student");

}

public void generatePdfReport(BasicDataSource dataSource, String contextPath)

throws SQLException {

Connection conn = dataSource.getConnection();

try {

InputStream input = new FileInputStream(new File(contextPath));

System.out.println("Context Path is : =" + contextPath);

JasperDesign jasperDesign = JRXmlLoader.load(input);

System.out.println("Compiling Report Designs");

JasperReport jasperReport = JasperCompileManager

.compileReport(jasperDesign);

jasperReport.setProperty(

"net.sf.jasperreports.query.executer.factory.plsql",

"com.jaspersoft.jrx.query.PlSqlQueryExecuterFactory");

JRProperties.setProperty(

JRQueryExecuterFactory.QUERY_EXECUTER_FACTORY_PREFIX

+ "plsql",

"com.jaspersoft.jrx.query.PlSqlQueryExecuterFactory");

System.out.println("Creating JasperPrint Object");

Map<String, Object> parameters = new HashMap<String, Object>();

parameters.put("studId", "1");

JasperPrint jasperPrint = JasperFillManager.fillReport(

jasperReport, parameters, conn);

int pages=jasperPrint.getPages().size();

if(pages != 0)

{

File f = new File("d:\\Studentnew.pdf");

f.createNewFile();

// Exporting the report

OutputStream output = new FileOutputStream(f);

JasperExportManager.exportReportToPdfStream(jasperPrint, output);

System.out.println("Report Generation Complete");

}

else

{

System.out.println(" NO DATA FOUND TO EXPORT .....");

}

conn.close();

} catch (Exception e) {

e.printStackTrace();

}

public void callStoredProcedure(BasicDataSource datasource) {

ObjectMapper m = new ObjectMapper();

JdbcTemplate template = new JdbcTemplate(datasource);

SimpleJdbcCall simpleJdbcCall = new SimpleJdbcCall(template)

.withProcedureName("getStudent");

Map<String, Object> inParamMap = new HashMap<String, Object>();

inParamMap.put("int_stockcode", 1);

SqlParameterSource in = new MapSqlParameterSource(inParamMap);

Map<String, Object> simpleJdbcCallResult = simpleJdbcCall.execute(in);

System.out.println(simpleJdbcCallResult);

System.out.println(simpleJdbcCallResult.get("name"));

// Student anotherBean = m.convertValue(simpleJdbcCallResult,

// Student.class);

// System.out.println(anotherBean.getStudentid());

// System.out.println(anotherBean.getName());

Iterator iterator = simpleJdbcCallResult.entrySet().iterator();

while (iterator.hasNext()) {

Student student = new Student();

* student.setStudentid((String)simpleJdbcCallResult.get("id"));

* student.setName((String)simpleJdbcCallResult.get("name"));

* System.out.println("st5udent : =>"+student.getName());

* System.out.println("The key is: " + mapEntry.getKey() +

* ",value is :" + mapEntry.getValue());

}

public static void main(String[] args) {

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(

"/context-conf.xml");

BasicDataSource datasource = (BasicDataSource) context

.getBean("myDataSource");

StudentDAO dao = (StudentDAO) context.getBean("studentDAO");

dao.callStoredProcedure(datasource);

}

WEB.XML

<?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" 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>ProcCallJasperSpring</display-name>

<welcome-file-list>

<welcome-file>add_student.jsp</welcome-file>

</welcome-file-list>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>WEB-INF/context-conf.xml</param-value>

</context-param>

<servlet-name>dispatcher</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>dispatcher</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

context-conf.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"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc.xsd

http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd"

</bean>

<bean id="mySessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<list>

<value>org.demo.model.Student</value>

</list>

</property>

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

</props>

</property>

</bean>

<constructor-arg ref="mySessionFactory" />

</bean>

<constructor-arg ref="hibernateTemplate" />

</bean>

<bean id="messageSource"

class="org.springframework.context.support.ReloadableResourceBundleMessageSource">

</bean>

</beans>

InitStudent.js

function InitStudent()

{

$('#AddStudent').click(function()

{

AddStudent();

});

$('#GenerateReport').click(function()

{

GenerateReport();

});

}

StudentLogic.js

function AddStudent()

{

$.ajax({

url: "add_student.html",

dataType:'json',

type:'post',

data: $('#StudentDetail').serialize(),

beforeSend: function() {

$.blockUI();

success: function (dataCheck)

{

error: function (xhr, ajaxOptions, thrownError) {}

});

}

function GenerateReport()

{

$.ajax({

url: "GenerateReport.html",

dataType:'json',

type:'post',

data: {},

beforeSend: function() {

$.blockUI();

success: function (dataCheck)

{

error: function (xhr, ajaxOptions, thrownError) {}

});

}

add_student.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<%@ taglib uri="http://www.springframework.org/tags/form"

prefix="springForm"%>

<html>

<head>

<title>ADD STUDENT FORM </title>

<style>

.error {

color: #ff0000;

font-style: italic;

font-weight: bold;

}

</style>

</head>

$(document).ready(function(){

InitStudent();

});

</script>

<body>

<%-- <springForm:form method="POST" commandName="student"

action="ValidateRequest"> --%>

<table>

<tr>

<%-- <td><springForm:errors path="txtid" cssClass="error" /></td> --%>

</tr>

<tr>

<%-- <td><springForm:errors path="txtname" cssClass="error" /></td> --%>

</tr>

<tr>

</tr>

</table>

</body>

</html>

Procedure that i call from Java code is given below :

DELIMITER $$

DROP PROCEDURE IF EXISTS `getStudent` $$

CREATE DEFINER=`root`@`localhost` PROCEDURE `getStudent`(studid VARCHAR(20))

BEGIN

SELECT id,name,college FROM student WHERE id = studid;

END $$

DELIMITER ;

Report will look like given below :

Happy Learning..!!

for any query ping me on pathak.nisarg@yahoo.com

Thanks for Reading..!

Saturday, 14 November 2015

Spring Batch Xml Generation

Hi Friends ,i will going to demosntrate how we can generate xml using spring batch application .

In this example i have used maven project structure ,

Project Structure is look like given below

The Code is as given below :
database script ::

(1)

DROP TABLE IF EXISTS `studentdb`.`batchstrn`;
CREATE TABLE `studentdb`.`batchstrn` (
`BATCHRUNID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`BATCHID` int(10) unsigned NOT NULL,
`REQDATE` datetime NOT NULL,
`PROCSTARTDATE` datetime NOT NULL,
`STATUSCODE` varchar(45) NOT NULL,
PRIMARY KEY (`BATCHRUNID`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1;

Main Class :
package org.zip;

import java.util.HashMap;
import java.util.Map;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameter;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
//@Component
public class App {

public static void main(String[] args) {

App obj = new App();
obj.run();

}
//batchstrn
private void run() {

String[] springConfig = { "spring/batch/jobs/student_excelList.xml" };

ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);

JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
Job job = (Job) context.getBean("XML_GEN");

Map<String, JobParameter> mapofParam = new HashMap<String, JobParameter>();

mapofParam.put("BATCHID", new JobParameter("3"));

JobParameters jobparam= new JobParameters(mapofParam);

try {

JobExecution execution = jobLauncher.run(job, jobparam);
System.out.println("Exit Status : " + execution.getStatus());
System.out.println("Exit Status : " + execution.getAllFailureExceptions());

} catch (Exception e) {
e.printStackTrace();

}

System.out.println("Done");

}

}

The Configuration file for job is as given below :

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

<context:annotation-config />
<context:component-scan base-package="org.batch" />

<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/studentdb" />
<property name="username" value="root" />
<property name="password" value="admin!@#" />
</bean>

<bean id="readListener" class="org.batch.listener.XmlReadListener" />

<batch:job id="XML_GEN" >
<batch:step id="XML_GEN_STEP1" next="XML_GEN_STEP2">
<batch:tasklet ref="XML_GEN_batchinit" >

</batch:tasklet>
</batch:step>

<batch:step id="XML_GEN_STEP2" >
<batch:tasklet>
<batch:chunk reader="XML_GEN_itemreader" writer="XML_GEN_itemwriter"
processor="XML_GEN_itemprocessor" commit-interval="10">

<batch:listeners>
<batch:listener ref="readListener"/>
</batch:listeners>
</batch:chunk>
</batch:tasklet>
</batch:step>

</batch:job>


<bean id="XML_GEN_batchinit" class="org.batch.tasklet.Student_InitTasklet"
scope="step">
<property name="batchId" value="#{jobParameters['BATCHID']}" />

</bean>


<bean id="XML_GEN_itemreader"
class="org.springframework.batch.item.database.JdbcCursorItemReader"
scope="step">
<property name="dataSource" ref="dataSource" />
<property name="sql"
value="select * from student where status='A'"
/>
<property name="rowMapper">
<bean class="org.batch.mapper.Student_RowMapper" />
</property>
</bean>


<bean id="XML_GEN_itemprocessor" class="org.batch.processor.Student_Processor"
scope="step" >

<property name="batchRunId" value="#{jobExecutionContext['BATCHRUNID']}" />

</bean>


<bean id="XML_GEN_itemwriter" class="org.batch.writer.StudentGeneration_Writer" scope="step">
<property name="dataSource" ref="dataSource" />
<property name="batchRunId" value="#{jobExecutionContext['BATCHRUNID']}" />
</bean>

<bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository"/>
</bean>

<bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name="transactionManager" ref="transactionManager"/>
</bean>

<bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager
"/>

</beans>

CONTEXT.XML

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">


<bean id="jobRepository"
class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name="transactionManager" ref="transactionManager" />
</bean>

<bean id="transactionManager"
class="org.springframework.batch.support.transaction.ResourcelessTransactionManager" />

<bean id="jobLauncher"
class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository" />
</bean>



<bean id="envProperties"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:META-INF/i18n/zip-batch.properties</value>
</list>
</property>
</bean>

</beans>

PROCESSOR:

package org.batch.processor;

import org.batch.model.Student;

import org.springframework.batch.item.ItemProcessor;

public class Student_Processor implements ItemProcessor<Student, Student> {

private int batchRunId;

@Override

public Student process(Student stdent) throws Exception {

// TODO Auto-generated method stub

return stdent;

}

public int getBatchRunId() {

return batchRunId;

}

public void setBatchRunId(int batchRunId) {

this.batchRunId = batchRunId;

}

WRITER :

package org.batch.writer;

/*import org.apache.commons.beanutils.PropertyUtils;*/

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import javax.sql.DataSource;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.batch.model.Student;

import org.springframework.batch.core.ExitStatus;

import org.springframework.batch.core.StepExecution;

import org.springframework.batch.core.StepExecutionListener;

import org.springframework.batch.item.ItemWriter;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.w3c.dom.Attr;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

public class StudentGeneration_Writer implements ItemWriter<Student>,StepExecutionListener{

private JdbcTemplate jdbcTemplate;

int batchRunId;

@Autowired

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

@Override

public ExitStatus afterStep(StepExecution stepExecution) {

// TODO Auto-generated method stub

String sqlUpdate="UPDATE batchstrn SET STATUSCODE='S' WHERE BATCHRUNID=?";

jdbcTemplate.update(sqlUpdate,batchRunId);

return ExitStatus.COMPLETED;

}

@Override

public void beforeStep(StepExecution arg0) {

// TODO Auto-generated method stub

}

@Override

public void write(List<? extends Student> studentList) throws Exception {

// TODO Auto-generated method stub

List<Student> listStudent = new ArrayList<Student>();

for(Student dto:studentList)

{

Student studentObj = new Student();

studentObj.setId(dto.getId());

studentObj.setName(dto.getName());

studentObj.setCollege(dto.getCollege());

studentObj.setStatus(dto.getStatus());

listStudent.add(studentObj);

}

createXml(listStudent);

}

public int getBatchRunId() {

return batchRunId;

}

public void setBatchRunId(int batchRunId) {

this.batchRunId = batchRunId;

}

//new

public static void createXml(List<? extends Student> studentList)

{

private String id ;

private String name;

private String college;

private String status;

try {

DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

// root elements

Document doc = docBuilder.newDocument();

Element rootElement = doc.createElement("college");

doc.appendChild(rootElement);

// staff elements

for (Student student : studentList) {

Element staff = doc.createElement("Student");

rootElement.appendChild(staff);

// set attribute to staff element

Attr attr = doc.createAttribute("id");

attr.setValue(student.getId());

staff.setAttributeNode(attr);

Element firstname = doc.createElement("name");

firstname.appendChild(doc.createTextNode(student.getName()));

staff.appendChild(firstname);

Element lastname = doc.createElement("college");

lastname.appendChild(doc.createTextNode(student.getCollege()));

staff.appendChild(lastname);

Element nickname = doc.createElement("status");

nickname.appendChild(doc.createTextNode(student.getStatus()));

staff.appendChild(nickname);

// write the content into xml file

TransformerFactory transformerFactory = TransformerFactory.newInstance();

Transformer transformer = transformerFactory.newTransformer();

DOMSource source = new DOMSource(doc);

StreamResult result = new StreamResult(new File("D:\\file.xml"));

// Output to console for testing

// StreamResult result = new StreamResult(System.out);

transformer.transform(source, result);

System.out.println("File saved!");

}

catch (Exception pce) {

pce.printStackTrace();

}

THANKS for reading this article.for any query ping me on pathak.nisarg@yahoo.com

Happy Learning!!

Code4java

Thursday, 26 November 2015

Procedure Call Using Jasper Reports ,Spring MVC

Saturday, 14 November 2015

Spring Batch Xml Generation

Spring Boot SSL configuration -Tomcat Server

Translate

Total Pageviews