Ever needs to invoke some other business service method from another service bean, which in turns calls your method?

Configuring the services this way

<bean class="ServiceA ">                                                                 

      <property name="IserviceB" ref="serviceB" />

      ……

</bean>

<bean class="ServiceB">                                                            

      <property name="IServiceA" ref="serviceA" />

      ……

</bean>

Will not work as the two beans try wait for other one to initialize.

Alternatively, implement the application context aware interface, which allows one bean to get access to the application context, as well as all the beans by its “id” attribute.

public class ServiceA implements IServiceA, ApplicationContextAware{

   private ApplicationContext applicationContext;

   public void setApplicationContext(ApplicationContext applicationContext) {

            this.applicationContext = applicationContext;

  }

   public void fooBar()

   {

      IServiceB = (IServiceB)applicationContext.getBean("ServiceB");

   }

}

(For Spring 2.5.6)

Ever wondered how Spring Form tags look like after they are compiled? I think using raw HTML/DOM with Spring MVC’s form controllers can be very useful. I personally like to use them to avoid using the onFormChange() function in the controller. For one this request is done server side and it feels unnatural to me. Although I have to admit that requesting a form change using Spring MVC almost feels like making an AJAX call (servlets are really that fast), the look and feel of the real thing is second to none.

So I thought, why not use raw html to bind input from form fields to a command class using Spring controllers? You’d have to know the raw html equivalent of Spring forms first. So without any further ado:

<form:form commandName="FootballTeam" method="POST">

</form:form>

<form id="FootballTeam" action="/createNewTeam" method="POST"> 

</form>

/createNewTeam maps to the Spring Controller that handles the form.

<form:input path="teamName"/>

<input id="teamName" name="teamName" type="text" value=""/>

Input type: text box

<form:select path="league">
		<form:options items="${leagues}"/><br/>
</form:select>

<select id="league" name="league">
     <option value="Bundesliga">Bundesliga</option>
     <option value="ZweiteLiga">ZweiteLiga</option>
     <option value="OberLiga">OberLiga</option>
</select> 

So I guess there’s no need to override the referenceData() method in the controller for a select option.

Currently I am Working as a technical lead of a spring based project. And surprising this is the first commercial spring based project for me. I had a very little idea on how to use Ajax/ DWR on Spring. So, I browse a lot on this topics and found some helpful sites related to this. But, no sites provide exact step to step procedure of doing this. So, I decided to write this blog.

For whom this blog is:

Those who have basic information on Spring Framework and DWR.

Direct Web Remoting ( DWR) is a Java Library that enables developer  to expose their Java Methods to JavaScript. Through this developer can call java methods from client side javascript code. It act as an alternative of Ajax for java programmer. You can get more on DWR here: http://directwebremoting.org/dwr/index.html.

Case:

Here I am using DWR to display some values from database against a combo box values. For Example , there is a combo box giving a list of emploryees name from database. Whenever user select a value from the combo box, it will show the age and grade of the particular employee at two text boxes on same form. I will not show all the details of the code here.

Steps:

To use DWR with Spring, you need to follow this three steps:

1. Enable and configure DWR at your project.
2. Write your java code
3. Expose the Java Code for JavaScript
4. Call the JavaCode from JavaScript

1. Enable and configure DWR at your project:

Configured your project for dwr support means adding the library files and configuring the beans through xml configuration.

download dwr library from http://directwebremoting.org/dwr/download.html.  Though beta version 3 is available you should download stable version 2.0.5. Add this library to you spring project.

To configure the dwr at you project you need to change the xml files as follows:

• Namespace: you need to enter following xml namespace on beans tag of your application-context.xml files:

xmlns:dwr=http://www.directwebremoting.org/schema/spring-dwr

Add the following two xml locations at xsi:schemaLocation attribute of beans tag:

http://www.directwebremoting.org/schema/spring-dwr

http://www.directwebremoting.org/schema/spring-wr-2.0.xsd

Typically your beans tag should like this:

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

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xmlns:p=”http://www.springframework.org/schema/p”

xmlns:aop=”http://www.springframework.org/schema/aop”

xmlns:dwr=”http://www.directwebremoting.org/schema/spring-dwr”

xmlns:tx=”http://www.springframework.org/schema/tx”

xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

http://www.directwebremoting.org/schema/spring-dwr

http://www.directwebremoting.org/schema/spring-dwr-2.0.xsd

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd”>

• Now,  add this two tag’s at your application-context.xml file:

<dwr:controller debug=”true” />

<dwr:configuration></dwr:configuration>

• Add the following bean definitions to application-conext.xml file>

<bean class=”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping”>

<property>

<props>

<prop key=”/engine.js”>dwrController</prop>

<prop key=”/util.js”>dwrController</prop>

<prop key=”/interface/**”>dwrController</prop>

<prop key=”/call/**”>dwrController</prop>

</props>

</property>

</bean>

This will enable you map the different files while calling from client side. You will use this files later on.

• Add a dwr mapping on your web.xml files like this:

<servlet-name>dwr</servlet-name>

<servlet-class>org.directwebremoting.spring.DwrSpringServlet</servlet-class>

<init-param>

<param-name>debug</param-name>

<param-value>true</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>dwr</servlet-name>

<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>

Now, you are ready to add your dwr code. Test if the configuration file browsing to following address:

http://localhost:8080/mydwr/dwr

this will show  the following message:

No Classes known to DWR:

2. Write Your Java Code:

Create a folder called dwr on source package. Add Java Classes to add functionality of your javacode. In our case the function may like this:

public class employeejs

{

// private property for DataAccess object

public int getAge(string empid)

{

//implementation
}

public string getGrade(string empid)

{

//implementation
}

}

1. Expose this bean for JavaScript:

To expose the above class to JavaScript, you need to publish this class and methods by using dwr:remote and dwr:include tag.

dwr:remote enable java classes to access remotely while dwr:include exposes the method accessible remotely.. These are uses as a bean attribute defined at dwr.jar library. In our case, the xml definition at application-context.xml should look like this:

<bean

class=”dwr. employeejs “>

<property name=”empdao” ref=”employeedao”></property>

<dwr:remote javascript=”emp”>

<dwr:include method=”getAge”/>

<dwr:include method=” getGrade “/>

</dwr:remote>

</bean>

Here, class means the name of Java class. On property tag you can initialize any property needed. We initialize the dataaccess object. Javascript attribute of dwr:remote define the javascript class name of the java class. Here it is emp. Which means this employeejs class will be called from JavaScript as emp .

You can optionally use <dwr:convert> tag to convert any java object to javascript data types if needed. The conversion doesn’t need for primitive data types. I wouldn’t describe this tag at this blog.

Now, the http://localhost:8080/mydwr/dwr – url should show the following message:

Classes known to DWR:

• emp (dwr.employeejs)

That means you are ready to call it from JavaScript.

1. Call the JavaCode from JavaScript

To Call the Java Method from JavaScript you need to include the following script pages at your jsp page:

<script type=’text/javascript’ src=’/<<home folder>>/dwr/interface/emp.js’></script>

<script type=’text/javascript’ src=’/<<home folder>>/dwr/engine.js’></script>

<script type=’text/javascript’ src=’/<<home folder>>/dwr/util.js’></script>

Where , emp is the remote class name defined at <dwr:remote> tag.

Now, call the javascript remote method by following codes:

<script>

function myunit(i)

{

emp.getAge(i,function handleGetData(str) {

document.getElementById(“Age”).value=str;

});

emp.getGrade(i,function handleGetData(str) {

document.getElementById(“Grade”).value=str;

});

}

</script>

You need to pass 1 more parameter to Java Function. This parameter will act as a out parameter. getAge took only one parameter; but we call it with two parameters.  The second one is out parameter. It is a javascript function with a single parameter. Java code will return the value at this single parameter.

Now, you can call this function again any method you require.

Hope, this will help you on using the dwr on spring framework. For, any query, you can reach me at mohi.khan@gmail.com.

Problem Statement: We need to start some task, after injecting all properties. How to resolve this?

Solution: Dont / Never depend on order of injecting values into bean. It is not controlled.

import org.springframework.beans.factory.InitializingBean;

public class BeanName implements InitializingBean
{

public void afterPropertiesSet() throws Exception
  {
    System.out.println( "It will be called after completion of properties setting.");
    //do whatever is required here.
  }

}

como já diria Joel Spolsky… este blog já está fedendo a cupim (não, Joel não disse isso, na verdade do que se trata dele terminou nas reticências e tinha a ver com o titulo do post) mas tudo bem, esta é uma rapidinha que, se eu tivesse um numero consideravel de seguidores no twitter, seria um twitt… mas, como eu não gosto do twitter e nem quero que você me siga, vai pra cá mesmo.

Tudo que você faz, o faz como se você mesmo fosse usar? Pense nisso antes de construir a próxima linha de código lá no seu trabalho, esqueça seu chefe chato (não que o meu seja, caso o mesmo leia este post…) e codifique como se você mesmo fosse seu próprio usuário, como se você dependesse do seu próprio sistema para realizar seu trabalho.

Afinal de contas meu caro colega, os usuários gostariam tanto, mas tanto, que o que tu faz realmente funcionasse, que eles seriam capazes de te dar um beijo nas nadegas a cada dia de caixa fechado sem bug no sistema. E eu, sendo o cara que irá dar manutenção no seu código, adoraria tanto ver uma suite de testes unitários bem construidos quando o pegasse, que seria capaz de.. te pagar uma Polar bem gelada no boteco mais badalado da cidade baixa aqui de POA.

“Ah, mas eu já escrevo todo aquele código e testo tudo no main..  ainda tenho que escrever testes unitários pra ele?” Amigão, se tu quiser não precisa mais escrever este código todo.. escreva apenas os testes então. Ééé, isso mesmo. Esqueça aquela coisa toda logo de cara e vá direto aos seus @Test.. apenas coloque na cabeça: só entregue este código depois que os testes passarem! Se por acaso, tu ter que codificar um pouco para os testes passarem, beleza, tu faz classe a classe, mas espere, a classe não precisa existir para tu escreve-la pela primeira vez no seu teste… deixe o Eclipse chorar mesmo, só depois tu cria, ou melhor, rode a droga do teste sem a classe, para tu VER na tela que nada funciona sem a presença da maldita classe. É bem simples, não precisa ler um livro para começar.. são regrinhas básicas: da direita (seus testes) <simula erro> para a esquerda (implementação de uma pequena porção de código) <testa>.

“Mas quando eu sei que não preciso mais testar?” Quem disse que não precisa mais testar? Sempre que tu tocar aí tu vai testar, a unica diferença é que não precisará mais se preocupar com o que já está testado, pois se der algum tipo de erro, tu saberá exatamente onde consertar. Eu mesmo, sei quando não preciso mais testar quando o código que eu preciso para entregar a minha estória está pronto e é suficiente, pois de acordo com o TDD, se ele já está pronto, é porque existe um teste para ele!

Finalizando.. “eat your own dog food” .. estou ficando louco ou:

a propósito (falando em loucos), aproveitando a presença do Rod Johnson na TDC, nos diga Rod: o que faz a SpringSource, usar PHP no seu portal? http://www.springsource.com/index.php, Por quê não o nosso amigo SpringMVC?

E que calor infernal em Porto Alegre…

DSRC requires Software Professionals (Walk-In Interviews)

Looking for dynamic Software Professionals for the following skills:

— Java – Technical Architect:
a). 7-10 years experience in J2EE Design and Architecture, UML, OOAD, Design Patterns, EJB, Struts, JSP, EJB, JDBC, JNDI, Web Services, Weblogic App Server
b). Struts Framework, Jakarta Tiles framework, Hibernate, Spring Framework, Eclipse 3.0, Solaris 9, Rational ClearCase, Rational ClearQuest, Oracle Database
c). Knowledge of SOA & SCA. Sun Certification Enterprise Architect would be preferred
— Mainframe-Developers / Sr. Developers : 3-8 years experience with extensive Real Time Project experience in COBOL, JCL, VSAM, CICS, DB2, IMS DB/DC, ASSEMBLER, PL/I

Walk-In on 31st October, 2009 between 9 am and 7 pm at:

Quality Inn Centurian Hotel
Opposite to Akaswani, Shivaji Nagar, Pune -411 005
Tel: 020 25510600
Fax:020-2552 0400

If you are unable to come on the above date, please forward your resume to jobs@dsrc.co.in

Using SPRING declarative transaction, learned today that Spring only rolls back transaction for an Unchecked Exception .

For example, suppose in the SPRING application context we have a business service that declares its transaction boundary using SPRING AOP.  In the example below, the create method has transaction definition of “Propagation_required”.   The business service has a DAO called artistDAO injected into it.

<!– persistence service–>

    <bean id="businessService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="transactionManager" />
        <property name="transactionAttributes">
            <props>
                <prop key="create*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
        <property name="target">
            <bean class="com.myexample.BusinessService">
               <property name="artistDAO" ref="artistDAO"/>
            </bean>
        </property>
    </bean>

In the code, throw a checked exception in the create method

public class BusinessService{
private ArtistDAO artistDAO;
public void create()throws Exception{
Artist artist1 = new Artist("Victor Huang 11");
Artist artist2 = new Artist("Victor Huang 12");
Artist artist3 = new Artist("Victor Huang 13");
artistDAO.create(artist1);
artistDAO.create(artist2);
if(1 == 1)
{throw new Exception("hello");}
artistDAO.create(artist3);

We declared a transaction and we tried to insert three entities into the database: artist 1, artist 2, and artist 3.  An exception was thrown, so the transaction should roll back right?

Wrong!  As a result, artist with name “Victor Huang 11″ and “Victor Huang 12″ still get inserted.  Even though the create() method was declared to be in a transaction, Spring does not roll back the insertion of artist 1 and artist 2 entities.

Had the exception being an unchecked exception, none of the entities would get inserted.

PROPAGATION_REQUIRED

Using SPRING declarative transaction, learned today that Spring only rolls back transaction for an Unchecked Exception .

For example, suppose in the SPRING application context we have a business service that declares its transaction boundary using SPRING AOP.  In the example below, the create method has transaction definition of “Propagation_required”.   The business service has a DAO called artistDAO injected into it.

<!– persistence service–>

    <bean id="businessService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager" ref="transactionManager" />
        <property name="transactionAttributes">
            <props>
                <prop key="create*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
        <property name="target">
            <bean class="com.myexample.BusinessService">
               <property name="artistDAO" ref="artistDAO"/>
            </bean>
        </property>
    </bean>

In the code, throw a checked exception in the create method

public class BusinessService{
private ArtistDAO artistDAO;
public void create()throws Exception{
Artist artist1 = new Artist("Victor Huang 11");
Artist artist2 = new Artist("Victor Huang 12");
Artist artist3 = new Artist("Victor Huang 13");
artistDAO.create(artist1);
artistDAO.create(artist2);
if(1 == 1)
{throw new Exception("hello");}
artistDAO.create(artist3);

We declared a transaction and we tried to insert three entities into the database: artist 1, artist 2, and artist 3.  An exception was thrown, so the transaction should roll back right?

Wrong!  As a result, artist with name “Victor Huang 11″ and “Victor Huang 12″ still get inserted.  Even though the create() method was declared to be in a transaction, Spring does not roll back the insertion of artist 1 and artist 2 entities.

Had the exception being an unchecked exception, none of the entities would get inserted.

PROPAGATION_REQUIRED

Using a form to submit to another form goes directly to successView instead of your formView.

Here’s an example:

SomeJsp.jsp

<form name="someForm" action="someForm.htm" method="post">
<input type="button" onClick="javascript:someForm.submit();" value="Submit"></input>
</form>

SomeFormController.java

public class SomeFormController extends SimpleFormController {
}

spring-servlet.xml

<bean name="/someForm.htm" class="SomeFormController">
<property name="formView" value="testForm"/>
<property name="successView" value="newForm"/>
</bean>

….

If you have code similar to the snippet above, you will find that when you click on the “Submit” button in SomeJsp.jsp, instead of going to the formView page (in this case testForm) it will go directly to the successView (newForm).

You will notice that your SomeFormController never executed its showForm() method and went directly to its processFormSubmission() and onSubmit() methods.

I don’t know what the real reason is behind this, but it seems like because the first form submission in SomeJsp.jsp, is a “post” method, the Spring container immediately does a post to the second form (newForm).

To acquire the results you want, simply use a FORM GET on the first form, like this:

SomeJsp.jsp

<form name="someForm" action="someForm.htm" method="get">
<input type="button" onClick="javascript:someForm.submit();" value="Submit"></input>
</form>

Hibernate has two kinds of caches for objects. The first-level cache is coupled with the Session object and used by default in order to decreases the amount of database queries and updates within one session. The second-level cache is associated with the Session Factory and can be reused between sessions. Hibernate has a bit more in store, namely the query cache. The query cache is used to store query results. Both the second-level cache and the query cache are not enabled by default and some configuration is required before they can be used. This post focuses on making EHCache work in configuration with Spring Framework and Hibernate as the JPA provider, so here it is what we need to make EHCache cooperate.

Enabling second-level cache

First, following properties should be set up in persistence.xml:

<property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.SingletonEhCacheProvider"/>
<property name="hibernate.cache.use_second_level_cache" value="true"/>

The first one sets up the cache provider and the second on enables the usage of the second-level cache. For instance creation net.sf.ehcache.hibernate.EhCacheProvider can be used.

Once you have decided which objects you would like to cache time to configure it in ehcache.xml which should be placed in the classpath. The name of the cache should be after the fully qualified name of the domain object you wish to cache.

<cache name="org.poppenjans.domain.Doll"
       maxElementsInMemory="100"
       eternal="false"
       timeToIdleSeconds="2000"
       timeToLiveSeconds="6000"
       overflowToDisk="false"
       />

The ehcache.xml should also include defaultCache configuration which is mandatory and which is used for caches created programatically.

The last thing is to configure the entity to be cached. This should be done using @Cache annotation (or alternatively in the XML mapping file).

@org.hibernate.annotations.Cache(usage=org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)

For the description of concurrency strategies please see Hibernate’s documentation.

Enabling query cache

The query cache stores results of queries. It is important to note that it actually stores identifiers of entities being the result of a query and not the actual state of entities. Therefore if you intend to query for entities (not scalar values) you should also enable the second-level cache for these entities. Otherwise a query to the database will be executed each time to retrieve these entities, even though their ids are present in the query cache. These means the entities
should be at least annotated with @Cache and preferably have a decent cache configuration in ehcache.xml. In case no configuration is provided the defaultCache configuration will be used.

First, following property needs to be set in persistence.xml:

<property name="hibernate.cache.use_query_cache" value="true"/>

Furthermore to configure a query to be cached the “cacheable” property needs to be set.

Query query = em.createQuery("select d from Doll d order by d.name");
query.setHint("org.hibernate.cacheable", true);

Cache statistics

Cache statistics needs to be enabled by setting up another property in persistence.xml.

<property name="hibernate.generate_statistics" value="true"/>

The Statistics object can be obtained from the CacheManager. For a single instance following code can be used to obtain
statistics of a cache called org.poppenjans.domain.Doll:

CacheManager cacheManager = CacheManager.getInstance();
System.out.print(cacheManager.getCache("org.poppenjans.domain.Doll").getStatistics());

Sometimes one has to perform validations directly in the Spring controller in addition to using validators.   This works differently depending on whether one is using MultiActionController or SimpleFormController.  Just some code snippet of doing validation in controller.

Example 1: Using MutiActionController, Just want to show errors on the header

public ModelAndView doSomething(HttpServletRequest request, HttpServletResponse response)throws Exception

{

ArrayList errors = new ArrayList();

try{

if(something)

{

throw new Exception(getApplicationContext().getMessage("messageKey", null, null));

}

//do something

}catch(Exception e)

{

errors.add(getApplicationContext().getMessage("messageKey", new String[]{e.getMessage()}, null));

}

if (errors.size() > 0) {

mav = new ModelAndView("error.htm");

request.setAttribute("errors", errors);

}

}

Example 2: Simple Form Controller

protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception {

try

{

//do something bad and throws exception

throw new Exception(getApplicationContext().getMessage("messageKey", null, null));

}catch(Exception e)

{

errors.addError(new ObjectError(getCommandName(), new String[]{"messageKey"},  new String[]{e.getMessage()}, null));

}

if(errors.hasErrors())

{

ModelAndView errorMav = new ModelAndView(getFormView());

errorMav.addAllObjects(errors.getModel());

errorMav.addObject(getCommandName(), address);

return errorMav;

}else

{

return new ModelAndView("redirect:/success.htm");

}

}

By the way, it seems like there is no way in Spring to display just regular messages (non-errors).
Check out this forum.

This is a refactored version of my post, Quick and Dirty Oauth for Twitter4J OAuth for Web Apps

This is also the result of my work on a a problem I had with getting a unauthorized request tokens using GData.

Basically I found that

1. Whatever you do (regardless if you’re using Servlets or Spring MVC), never maintain state in a servlet or a Spring MVC controller because GData and Twitter4J client libraries maintain state.

2. It’s impossible to wire them in Spring because they maintain state.

I think the best way to use Spring for OAuth is by using a MultiActionController with two methods:

authorization()
to print the authorization url

callback()
where the provider will go after the user has authorized it to allow the consumer to access the user’s account in the provider

Here’s what it looks like:

public class OAuthAuthorizeController extends MultiActionController {
public ModelAndView authorize(HttpServletRequest request,
			HttpServletResponse response){

       //authorization code here

}

public ModelAndView callback(HttpServletRequest request,
			HttpServletResponse response){
       //callback code here

}
}

With OAuth client libraries there is less need for url rewriting and doing manual get requests.

But the best way to implement the libraries in your code is to program them to an interface, encapsulating what varies because each client library is used differently.

public interface Provider {
public String getAuthUrl() throws OAuthProviderException;
public UserOAuthAccessToken getAccessToken(String token,String tokenSecret)
}

The rationale behind this is that the Spring controller we have shouldn’t have to know what provider he is dealing with. This makes code loosely coupled.

So if you want your controller to deal with GData or Twitter using the Twitter4J and GData libraries, implement the Provider interface and code in the implementation:

public class GoogleDocs/Twitter4JClient implements Provider {
     public String getAuthUrl(){
        //GData or Twitter4J specific code here
     }
    public UserOAuthAccessToken getAccessToken(){
       //GData or Twitter4J specific code here
    }
}

GData specific code can be found here
Twitter4J well here. Haha.

Use an abstract factory method to return the specific implementation to the controllers:

private Provider getProvider(String providerRequested){
	Provider provider = null;
	if (providerRequested is googledocs){
		provider = new GoogleDocs();
	}
        if (providerRequested is Twitter) {
               provider = new Twitter4JClient();
        }
	return provider;
}

This is what the Spring MVC controller will look like when it’s done:

public class OAuthAuthorizeController extends MultiActionController {
public ModelAndView authorize(HttpServletRequest request,
			HttpServletResponse response){

         Provider provider = getProvider("Twitter"/"GoogleDocs");
         String authUrl = provider.getAuthUrl();
         return new ModelAndView("view","authUrl",authUrl);

}

public ModelAndView callback(HttpServletRequest request,
			HttpServletResponse response){
       Provider provider = getProvider("GoogleDocs"/"Twitter");
       UserOAuthAccessToken accessToken = provider.getOAuthAccessToken();
       //some other logic you have to do
}
private Provider getProvider(String providerRequested){
	Provider provider = null;
	if (providerRequested is googledocs){
		provider = new GoogleDocs();
	}
        if (providerRequested is Twitter) {
               provider = new Twitter4JClient();
        }
	return provider;
}
}