Here’s an excerpt:

A San Francisco cable car holds 60 people. This blog was viewed about 2,800 times in 2011. If it were a cable car, it would take about 47 trips to carry that many people.

Click here to see the complete report.

Normally, people load them like

ApplicationContext context =
new ClassPathXmlApplicationContext(new String[] {“springConfig-delegate.xml”,”springConfig-service.xml”,”springConfig-dao.xml”});

This is not a good practice when we have the provision to organize all our spring configuration files into a single XML file & load it.

Create a single spring config file names “springConfig.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-2.5.xsd">

	<import resource="common/Spring-Common.xml"/>
        <import resource="connection/Spring-Connection.xml"/>
        <import resource="moduleA/Spring-ModuleA.xml"/>

</beans>

and then load it like

ApplicationContext context =
new ClassPathXmlApplicationContext(springConfig.xml);

There are 5 auto-wiring modes in spring

1. no – Default, no auto wiring, set it manually via “ref” attribute
2. byName – Auto wiring by property name. If the name of a bean is same as the name of other bean property, auto wire it.
3. byType – Auto wiring by property data type. If data type of a bean is compatible with the data type of other bean property, auto wire it.
4. constructor – byType mode in constructor argument.
5. autodetect – If a default constructor is found, use “autowired by constructor”; Otherwise, use “autowire by type”.

Hope the following examples will help you understand auto-wiring much better

Consider the following classes – Customer.java and Person.java

public class Customer {
        private Person person;

        public Customer(Person person) {
            this.person = person;
        }

        public void setPerson(Person person) {
            this.person = person;
        }
    }

    public class Person {
        // some code..
    }

1. NO

This is the default mode. We have to use <ref> tag here

<bean id=”customer” class=”de.suhas.Customer” autowire=”constructor” />

<bean id=”person” class=”de.suhas.Person” />

5. autodetect

Tip : It’s always good to combine both ‘auto-wire’ and ‘dependency-check’ together, to make sure the property is always auto-wire successfully.

<bean id="customer" class="de.suhas.Customer"
			autowire="autodetect" dependency-check="objects />
<bean id="person" class="de.suhas.Person" />

In order to explain them, let us consider a simple example -

public class Shape {

int x= 10;

void draw() {
System.out.println(“Shape”);
}
}

and

public class Circle extends Shape{

int x=5;

void draw(){
System.out.println(“Circle”);
}
}

You might have noticed that class Circle is inheriting the class Shape and both classes have the same member variable and the method draw() is overridden in class Circle.

Dynamic Binding / Run Time Polymorphism / Late Binding

Consider the following Test class

public class Test{

public static void main(String[] args) {
Shape shape = new Circle();
shape.draw(); // DYNAMIC BINDING
System.out.println(shape.x); // STATIC BINDING
}
}

Shape shape = new Circle()

This is alright as Shape is the parent class of Circle.

Now if we call shape .draw(); then it the draw method in circle will be executed.

Note: The type of the object that is assigned to the Animal variable determines the method that is called.

But when the compiler sees this draw() command, it knows that shape object is of type Shape, but the compiler also knows that shape object can be a reference to any class derived from Shape. Therefore, the compiler doesn’t know what version of draw() that statement is calling. It will only know it upon reaching the execution of that statement at runtime.

Static binding/ Compile time polymorphism / early binding

In some cases, the compiler can readily determine the correct version of something during compile time.

In Java, member variables have static binding because Java does not allow for polymorphic behavior with member variables. That means if both the Shape class and the Circle class have a member variable with the same name, it’s the base class version that is used.

In the above test class,    System.out.println(shape.x);  will print the value of x in class Shape.

Test Setup : Define and Create all the Data and Objects you need for the tests
Expectations : Say what methods and parameters you expect to be executed during the test
Test : The actual behavior/method call you want to test
Assertions : Statements that make sure the outcome of the test were successful
Test Tear down : Destroy any side effects that occurred during the test

jUnit is a Unit Testing Framework and provides all but the Expectations phase of testing.

The concept of mocking is what added the new phase of Expectations, and since jUnit saw most of it’s major development prior to the mocking movement, those features were not incorporated into the core, and a set of tools to fill that gap in the java space have opened up. Those libraries include

EasyMock
jMock
jMockIt

All of these libraries are compliments to any of the above Unit Testing frameworks I listed, including jUnit. They add the ability to define mock objects. Mock objects get “expectations” assigned to them, which are then asserted in the Assertions phase. Each Mock library accomplishes this slightly differently, but the major models are

Record Replay – EasyMock
Expectations – jMock, jMockIt

Sample EASYMOCK Program to calculate employee salary and bonus

Salary class has to find out the employee salary and bonus but the business logic resides in FinanceDepartment.java

public interface IFinanceDepartment {

public long calculateSalary(long days);

public long calculateBonus(long employeeRating);

}

public class FinanceDepartment implements IFinanceDepartment {

@Override
public long calculateBonus(long employeeRating) {
return employeeRating * 5000;
}

@Override
public long calculateSalary(long days) {
return days * 45;
}

}

public class  Salary {

private IFinanceDepartment financeDepartment;

public IFinanceDepartment getFinanceDepartment() {
return financeDepartment;
}

public void setFinanceDepartment(IFinanceDepartment financeDepartment) {
this.financeDepartment = financeDepartment;
}

public Long calculateSalary(Long days) {
return financeDepartment.calculateSalary(days);
}

public Long calculateBonus(Long employeeRating) {
return financeDepartment.calculateBonus(employeeRating);
}

}

Now let’s write a EasyMock Test Case

import junit.framework.TestCase;

import org.easymock.EasyMock;
import org.junit.BeforeClass;
import org.junit.Test;

public class SalaryEasyMockTest extends TestCase {

private IFinanceDepartment financeDepartment;

private Salary salary;

@BeforeClass
public void setUp() throws Exception {
financeDepartment = EasyMock.createMock(IFinanceDepartment.class);
salary = new Salary();
salary.setFinanceDepartment(financeDepartment);
}

Limitations of EasyMock

• Cannot mock static methods

• Cannot mock private methods

• Cannot mock final methods

• Cannot mock concrete classes

• Cannot mock Constructors

Prerequisites for this tutorial

1. Download and install iReports from http://jasperforge.org/projects/ireport                      (We use this to create the report template/layout) and this website will give you a  very very clear idea on how to design a report template. Trust me, its easy. It’s easy to understand it from their own website rather me trying to explain it in words.
2. Download and install MySQL
3. Have the following jar files in your classpath

commons-beanutils-1.7.jar

commons-collections-3.1.jar

commons-digester-1.8.jar

commons-lang-2.1.jar

commons-logging-1.1.jar

iText-2.1.1.jar

jasperreports-1.0.3.jar

mysql-connector-java-5.0.4-bin.jar

Note: The template that we create using iReport tool will be saved with extension .jrxml

Create a folder jrxml in your project and save/copy the template you designed here.

Create a folder report in your project and this is where your PDF/EXCEL report will be saved

Before we go further, we need to populate the data in the database so that we can fetch it and display it on the report. (Who would like to see a empty PDF report? In case, if you get a empty PDF report, then your must have forgotten to  add iText-2.1.1.jar to the classpath..provided your query works)

Execute the following scripts in MySQL Browser

create table Employee(
ID                 VARCHAR(4) NOT NULL,
First_Name         VARCHAR(10),
Last_Name          VARCHAR(10),
Start_Date         DATE,
End_Date           DATE,
Salary             DECIMAL(8,2),
City               VARCHAR(10),
Description        VARCHAR(15)
)

INSERT into Employee values
(’06′,’Suhas’,'Saheer’,
to_date(’20071213′,’YYYYMMDD’),
to_date(’20701213′,’YYYYMMDD’),
52500.56,
‘MUNICH’,
‘Programmer’)

Since this is your first application, lets make it simple.
We need to fetch the first_name and last_name from the employee table and show it on a PDF report named EmployeeReport.pdf

So the query for fetching the records to be displayed on the report is

select First_Name, Last_Name from employee e

Where to we need to provide this query?
Either we can provide it in the .jrxml file we created or in our invoking method(java class)

In this tutorial, we are talking about the case where we mention the query in the .jrxml file itself

EmployeeReport.jrxml

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE jasperReport PUBLIC “//JasperReports//DTD Report Design//EN”
“http://jasperreports.sourceforge.net/dtds/jasperreport.dtd”>
<jasperReport name=”EmployeeReport_SuhasJavaBlog”>
<queryString>
<![CDATA[select First_Name, Last_Name from employee e]]>
</queryString>
<field name=”First_Name” />
<field name=”Last_Name” />
<title>
<band height=”50″>
<staticText>
<reportElement x=”0″ y=”0″ width=”180″ height=”15″/>
<textElement/>
<text><![CDATA[Jasper Report - SuhasJavaBlog]]></text>
</staticText>
</band>
</title>
<pageHeader>
<band height=”30″>
<staticText>
<reportElement x=”0″ y=”0″ width=”69″ height=”24″ />
<textElement verticalAlignment=”Bottom” />
<text>
<![CDATA[First Name: ]]>
</text>
</staticText>
<staticText>
<reportElement x=”140″ y=”0″ width=”79″ height=”24″ />
<text>
<![CDATA[Last Name: ]]>
</text>
</staticText>
</band>
</pageHeader>
<detail>
<band height=”30″>
<textField>
<reportElement x=”0″ y=”0″ width=”69″ height=”24″ />
<textFieldExpression>
<![CDATA[$F{First_Name}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x=”140″ y=”0″ width=”69″ height=”24″ />
<textFieldExpression>
<![CDATA[$F{Last_Name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

Note the highlighted text in the above template. (Thats our SQL query to fetch the records)

Now let’s take a look the Java code for generating the report. (We use Jasper API for this)

1. Establish a connection to the MySQL database :

Class.forName(“com.mysql.jdbc.Driver”);
conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/test?user=root&password=root”);

2. Read the .jrxml report template you have designed and create a JasperDesign Object which represent the report design :

InputStream input = new FileInputStream(new File(“jrxml/BasicReport.jrxml”));
JasperDesign jasperDesign = JRXmlLoader.load(input);

3. Now compile the report design file to create a JasperReport object. The compilation of the report design file validates the JasperReports XML file (EmployeeReport.jrxml) with the jaspereports.dtd DTD and converts the report expressions into a ready-to-evaluate form :

JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);

4. To view this, generate a JasperPrint document, which may be viewed, printed or exported to other formats, from the compiled report design :

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, conn);

In this example,  we don’t have any parameters to pass.

Hence we re-write this as

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, null, conn);

5. A JasperReports report may be exported to a XML file, a PDF file, an HTML file, a CSV file, or an Excel XLS file; to export the JasperReports report we’ve just generated to a PDF file, use this:

 OutputStream output = new FileOutputStream(new File(“jrxml/EmployeeReport.pdf”));
JasperExportManager.exportReportToPdfStream(jasperPrint, output);

That’s it. You have done it. You just need to execute this method and you have your report ready under the ‘reports’ folder in your project

ReportGenerator.java

package de.suhas.jasper;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRResultSetDataSource;
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.xml.JRXmlLoader;

public class ReportGenerator {

Connection conn;

public void generateReport() {

try {
Class.forName(“com.mysql.jdbc.Driver”);
conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/test?user=root&password=root”);
System.out.println(“Loading Report Designs”);
InputStream input = new FileInputStream(new File(“jrxml/BasicReport.jrxml”));
JasperDesign jasperDesign = JRXmlLoader.load(input);

System.out.println(“Compiling Report Designs”);
JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);

System.out.println(“Creating JasperPrint Object”);
Map<String, String> parameters = new HashMap<String, String>();
parameters.put(“ReportTitle”, “PDF JasperReport”);

System.out.println(“Filling Report to File”);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, null, conn);

//Exporting the report
OutputStream output = new FileOutputStream(new File(“jrxml/catalog.pdf”));
JasperExportManager.exportReportToPdfStream(jasperPrint, output);

System.out.println(“Report Generation Complete”);
conn.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (JRException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
new ReportGenerator().generateReport();
}
}

Hope you guys have understood the art of creating reports using Jasper API and iReports.

Would love to hear from you guys if this was the slightest help to you.
Also feel free to drop in a reply for any queries related to Jasper Reports

]]> http://suhasjavablog.wordpress.com/2011/11/23/jasper-reports-tutorial/feed/ 0 ShamanOfJava http://suhasjavablog.wordpress.com/2011/11/20/linkedlist-vs-arraylist/ http://suhasjavablog.wordpress.com/2011/11/20/linkedlist-vs-arraylist/#comments Sun, 20 Nov 2011 05:31:43 +0000 ShamanOfJava http://suhasjavablog.wordpress.com/?p=453 ]]> Let’s first take a look at the interfaces which the ArrayList and LinkedList implement.

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable,Serializable
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Queue<E> Cloneable, Serializable

ArrayList

Now for some implementation notes. The ArrayList is actually encapsulating an actualy Array, an Object[]. When you instanciate ArrayList, an array is created, and when you add values into it, the array changes its size accordingly. This gives you strengths and weaknesses:

• Fast Random Access

You can perform random access without fearing for performence. Calling get(int) will just access the underlying array

• Adding values might be slow When you don’t know the amount of values the array will contain when you create it, a lot of shifting is going to be done in the memory space when the ArrayList manipulates its internal array.
• Slow manipulation When you’ll want to add a value randomly inside the array, between two already existing values, the array will have to start moving all the values one spot to the right in order to let that happen.

LinkedList

The LinkedList is implemented using nodes linked to each other. Each node contains aprevious node link, next node link, and value, which contains the actual data. When new data is inserted, a node is inserted and the links of the surrounding nodes are updated accordingly. When one is removed, the same happens – The surrounding nodes are changing their links and the deleted node is garbage collected. This, as well, gives strengths and weaknesses:

• Fast manipulation As you’d expect, adding and removing new data anywhere in the list is instantanious. Change two links, and you have a new value anywhere you want it.
• No random access Even though the get(int) is still there, it now just iterates the list until it reaches the index you specified. It has some optimizations in order to do that, but that’s basically it.

]]> http://suhasjavablog.wordpress.com/2011/11/20/linkedlist-vs-arraylist/feed/ 0 ShamanOfJava http://suhasjavablog.wordpress.com/2011/11/18/abstraction-encapsulation/ http://suhasjavablog.wordpress.com/2011/11/18/abstraction-encapsulation/#comments Fri, 18 Nov 2011 10:52:12 +0000 ShamanOfJava http://suhasjavablog.wordpress.com/?p=436 ]]> Abstraction is only giving essential details w/o any background information.

This is achieved in java by
1) Abstract Class and Interface //We don’t know the function implementation of code until unless at run time or we have a information about the class which implementing this Interface or Extends this Abstract Class If we click on this method it directly take us to Interface method not to Class which actually implementing this method.
2) Hiding information by access modifier only give access to required
3) Object - Nothing can be accessed by Object ref.

Encapsulation protects abstractions. Encapsulation is the bodyguard; abstraction is the VIP.

A real world example,

consider u have setup a big building(say a company), the details regarding materials used to built (glass, bricks), type of work, manager of the company, number of floors, design of the building, cost of the building etc. can be classified as ABSTRACTION.

Whereas, type of glass or bricks(grey one or red one) used, who all work for which all departments n how they work, cost of each and every element in the building etc. comes under Data ENCAPSULATION.

Another example can be of a VIP(Abstraction) and his assistant(Encapsulation).

]]> http://suhasjavablog.wordpress.com/2011/11/18/abstraction-encapsulation/feed/ 0 ShamanOfJava http://suhasjavablog.wordpress.com/2011/11/18/difference-between-iterator-and-enumeration-interface/ http://suhasjavablog.wordpress.com/2011/11/18/difference-between-iterator-and-enumeration-interface/#comments Fri, 18 Nov 2011 10:43:31 +0000 ShamanOfJava http://suhasjavablog.wordpress.com/?p=434 ]]> Both Iterator and Enumeration are used to traverse Collection objects, in a sequential fashion.  Enumeration can be applied to Vector and HashTable. Iterator can be used with most of the Collection objects.

The main difference between the two is that Iterator is fail-safe. i.e,  If you are using an iterator to go through a collection you can be sure of no concurrent modifications in the underlying collection which may happen in multi-threaded environments.

Enumeration is twice as fast as Iterator and uses very less memory.

Vector <String> aVector = new Vector<String>();
aVector.add(“I”);
aVector.add(“am”);
aVector.add(“really”);
aVector.add(“good”);
Enumeration<String> e = aVector.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}

]]> http://suhasjavablog.wordpress.com/2011/11/18/difference-between-iterator-and-enumeration-interface/feed/ 0 ShamanOfJava http://suhasjavablog.wordpress.com/2011/11/17/few-tips-for-constructor-based-dependency-injection/ http://suhasjavablog.wordpress.com/2011/11/17/few-tips-for-constructor-based-dependency-injection/#comments Thu, 17 Nov 2011 09:06:47 +0000 ShamanOfJava http://suhasjavablog.wordpress.com/?p=407 ]]> Why should one go for Constructor-based dependency Injection?

1. Best to use for a bean with one or two properties.
2. Less LOC as there are no setters, just one constructor method.
3. Facilitates ‘immutable’ property

Prefer ‘type’ over ‘index’ while you go for constructor-based dependency injection

Instead of:

<bean id="billingService">
<constructor-arg index="0" value="lizjason"/>
<constructor-arg index="1" value="100"/>
</bean>

It is better to use the type attribute like this:

<bean id="billingService">
<constructor-arg type="java.lang.String" value="lizjason"/>
<constructor-arg type="int" value="100"/>
</bean>

]]> http://suhasjavablog.wordpress.com/2011/11/17/few-tips-for-constructor-based-dependency-injection/feed/ 0 ShamanOfJava