<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

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

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.

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.

Previous versions of Java provided a limited and ad-hoc mechanism for annotating code through JavaDoc comments

Java 1.5 allows both runtime and compile-time processing of annotation data. Annotations are said to annotate a Java element. A good example is the @deprecated JavaDoc tag. The @deprecated tag is used for documentation purposes. This tag has no effect on the code it describes, but causes the compiler to produce warnings if any other code references the tagged element.

Annotations will also be used for compile-time checking such as to produce warnings and errors for different failure scenarios. An example of an annotation that is used at compile time is the new @Deprecated annotation, which acts the same as the old @deprecated JavaDoc tag.

How to define an Annotation?

Annotations are defined in following way:

public @interface MyFirstAnnotation

{

 // define the properties.

 // define the properties.

}

MyFirstAnnotation is the name of the annotation.

Annotation may have metadata defined for itself also. Following are the Meta data that can be defined for an Annotation.

Target Annotation: The element (Packages, Classes, variables & methods) on which an Annotation has been defined is also needs to be specified. It needs to be specified in the following way:

@Target(ElementType.METHOD)

public @interface MyFirstAnnotation

{

// define the properties.

// define the properties.

}

Here ‘@Target’ is a meta data for the annotation ‘MyFirstAnnotation’ and it symbolizes that the annotation can only be used with a method. ‘ElementType’ is an already defined Enum in ‘java.lang.annotation’ package.

               ElementType can have the following usages

Rentention Annotaion: This is another metadata for an Annotation. It tells to what extent an Annotation should be retained.

@Retention(RetentionPolicy.CLASS)

@Target(ElementType.METHOD)

public @interface MyFirstAnnotation

{

 // define the properties.

 // define the properties.

}

An annotation can be retained at Code level or at class file level or at runtime JVM level. In the above example, the retention is at class file level. ‘RetentionPolicy’ is an already defined Enum in ‘java.lang.annotation’ package.

               RententionPolicy can have following levels.

Types of Annotation

Annotation can be of 3 types

Marker annotations: This kind of annotation has no variables. They are identified by only their name.

They are defined as follows:

public @interface MarkerAnnotation {

}

          Used as @ MarkerAnnotation

Single Value Annotations: This kind of annotations is provided with a single value.

They are defined as follows:

public @interface SingleValueAnnotation {

String name();

}

Used as @SingleValueAnnotation(“singlevalue”)

Full annotations: This kind of annotations has multiple data members. This need to use fuller syntax.

They are defined as follows:

public @interface FullAnnotation {

String[] names();

}

Used as @FullAnnotation(value1=”val1”,value2=”val2”)

Here is an example full annotation:

/**

* Describes the Request-For-Enhancement(RFE) that led

* to the presence of the annotated API element.

*/

public @interface RequestForEnhancement {

int    id();

String synopsis();

String engineer() default “[unassigned]“;

String date()    default “[unimplemented]“;

}

Once an annotation type is defined, you can use it to annotate declarations. An annotation is a special kind of modifier, and can be used anywhere that other modifiers (such as public, static, or final) can be used. By convention, annotations precede other modifiers. Annotations consist of an at-sign (@) followed by an annotation type and a parenthesized list of element-value pairs. The values must be compile-time constants. Here is a method declaration with an annotation corresponding to the annotation type declared above:

@RequestForEnhancement(

id       = 2868724,

synopsis = “Enable time-travel”,

engineer = “Mr. Peabody”,

date     = “4/1/2007″

)

public static void travelThroughTime(Date destination) { … }

Conclusion

Before the advent of Annotations, Applications had to define their meta-data in some configuration files and usually these meta-data were externalized from the Application. Now, they can directly define this meta-data information in the source code

One of the choices which come to mind is Spring webflow.  Spring webflow is for management of page flow , navigation and state management. It is not an full fledged MVC framework like JSF 2.0 or Apache Struts.

You might get confused by the definition of Spring webflow on its home page

Spring Web Flow is the project in the Spring Portfolio that focuses on providing the infrastructure for building and running rich web applications. As a Spring project, Web Flow builds on the Spring Web MVC framework to provide:

• A domain-specific-language for defining reusable controller modules called flows
• An advanced controller engine for managing conversational state
• First-class support for using Ajax to construct rich user interfaces

Be very clear on your requirements. Do you really need all these features which Spring webflow offers ?

Some features which I liked in Spring webflow 1.0 was the state management and navigation. Did not use Spring webflow for any other task beyond that.

In state management,  one of the neat features was Flow scope which allowed the data to live for a use case or a flow. This was less than session and more than request.  Perfect for some of the situations we had.

But if you have simple  web application, free flowing links it is not advised. Also if you are using JSF2 or any other similar framework, it does not make sense to go with Spring webflow and introduce complexity in application

From Spring Confluence page , Is Spring web flow right for me

Spring web flow is not a one-size-fits-all solution. It is a powerful system to implement controlled navigations that represent user conversations that drive business processes. It is not ideally suited for web sites that require a lot of free browsing.

Another good documentation on web flow is here

Selenium is an open source, robust set of tools that supports rapid development of test automation for web-based applications. This tool is primarily developed in Java Script and browser technologies and hence supports all the major browsers on all the platforms. Most of the time, we will not need to change our scripts for them to work on other platforms. Selenium provides a record/playback tool for authoring tests without learning a test scripting language.

Selenium Components

There are three variants of Selenium, which can be used in isolation or in combination to create complete automation suite for the web applications. Each one has a specific role in aiding the development of web application test automation.

• Selenium IDE
• Selenium Core
• Selenium RC

Selenium IDE

Selenium IDE is an integrated development environment for Selenium tests. It is implemented as a Firefox extension, and has a recording feature, which will keep account of user actions as they are performed and store them as a reusable script to play back. Selenium-IDE also offers full editing of test cases for more precision and control.

How to Use Selenium:

Select “Selenium IDE” from the Tools menu in Firefox. By default when the IDE comes up it has recording turned on. Go to a web site that you want to record, click on the record button and begin the browsing task(s).  we will notice that as we click and type in the browser the IDE is recording everything we are doing.  When we are done, simply end recording and click on the green arrow to play back the script you just created.  Don’t forget to save your script before closing the IDE.Below are the screen shots of working of Selenium IDE and the script generated by IDE.

Please find in below link the Video presentation to record and execute a test

http://wiki.openqa.org/download/attachments/400/Selenium+IDE.swf?

Biggest drawback of Selenium IDE is its limitation in terms of browser support. Though Selenium scripts can be used for most of the browser and operating system,

Advantages of Selenium:

• It is a Open source
• Simple, Easy to install, Easy to work
• Selenium IDE is the only flavor of Selenium which allows you to record user action on browser window

• Can also record user actions in most of the popular languages like Java, C#, Perl, Ruby
• It will not record any operation that you do on your computer apart from the events on Firefox browser window
• During recording if you right click on any element it will show all the selenium commands available
• we can also edit existing command, by selecting it and editing on the boxes available
• we can also insert/delete commands by choosing appropriate option after right clicking
• Choose appropriate run option – i.e walk, run or test runner and review your results

Disadvantages of Selenium:

• Limitation in terms of browser support (It runs only in Mozilla).Scripts written using Selenium IDE can be used for other  browsers only if it is used with Selenium RC or Selenium Core.
• We can’t run recorded script if it is converted to Java, C#, Ruby etc.
• Not allowed to write manual scripts like conditions and Loops for Data Driven Testing
• There is no option to verify images.

Selenium Core

Selenium Core is a test tool for web applications. Selenium Core tests run directly in a browser, just as real users do. They run in Internet Explorer, Mozilla and Firefox on Windows, Linux and Macintosh. It is a simpler form of Selenium, and suitable for non-developers.

Browser compatibility testing: To test the application if it works correctly on different browsers and operating systems. The same script can run on any Selenium platform.
System functional testing: Create regression tests to verify application functionality and user acceptance.

Disadvantages:

• It cannot switch between http and https protocols.
• It cannot handle file upload
• It is extremely complicated for first time users.

Selenium Remote Control

Selenium-RC is the solution for tests that need more than simple browser actions and linear execution. We can use Selenium-RC whenever our test requires logic which is not supported by Selenium-IDE. Selenium-RC uses the full power of programming languages to create more complex tests like reading and writing files, querying a database, and emailing test results.

Features

• We can use Java syntax to write test script
• Easy to conduct Data Driven Testing
• We can read files to get test data
• We can store Test Results into files

Disadvantages

• We can only run a limited number of concurrent tests on the same remote control before seriously impacting its stability.

* Tests developed on Firefox via Selenium-IDE can be executed on any other supported browser via a simple Selenium-RC command line.

References

• http://seleniumhq.org/docs/book/Selenium_Documentation.pdf
• http://www.dynamitemap.com/selenium/
• http://www.peratia.com/index.php?p=analysis&article=selenium_core_basics

If you are lazy enough to build the project using maven , here is another option

Go to this link

http://www.springsource.org/webflow-samples

Download and run the sample . Copy all the libraries into your project . Make sure you have deleted all the old jar files.

The exception you were seeing earlier should be gone.