<bean
id=”myBeanInstance”
class=”com.xyx.PrototypeBeanExample”
scope=”prototype”
autowire=”byName”>

</bean>

it means that every time a request for this bean is made, a new instance is created. If you want to see the illustration

Prototype bean in Spring

Prototype is meant for beans which hold some state.

The  bean lifecycle also changes in prototype bean. From Spring’s doc

Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, decorates and otherwise assembles a prototype object, hands it to the client and then has no further knowledge of that prototype instance

Basic Checks on dbase:

Make sure to check following with respects to the tables / database in question:

• Latest Database statistics exists for the tables in question.
• Indexes
• Degree of Parallelism at Table Level:
• Optimizer mode

Database configuration parameters  – sga_max_size,  pga_aggregate_target , memory_target, processes

Solutions tried

• Multiple tests were performed, taken explain plan and auto trace, which showed that query is taking time in SQL Net and it has higher waits on this layer.
• When we run query on the server hosting oracle (A) it is much faster as compare to running from the clients machine(C).
• Use of optimizer hints and parallelism is not helping any speed-up in the query.
• Changes in the database configuration parameters and tuning SQL Net does not help.

Resolution

• From the clients machine, using SQLPLUS – Changed the “ARRAYSIZE” parameter to 5000 (from default 15) – This reduces the query time to about 1 min from 45 min.
• For Java based front end – changed the “setdefaultrowfetch” to 5000 and query time is reduced to ~35s.

Understanding the issue

JDBC drivers’ default fetch size is 10. In normal JDBC programming if you want to retrieve 100 rows, it requires 10 network round trips between your application and database server to transfer all data. Definitely this will impact your application response time. The reason is JDBC drivers are designed to fetch small number of rows from database to avoid any out of memory issues.

Important : Do not make fetch size too big. The fetch size should be based on your JVM heap memory setting. Too large a fetch size will lead to out of memory issues on application server, esp if you are on hosted environment.

Here is sample code to explain fetch size implication

We  have a web application using Hibernate (with JPA ) and Spring. This application relies on Spring for transaction, bean initialization / injection etc. EntityManager, transaction are configured in application.xml file. When integrating Hibernate search in such an application one might face problems. In this post I am sharing some problems I faced during integration and the solution I found.

entitymanager configuration in my application.xml

Spring configuration:
<bean id=”propertyConfigurer”>
<property name=”location” value=”classpath:myproperties.properties”/>
</bean>

<bean id=”dataSource” destroy-method=”close”>
<property name=”driverClass” value=”${db.driverClass}”/>
<property name=”jdbcUrl” value=”${db.url}”/>
<property name=”user” value=”${db.username}”/>
<property name=”password” value=”${db.password}”/>
<property name=”minPoolSize” value=”2″/>
<property name=”maxPoolSize” value=”8″/>
<property name=”breakAfterAcquireFailure” value=”false”/>
<property name=”acquireRetryAttempts” value=”3″/>
<!– property name=”idleConnectionTestPeriod” value=”300″ –>
<property name=”testConnectionOnCheckout” value=”true”/>
</bean>

<bean id=”entityManager”
p:dataSource-ref=”dataSource”>
<property name=”persistenceUnitName” value=”defaultManager” />
<property name=”jpaVendorAdapter”>
<bean>
<property name=”database” value=”${jpa.database}”/>
<property name=”showSql” value=”${jpa.showSql}”/>
</bean>
</property>
</bean>

<bean id=”transactionManager”
p:entityManagerFactory-ref=”entityManager”/>

In the base DAO, I have  entityManager  as class level variable, value to which will be injected by spring:

@PersistenceContext(unitName = “defaultManager”)
private EntityManager entityManager;
For Hibernate search we need FullTextEntityManager. This instance of FullTextEntityManager  will be created using entityManager as below:
fullTextEntityManager = Search.getFullTextEntityManager(entityManager);

To make fullTextEntityManager available for search in the DAO class , I creates a class level variable fullTextEntityManager and  initialized this in @postConstruct method (after entityManager injection) as below.
@PersistenceContext(unitName = “defaultManager”)
private EntityManager entityManager;

FullTextEntityManager fullTextEntityManager;

public abstractDAO(){
super();

@PostConstruct
public void setPersistenceUnit(){
super.setUnit(entityManager);
fullTextEntityManager = Search.getFullTextEntityManager(entityManager);

}

public FullTextEntityManager getFullTextEntityManager(){
return fullTextEntityManager;
}
But this approach gave me
org.hibernate.SessionException: Session is closed!
Exception whenever I tried to search.

My initial action was to look into index directory to see if they are being created. It looked perfectly ok there.

The problem was, search operation was not getting transaction while searching. The spring was not injecting transaction into a fullTextEntityManager created from entityManager.

For a try I introduced EXTENDED persistence context as below:
@PersistenceContext(unitName = “defaultManager”,type=PersistenceContextType.EXTENDED)
private EntityManager entityManager;

and search started working!! But this gave me other problems. Any changes to the entity bean got saved into DB without even committing!!!! I had to revert this change.

My second approach to solve this was to configure fullTextEntirtyManager as Spring bean (as entityManager was configured) so that it can get the transaction.
I couldn’t do it properly as I found no spring’s implementation for fullTextEntirtyManager bean configuration.

After a lot of tries and searching, just changing my DAO code solved this. Instead of making FullTextEntityManager a class level variable, I instatiated it from entityManager whenever I wanted to search. Something like below:

@PersistenceContext(unitName = “defaultManager”)
private EntityManager entityManager;

public abstractDAO(){
super();
}

@PostConstruct
public void setPersistenceUnit(){
super.setUnit(entityManager);

}

public FullTextEntityManager getFullTextEntityManager(){
FullTextEntityManager fullTextEntityManager;
fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
return fullTextEntityManager;
}
This solved my problem and the search is working perfectly now.

Going for an interview or want to test your hibernate skills , check out our hibernate interview questions

Twitter has been written in which programming language

Why did twitter dumped Ruby on Rails

For new England residents a chance to learn Scala with Venkat Subramaniam who will be presenting on Programming Scala on Aug 12 2010  at  NEJUG.

Venue : Sun Microsystems, Burlington , MA

Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects, and speaks frequently at international conferences and user groups. He is author of “.NET Gotchas,” coauthor of 2007 Jolt Productivity Award winning “Practices of an Agile Developer,” author of “Programming Groovy: Dynamic Productivity for the Java Developer” and “Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine” (Pragmatic Bookshelf).

Spring certification mock test 1

Spring certification mock test 2

These tests are priced at $0.99 each . So how good are the tests ?

Follow this discussion on javaranch to see what real users who have been through Spring certification are saying about the test

Failed Core Spring certification

We hope that you like his Core Spring 3.0 Certification Mock Test 2 . This test covers topics on container, Test, AOP, SpEL, Database, JMS, JMX, Web, MVC, Remoting etc

Looking for your feedback and inputs.

This API allows non Windows operating systems to run pure Java applications which can both process and deliver Excel spreadsheets. Because it is Java, this API may be invoked from within a servlet, thus giving access to Excel functionality over internet and intranet web applications.

Download JExcelApi JAR files from

http://jexcelapi.sourceforge.net/

Reading Spreadsheets

Here is the sample program which uses the javaexcel

Program to read the Excel.

package com;

import java.io.File;

import java.io.IOException;

import jxl.*;

import jxl.read.biff.BiffException;

public class JavaExcel {

public static void main(String args[]) {

readExcel();

}

public static void readExcel() {

try {

Workbook workbook = Workbook.getWorkbook(new File(“Res.xls”));

Sheet sheet = workbook.getSheet(0);

Cell a1 = sheet.getCell(1, 13);

String stringa1 = a1.getContents();

System.out.println(stringa1);

workbook.close();

} catch (BiffException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

Input excel file (place it in the classpath):

Following is the Output of the program.

Deepak

Dinesh

Fundamentals

JExcelApi can read an Excel spreadsheet from a file stored on the local file system or from some input stream. The first step when reading a spreadsheet from a file or input stream is to create a Workbook. The code fragment below illustrates creating a workbook from a file on the local file system.

Workbook workbook = Workbook.getWorkbook(new File(“myfile.xls”));

(NOTE: when creating a spreadsheet from a ServletInputStream you must remove the HTTP header information before creating the Workbook object.)

Once you have accessed the workbook, you can use this to access the individual sheets. These are zero indexed – the first sheet being 0, the second sheet being 1, and so on. (You can also use the API to retrieve a sheet by name).

Sheet sheet = workbook.getSheet(0);

Once you have a sheet, you can then start accessing the cells. You can retrieve the cell’s contents as a string by using the convenience method getContents(). In the example code below, A1 is a text cell, B2 is numerical value and C2 is a date. The contents of these cells may be accessed as follows

Cell a1 = sheet.getCell(0,0);
Cell b2 = sheet.getCell(1,1);
Cell c2 = sheet.getCell(2,1);

String stringa1 = a1.getContents();
String stringb2 = b2.getContents();
String stringc2 = c2.getContents();

// Finished – close the workbook and free up memory
workbook.close();

Writing Spreadsheets

Sample program to write contents in the Excel.

package com;

import java.io.File;

import java.io.IOException;

import jxl.*;

import jxl.write.Label;

import jxl.write.Number;

import jxl.write.WritableSheet;

import jxl.write.WritableWorkbook;

import jxl.write.WriteException;

import jxl.write.biff.RowsExceededException;

public class JavaExcelWr {

public static void main(String args[]) {

writeExcel();

}

public static void writeExcel() {

try {

WritableWorkbook wrworkbook = Workbook.createWorkbook(new File(

“output.xls”));

WritableSheet wrsheet = wrworkbook.createSheet(“First Sheet”, 0);

Label label = new Label(0, 0, “label record 1″);

wrsheet.addCell(label);

label = new Label(0, 1, “label record 2″);

wrsheet.addCell(label);

label = new Label(0, 2, “label record 3″);

wrsheet.addCell(label);

label = new Label(0, 3, “label record 4″);

wrsheet.addCell(label);

Number number = new Number(3, 4, 3.1459);

wrsheet.addCell(number);

wrworkbook.write();

wrworkbook.close();

} catch (IOException e) {

e.printStackTrace();

} catch (RowsExceededException e) {

e.printStackTrace();

} catch (WriteException e) {

e.printStackTrace();

}

}

}

Following is the Output of the program.

Fundamentals

Similarly to reading a spreadsheet, the first step is to create a writable workbook using the factory method on the Workbook class.

WritableWorkbook workbook = Workbook.createWorkbook(new File(“output.xls”));

This creates the workbook object. The generated file will be located in the current working directory and will be called “output.xls”. The API can also be used to send the workbook directly to an output stream eg. from a web server to the user’s browser. If the HTTP header is set correctly, then this will launch Excel and display the generated spreadsheet.

The next stage is to create sheets for the workbook. Again, this is a factory method, which takes the name of the sheet and the position it will occupy in the workbook. The code fragment below creates a sheet called “First Sheet” at the first position.

WritableSheet sheet = workbook.createSheet(“First Sheet”, 0);

Now all that remains is to add the cells into the worksheet. This is simply a matter of instantiating cell objects and adding them to the sheet. The following code fragment puts a label in cell A3, and the number 3.14159 in cell D5.

Label label = new Label(0, 2, “A label record”);
sheet.addCell(label);

Number number = new Number(3, 4, 3.1459);
sheet.addCell(number);

There are a couple of points to note here. Firstly, the cell’s location in the sheet is specified as part of the constructor information. Once created, it is not possible to change a cell’s location, although the cell’s contents may be altered.

The other point to note is that the cell’s location is specified as (column, row). Both are zero indexed integer values – A1 being represented by (0,0), B1 by (1,0), A2 by (0,1) and so on.

Once you have finished adding sheets and cells to the workbook, you call write() on the workbook, and then close the file. This final step generates the output file (output.xls in this case) which may be read by Excel. If you call close() without calling write() first, a completely empty file will be generated.

// All sheets and cells added. Now write out the workbook
workbook.write();
workbook.close();

Download JAR files from

http://jexcelapi.sourceforge.net/

FAQ has details on how to read an Excel File uploaded through a Web browser to a Servlet and also about how to Output an Excel file from a Servlet.

FAQ link is http://jexcelapi.sourceforge.net/resources/faq/

Reading environment Variables in Java

System environment variable can be used in the java application to set the system related values for ex: application path, database environment etc..,

In standalone application, start the JVM with the “-D” switch to pass properties to the application and read them with the System.getProperty() method.

SET myvar=Hello world

SET myothervar=nothing

java -Dmyvar=”%myvar%” -Dmyothervar=”%myothervar%” myClass

Then in myClass do the following

String myvar = System.getProperty(“myvar”);

String myothervar = System.getProperty(“myothervar”);

Reading UNIX environment Variables in Java

How the code works:

Create an instance of a java.util.Properties class.

Every Java application has a single Runtime instance, which is an interface with the environment in which the application is running. The current Runtime is obtained using the static method getRuntime() of Runtime class.

Call the exec method of the Runtime object, to execute the given command in a separate process.

After executing, the method returns the handle to a Process class. Get the input stream for the sub process using getInputStream() method.

Load the Properties object with this InputStream.

Now we can read any environment variable form the Properties Object, by using get method.

Lines of Code:

java.util.Properties env = new java.util.Properties();

env.load(Runtime.getRuntime().exec(“env”).getInputStream());

String myEnvVar =(String) env.get(“MY_VAR”);

Configuring / Reading the JVM environment variable in IBM WAS Server.

JVM environment variables can be set in the WAS server, and that environment variable can be read from the java program using System.getProperty().

In a real time scenario, database environment variable can be set in the JVM custom properties, and that can be changed depending on which environment the application is deployed.

For ex: for production database environment, value can be set to PROD so that production database related properties file can be read by the application.

Following is the path in the WAS server where we need to set the JVM custom variable and value.

Below is the sample snapshot which shows the DB_ENVIRONMENT property name and value settings.

After adding a new value or updating the value, restart the WAS server, so that changes will get reflected in the application.

Code to read the environment setup:

String env = System.getProperty(“DB_ENVIRONMENT”)

So depending on the value of env variable, we can read the properties file for different environment

For ex:

If(“DEVELOPMENT”.equals(env)) {

//Load the development environment related property files.

//Connect to development database.

} else If(“PROD”.equals(env)) {

//Load the production environment related property files.

//Connect to production database.

} If(“UAT”.equals(env)) {

//Load the uat environment related property files.

//Connect to uat database.

}

In our site Skill-Guru , you will notice a search box on the right hand side.  We have enabled the search on few tables and columns initially. Currently it will search for the tests , description and keywords for the input keyword.

Hibernate search searches objects from text queries. It uses Apache Lucene Indexing technique. It indexes the tables with the help of annotations. Also it does the synchronization of database and index. Following tutorial demonstrates a simple searching example using hibernate search. The application uses JPA way.

Consider any site selling some products. You want to search products by title, description etc. Consider following products table.

create table product(
id int(5) not null auto_increment,
title varchar(100) not null,
description varchar(250) not null,
manufacture_date datetime,
primary key(id));
To start with Hibernate Search , you must have hibernate search downloaded. Download Hibernate search 3.1.1 and Hibernate 3.
Create a java application and add required jars to your build path. Click here to know exact jars used in this project.

Crate a src/META-INF directory and create a persistence.xml file with following contents (edit it according to your database parameters)

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence xmlns=”http://java.sun.com/xml/ns/persistence”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd” version=”1.0″>

<persistence-unit name=”defaultManager”
transaction-type=”RESOURCE_LOCAL”>
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name=”hibernate.connection.driver_class”
value=”com.mysql.jdbc.Driver” />
<property name=”hibernate.connection.url”
value=”jdbc:mysql://localhost:3306/hibernatetest” ></property>
<property name=”hibernate.connection.username” value=”root” />
<property name=”hibernate.connection.password”
value=”root” />
<property name=”hibernate.show_sql” value=”false” />

<property name=”hibernate.search.default.directory_provider”
value=”org.hibernate.search.store.FSDirectoryProvider” />
<property name=”hibernate.search.indexing_strategy” value=”manual” />
<property name=”hibernate.search.default.indexBase” value=”e:\indexes” />
</properties>
</persistence-unit>
</persistence>

Make sure you have database url, username and password entered properly. Another important factor is the indexBase directory. Hibernate search creates indexes for each table it need to search and those indexes will be saved in this directory.

The properties:
<property name=”hibernate.search.default.directory_provider”
value=”org.hibernate.search.store.FSDirectoryProvider” />
<property name=”hibernate.search.indexing_strategy” value=”manual” />
<property name=”hibernate.search.default.indexBase” value=”e:\indexes” />
are used by Hibernate Search.

Create test.eo package and create a ProductEO class. The ProductEO entity class for products table might look like below:

Create test.eo package and create a ProductEO class. The ProductEO entity class for products table might look like below:

package test.eo;

import java.util.Date;

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

@Entity
@Table(name=”product”)
public class ProductEO {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name=”id”)
private Integer id;

@Column(name=”title”)
private String title;

@Column(name=”description”)
private String description;

@Column(name=”manufacture_date”)
private Date manifactureDate;

public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Date getManifactureDate() {
return manifactureDate;
}
public void setManifactureDate(Date manifactureDate) {
this.manifactureDate = manifactureDate;
}
}

To make this entity to be able to be searched, we need to add some more annotations. Altered Entity class is shown below:

package test.eo;

import java.util.Date;

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

import org.hibernate.search.annotations.DocumentId;
import org.hibernate.search.annotations.Field;
import org.hibernate.search.annotations.Index;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.annotations.Store;

@Entity
@Table(name=”product”)
@Indexed
public class ProductEO {

@DocumentId
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name=”id”)
private Integer id;

@Field(index=Index.TOKENIZED, store=Store.NO)
@Column(name=”title”)
private String title;

@Field(index=Index.TOKENIZED, store=Store.NO)
@Column(name=”description”)
private String description;

@Column(name=”manufacture_date”)
private Date manifactureDate;

public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Date getManifactureDate() {
return manifactureDate;
}
public void setManifactureDate(Date manifactureDate) {
this.manifactureDate = manifactureDate;
}
}

We added following:

1. @Indexed annotation to Class
2. @DocumentId annotation on the primary key. Hibernate Search needs to store an id in the index to ensure index uniqueness for a given entity. This annotation marks that unique property. In most of the cases this will be the primary key.
3. @Field(index=Index.TOKENIZED, store=Store.NO) annotation on the fields, which need to be matched while searching. The parameter
index=Index.TOKENIZED will ensure that the text will be tokenized (in short words will be identified) using the default Lucene analyzer. store=Store.NO is to  ensures that the actual data will not be stored in the index.

Now define a HibernateEntitymanagerHelper class in package test.services to initialize persistence context as below:

package test.services;
import javax.persistence.*;
public class HibernateEntitymanagerHelper {
private static EntityManagerFactory emf;
static{
try{
emf = Persistence.createEntityManagerFactory(“defaultManager”);
}catch(Throwable tw){
throw new ExceptionInInitializerError(tw);
}
}
public static EntityManagerFactory getEntityManagerFactory() {
return emf;
}
public static void shutdown() {
emf.close();
}
}

Create following AddProducts  class in test.services package and add some data into the table:

package test.services;

import javax.persistence.EntityManager;
import test.eo.*;
import java.util.Date;

public class AddProducts {
public static void main(String[] args) {
try{
EntityManager em = HibernateEntitymanagerHelper.getEntityManagerFactory().createEntityManager();
em.getTransaction().begin();
ProductEO prodEO = new ProductEO();
prodEO.setTitle(“Mike”);
prodEO.setDescription(“XXX company Mike”);
prodEO.setManifactureDate(new Date());
em.persist(prodEO);

prodEO = new ProductEO();
prodEO.setTitle(“Phone”);
prodEO.setDescription(“YYY company Phone”);
prodEO.setManifactureDate(new Date());
em.persist(prodEO);

prodEO = new ProductEO();
prodEO.setTitle(“Microphone”);
prodEO.setDescription(“YYY company Microphone”);
prodEO.setManifactureDate(new Date());

em.persist(prodEO);
em.getTransaction().commit();

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

Now, this is time to test. For Hibernate search to work you have to trigger an initial Indexing to populate the Lucene index with the data already present in your database.  Following code creates indexes and then does searching.

package test.services;

import java.util.List;

import javax.persistence.EntityManager;
import test.eo.*;
import java.util.Date;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.hibernate.search.jpa.FullTextEntityManager;
import org.hibernate.search.jpa.Search;

public class ProductService {

/**
* @param args
*/
public static void main(String[] args) {

try{
EntityManager em = HibernateEntitymanagerHelper.getEntityManagerFactory().createEntityManager();
FullTextEntityManager fullTextEntityManager =  Search.getFullTextEntityManager(em);

fullTextEntityManager.getTransaction().begin();

List<ProductEO> products = em.createQuery(“select product  from ProductEO as  product”).getResultList();
for (ProductEO product : products) {
fullTextEntityManager.index(product);
System.out.println(“Product”+product.getTitle());
}

String[] fields = new String[]{“title”, “description”};
MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, new StandardAnalyzer());
// parser.setDefaultOperator(QueryParser.AND_OPERATOR);

/*
* Search only by lowercase
*/
org.apache.lucene.search.Query query = parser.parse( “phone” );
// wrap Lucene query in a javax.persistence.Query
javax.persistence.Query persistenceQuery =  fullTextEntityManager.createFullTextQuery(query, ProductEO.class);
// execute search
List<ProductEO> result = persistenceQuery.getResultList();
System.out.println(“result ::”+result);
for (ProductEO product : result) {
System.out.println(“product ::”+product.getTitle());
}

fullTextEntityManager.getTransaction().commit();
em.close();
HibernateEntitymanagerHelper.shutdown();
}catch(Exception e){
e.printStackTrace();
}

}

}

Going for an interview or want to test your hibernate skills , check out our hibernate interview questions

He has created Core Spring Certification practice test at Skill-Guru.  It is a 50 questions test priced at $0.99 and 10 questions are free. An absolute bargain !!

Take the Spring certification practice test before you take that Spring certification.