Tuesday, January 12, 2010

Interface injection using Spring

I am adding one more sample for Interface Injection using spring. Spring directly does not support interface injection but there is one thing called autowire, that can be used in spring to achieve some sort of interface injection.

Consider below sample Java classes:

1. Text.java - interface which has getter and setter for String object

public interface Text {
void setTextString(String textString);
String getTextString();

2. MyText.java - implements above Text interface

public class MyText implements Text {

private String textString;

public String getTextString() {
return textString;

public void setTextString(String textString) {
this.textString = textString;


3. Service.java - which has getter and setter for above Text object

public interface Service {
void setText(Text text);
Text getText();

4. MyService.java - implements above Service Interface

public class MyService implements Service {
private Text text;

public Text getText() {
return text;

public void setText(Text text) {
this.text = text;

5. MyServiceApp.java - which has main method to test interface injection

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import static java.lang.System.out;

public class MyServiceApp {

public static void main(String...strings) {
XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(
MyService myService = (MyService) beanFactory.getBean("myService");
out.println( myService.getText().getTextString());

Now, in above sample to get interface injection major file is configuration file(myservice.xml).

Look at below configuration

Configuration file: myservice.xml

<beans xmlns="http://www.springframework.org/schema/beans"

<bean id="text" class="MyText" p:textString="My First String...!"/>

<!-- <bean id="myService" class="MyService" p:text-ref="text"/> -->
<!-- The above can be used if you want to inject the dependency yourself-->

<!-- The below can be used to leave the dependency injection decision to the IoC container -->
<!-- <bean id="myService" class="MyService" autowire="byName"/> -->

<!-- The following line is also almost same as the above except for this case IoC will
detect dependency by type -->
<bean id="myService" class="MyService" autowire="byType"/>


In above sample you can configure interface injection by two ways:

1. <bean id="myService" class="MyService" p:text-ref="text"/>

Here, injection is done by yourself by giving reference to another bean object.

2. <bean id="myService" class="MyService" autowire="byName"/>

Here, injection decision is taken by IoC container as you have specified autowire attribute. autowire value can be set as byName or byType.

Thursday, January 7, 2010

Constructor Injection using Spring

I wrote about Spring & Setter Injection in my previous blog now I am adding one more sample using constructor Injection. Constructor injection is almost same like setter injection except only difference that here IoC container initializes the constructor parameters.

Consider below sample java class.

Java Class: TestConstructor.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestConstructor {

public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"constructorinjection.xml"});
Inject inject = (Inject) context.getBean( "myInject" );
System.out.println( inject.getName() );

class Inject {

private String name;

public Inject(String name, String text)
this.name = name + text;

public String getName() {
return this.name;

In above class constructor parameter values(name & text) would be injected from constructorinjection.xml configuration file.

Configuration file: constructorinjection.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

<bean id="myInject" class="Inject">
<constructor-arg type="java.lang.String" index="1">
<value>Welcome to example to constructor injection </value>
<constructor-arg type="java.lang.String" index="0">
<value>A text </value>

Here, </constructor-arg> has two optional attributes type and index. Type is not significant in this particular example but can be useful when using some other complex types. Specify type value based on your constructor type. Index is also one useful mechanism to be used within. Based on index value it assigns value to constructor parameter.

In above sampe output is:
A text Welcome to example to constructor injection

Now if you change index vaue 1 to 0 and 0 to 1 output is:
Welcome to example to constructor injection A text

If you have noticed I made one more change in this sample compare to my previous blog. I used ApplicationContext instead of BeanFactory. What is the difference? We will now see why ApplicationContext. The first thing you can notice is that you can (of course optionally) pass more than one XML bean definition/configuration files. Ultimately we are assigning the ApplicatioContetx instance to BeanFactory.

Wednesday, January 6, 2010

Use CodeModel to generate Java Source Code

CodeModel is a library that allows you to generate Java source code in a type-safe fashion.

When to use CodeModel:

If you have huge chunk of data in terms of text file or XML and want to generate some Java class based on those data you can use CodeModel. It also helps when your data changes frequently.

To know more about the CodeModel visit following link:


Giving you small sample how to use CodeModel to generate your own class.

Example: CodeFactory.java

import com.sun.codemodel.JAnnotationUse;
import com.sun.codemodel.JBlock;
import com.sun.codemodel.JClass;
import com.sun.codemodel.JCodeModel;
import com.sun.codemodel.JDefinedClass;
import com.sun.codemodel.JDocComment;
import com.sun.codemodel.JExpr;
import com.sun.codemodel.JMethod;
import com.sun.codemodel.JMod;
import com.sun.codemodel.JPackage;
import com.sun.codemodel.JType;
import com.sun.codemodel.JVar;

* @author naman
public class CodeFactory {

// Method to get JType based on any String Value
public JType getTypeDetailsForCodeModel(JCodeModel jCodeModel, String type) {
if (type.equals("Unsigned32")) {
return jCodeModel.LONG;
} else if (type.equals("Unsigned64")) {
return jCodeModel.LONG;
} else if (type.equals("Integer32")) {
return jCodeModel.INT;
} else if (type.equals("Integer64")) {
return jCodeModel.LONG;
} else if (type.equals("Enumerated")) {
return jCodeModel.INT;
} else if (type.equals("Float32")) {
return jCodeModel.FLOAT;
} else if (type.equals("Float64")) {
return jCodeModel.DOUBLE;
} else {
return null;

// Function to generate CodeModel Class
public void writeCodeModel(String factroyPackage) {
try {

/* Creating java code model classes */
JCodeModel jCodeModel = new JCodeModel();

/* Adding packages here */
JPackage jp = jCodeModel._package(factroyPackage);

/* Giving Class Name to Generate */
JDefinedClass jc = jp._class("GeneratedFactory");

/* Adding annotation for the Class */

/* Adding class level coment */
JDocComment jDocComment = jc.javadoc();
jDocComment.add("Class Level Java Docs");

/* Adding method to the Class which is public static and returns com.somclass.AnyXYZ.class */
String mehtodName = "myFirstMehtod";
JMethod jmCreate = jc.method(JMod.PUBLIC | JMod.STATIC, com.somclass.AnyXYZ.class, "create" + mehtodName);

/* Addign java doc for method */
jmCreate.javadoc().add("Method Level Java Docs");

/* Adding method body */
JBlock jBlock = jmCreate.body();

/* Defining method parameter */
JType jt = getTypeDetailsForCodeModel(jCodeModel, "Unsigned32");
if (jt != null) {
jmCreate.param(jt, "data");
} else {
jmCreate.param(java.lang.String.class, "data");

/* Defining some class Variable in mthod body */
JClass jClassavpImpl = jCodeModel.ref(com.somclass.AnyXYZ.class);
jvarAvpImpl = jBlock.decl(jClassavpImpl, "varName");

/* Adding some direct statement */

/* returning varibalbe */

/* Building class at given location */
jCodeModel.build(new File("generated/src"));

} catch (JAXBException ex) {
logger.log(Level.SEVERE, "JAXBException:" + ex);
} catch (Exception ex) {
logger.log(Level.SEVERE, "Other Exception which in not catched:" + ex);

// Wirte main mehtod and call writeCodeModel("com.test") function to generate class

After running above class it generates GeneratedFactory class under generated/src/com/test folder. It includes all required imports and also format the class as per Java Standard. It generates as described below.

Generated Class: GeneratedFactory.java

package com.test;

import com.myannotation.AnyXYZ;
import com.somclass.AnyXYZ;

* Class Level Java Docs
public class GeneratedFactory {

* Method Level Java Docs
public static com.somclass.AnyXYZ myFirstMehtod(long data) {
com.somclass.AnyXYZ varName = new com.somclass.AnyXYZ();
return varName;

Tuesday, January 5, 2010

Java Design Patterns

You can go through below link to get more idea on Different design patterns. You must have to try sample also there.

Link: http://www.javacamp.org/designPattern/

I will add more details on the same later on.

Monday, January 4, 2010

How to use Java Persistence API (JPA)?

The Java Persistence API, sometimes referred to as JPA, is a Java programming language framework that allows developers to manage relational data in applications. A persistence entity is a lightweight Java class whose state is typically persisted to a table in a relational database. Instances of such an entity correspond to individual rows in the table. Entities typically have relationships with other entities, and these relationships are expressed through object/relational metadata. Object/relational metadata can be specified directly in the entity class file by using annotations, or in a separate XML descriptor file distributed with the application.

Let's start with Simple Java Code.

Consider following table in any rational database.

Table Structure:

CREATE TABLE `persistencemsg` (
`messageCode` INT(10) NOT NULL,
`sessionId` VARCHAR(500) NULL,
`message` BLOB(4294967295),
PRIMARY KEY (`messageCode`),
INDEX `messageCode` (`messageCode`)

Now, we will write corresponding entity class (JPIPersistenceMessage.java) for the same. @Table annotation represents table name of the table, in our case it is 'PERSISTENCEMSG'. This entity class is always implements Serializable to write thread safe code. It contains getter and setter method for each column in the table. @Column annotation represents column name corresponding to the each column in the table. Go through below Java code.

Class: JPIPersistenceMessage.java

import java.io.Serializable;
import java.nio.ByteBuffer;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

* @author naman
@Table(name = "PERSISTENCEMSG")
public class JPIPersistenceMessage implements Serializable {

private byte [] message;
private int messageCode;
private String sessionId;

* @return the message
@Column(name = "MESSAGE")
public byte[] getMessage() {
return message;

* @param message the message to set
public void setMessage(byte[] message) {
this.message = message;

* @return the messageCode
@Column(name = "MESSAGECODE")
public int getMessageCode() {
return messageCode;

* @param messageCode the messageCode to set
public void setMessageCode(int messageCode) {
this.messageCode = messageCode;

* @return the sessionId
@Column(name = "SESSIONID")
public String getSessionId() {
return sessionId;

* @param sessionId the sessionId to set
public void setSessionId(String sessionId) {
this.sessionId = sessionId;

Now, how do we use this class for add/edit/update/find operation? First, we need to connect to the database so we have to write one XML file called 'persistence.xml' which is part of META-INF folder in your application. It contains properties to connect to the database. Please change as per your requirement.

XML File: persistence.xml

<persistence-unit name="persist_name">
<property name="toplink.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="toplink.jdbc.password" value="password"/>
<property name="toplink.jdbc.url" value="jdbc:mysql://localhost:3306/databasename"/>
<property name="toplink.jdbc.user" value="username"/>
<property name="toplink.jdbc.read-connections.max" value="3"/>
<property name="toplink.jdbc.read-connections.min" value="1"/>
<property name="toplink.jdbc.read-connections.shared" value="true"/>
<property name="toplink.jdbc.write-connections.max" value="5"/>
<property name="toplink.jdbc.write-connections.min" value="2"/>
<property name="toplink.cache.type.default" value="Full"/>
<property name="toplink.target-database" value="MySQL4"/>

Let's write manager class (JPIPersistenceManager.java) for database operations. We need to load EntityManagerFactory using persistence-unit name given in persistence.xml file, in this case it is 'persist_name'. Now load EntityManager based on EntityManagerFactory. Now you can call all database operations like add/delete/find on this EntityManager object. User must have to start and close the transaction during each operation. Please go through below code.

Class: JPIPersistenceManager.java

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

* @author naman
public class JPIPersistenceManager {

private static EntityManagerFactory emf;
private static EntityManager em;

public void createEntityManagerFactory(String persistenceUnitName) {
emf = Persistence.createEntityManagerFactory(persistenceUnitName);

private static void createEntityManager() {
em = emf.createEntityManager();

private static void closeEntityManager() {

private static void createTransactionalEntityManager() {

private static void closeTransactionalEntityManager() {

public void storeMessage(JPIPersistenceMessage persistenceMessage) {


public void deleteMessage(long messageCode) {

JPIPersistenceMessage persistenceMessageDelete = findMessage(messageCode);

public JPIPersistenceMessage findMessage(long messageCode) {

JPIPersistenceMessage jpipm = em.find(JPIPersistenceMessage.class, Long.toString(messageCode));
return jpipm;


public JPIPersistenceMessage updateMessage(byte[] message, long messageCode) {

Query query = em.createQuery(
"UPDATE JPIPersistenceMessage p SET p.message = :message where p.messageCode = :messageCode");
query.setParameter("message", message);
return findMessage(new Long(messageCode));

public static void main(String args[]) {
JPIPersistenceManager persistenceManager = new JPIPersistenceManager();

// Now call storeMessage,deleteMessage, updateMessage and findMessage on persistenceManager object.

Hope it should be useful to you. Please let me know any comment on this...