400+ Java Interview Questions and Answers

400+ Java Interview Questions and Answers with lots of diagrams, examples, & code

2015-09-28T21:34:00.000-07:00

Free PDF downloads:

Core Java and enterprise Java Interview Questions and Answers:

400+ Questions and Answers: Java/J2EE Job Interview Companion (47 pages)

250+ Questions and Answers: Core Java Career Essentials (107 pages)

Java/J2EE Resume/CV sample PDF

Java/J2EE Resumes (19 pages)

Find the Java Interview books and complete PDFs at Lulu.com and Amazon.com.

This blog compliments the above resources by serving as a very handy refresher and a quick reference material. Covers everything from Core Java to enterprise Java, JavaScript to Unix and many development tools to sought-after frameworks like Spring, Hibernate, and JSF with lots of diagrams, code snippets, and examples. If you just want to cram the answers prior to job interviews, this is NOT for YOU.

This blog covers and compliments our books with

Core Java to Enterprise Java Interview Questions and Answers
Most frequently asked Interview Questions and Answers on scripting languages like JavaScript and Unix.
Popular questions and answers on sought after frameworks like JSF, Spring, and Hibernate
Most popular open-ended questions and answers on tools to improve developer productivity and code quality.
And a lot more. Use the search box on the right hand side panel for specific key words.

Hope these resources add value to you as it did to me to go from being a Mechanical Engineer to a Java/JEE based development team leader in 4 years and then to become an independent contractor/consultant working for multinational organizations in varying capacities. Stay tuned or connected for more handy resources.

What do others say:

"After landing a job I have kept on Publish Post reading the book and recommend it to all my friends..." -- JavaRanch Forum	"I have read several technical books over the last few years, but this one was entirely different...." - By Meera Subbarao IT Book Zone Team Leader
I can safely say you'd have to buy probably at least 15 individual books and supplement... -- By Mr. Jeremy Flowers at Amazon UK	"I was in the course of reading the book and now that I have finished it thoroughly , i'm 100% sure i will crack the next interview" -- Blog comment
"If a person manages to give answers as given in book, he/she can easily bag a new job..." -- JavaRanch forum	"Very well written! authors have good, clear style" I'm happy to say I know almost all of the content in the book already, but I'm still very happy I bought it. What really jumped out at me is how well written the explanations are. There are so many book out there that get quite pompous and long-winded with their explanations of polymorphism, for instance. But the authors have summarize what polymorphism does in one short, clear sentence early on in the book. Most of the other explanations are similar, they really "cut through the crap" and provide the most direct answer possible. I recommend this book as a refresher for any Java professional--inevitably, we all get tied up in the peculiar...." -- Lulu.com reviews
"If you have read the The Pragmatic Programmer: From Journeyman to Master, you would enjoy this book too. Is similar about the comfortable pleasure to read this book." IT Book Zone Review

Why prepare?

Preparation breeds confidence and confidence breeds success.

Preparation can help you communicate your thoughts more clearly with examples and illustrations. Preparing prior to each interview has immensely helped me fast-track my career. Even with 11+ years of hands-on experience in Java/JEE based design and development, I still brush up on the fundamentals and the 14+ key areas using the career companions and the essentials prior to attending job interviews or important meetings.

Preparation has always resulted in multiple job offers and much needed job security as a freelancer even in a much tougher job market. Understanding what problems are faced by the industry and what the prospective employers are looking for can make a huge difference to one's career. Being in this know how can also open more doors to take on more challenging tasks in varying capacities. This blog and books share my experience. It is quite encouraging from many personal emails and review comments as to how these materials have helped many others.

How do these resources help you fast-track your Java career?

If you rely only on your own experience, it will take you a lot longer to get a good handle on these 14+ key areas. The best way to fast-track your career is to pro-actively learn these 14+ key areas from others' experience, good books and online articles, and apply what you had learned to practice. This will help you earn a reputation as a "go to person" through your contributions and achievements at work.

What are these 14+ key areas?

Language Fundamentals (LF)
Specification Fundamentals (SF)
Platform Fundamentals (PF)
Design Considerations (DC)
Design Patterns (DP)
Concurrency Management (CM)
Performance Considerations (PC)
Memory/Resource Considerations (MC)
Transaction Management (TM)
Security (SE)
Scalability (SC)
Best Practices (BP)
Coding (CO)
Exception Handling (EH)
Software Development Processes (SDP)
Quality of Service (QoS)

Why use these resources?

Standout from the candidates who are more qualified than you are

The resources provided in here are full of practical examples, diagrams, code snippets, and cross references to provide clear and concise answers to most of the very frequently asked Java interview questions.

Each question is tagged with one or more of the 14+ key areas. These questions and answers are not just meant for cramming prior to interviews. If you are after real career success, pro-actively apply what you learn from these resources.

The questions and answers approach also give a different perspective to clearing up your fundamentals in Java. The answers are detailed enough to learn the fundamentals while preparing for job interviews, code review sessions and technical team meetings. Depending on your level of experience, some answers may require additional research on Google to get a better understanding.

Good caliber professionals are promoted and paid well for thinking, reasoning, solving business problems, and getting things done by drawing on their experiences and skills

to look at the big picture.
to pay attention to details.
for applying the fundamentals/key areas to solve business problems.
for complimenting their technical "know how" with good soft skills and attitude to get things done.

Should you get certified in Java?

Certifications combined with many other "know hows" can make you a better programmer. At the end of the day, it is what you know and can do makes the real difference and not what some documents declare what you know. Certified or not, you will be grilled in job interviews. In my view, favor continuous learning and hands-on experience. Learn more here Why Java certifications are alone not enough?

How do you get your first break with Java?

In summary, the best way for people to get their first break with Java is to:

Learn the core concepts and work on a Java programming project. Start a little Java-based project of your own.
Participate in an open-source project - even if it's just submitting a little patch to see how things fit together.
Update your resume based on the experience and skills you acquired in the above steps to get a break by acquiring an entry level job, even volunteer work should help you open more doors. More on this here -- How to get the much needed experience in Java?

Note: Even though the certifications can be useful, don't wait until you've passed certifications before trying to get work. Recruiters don't hire just because someone has a certification. Certified or not, your Java knowledge and experience will be tested at job interviews.

What Java questions are asked in job interviews?

In career forums, many ask for Java interview questions for 2 year experience, 4 year experience, etc. My advise is that if you brush up on the Java/JEE basics and the 14+ key areas, you should be fine. You have no control over what questions are going to be asked. The interviews are not technical contests to see who gets most questions right. It is all about convincing your prospective employer that you can get the job done. The open-ended questions give you a great opportunity to sell your strengths in these 14+ key areas along with your soft skills, and personal attributes to make a good impression.

Having said this, there are some very basic "must know" Java interview questions that can make or break the deal. These "must know" Java interview questions are covered in my books (tagged as FAQs) and blog entries along with many open-ended questions and answers. You hold the key to your Java career success, and hope this blog assists in your quest to succeed in your career.

If you have any specific question or would like to provide any constructive criticisms, then contact me via email java-interview@hotmail.com. Hope this blog and books help you take the road less traveled.

"talk the talk and walk the walk .... "

What gives the real job security?

There is no such thing as real job security in IT. Keeping your knowledge and skills sharp and current along with good networking, marketing, and soft skills is the best way to achieve real job security. The jobs offered on a contract basis is on the rise, and can be more rewarding for some. contract-jobs-in-IT

"The people who win are not necessarily the smartest people, but they are the people who are able to sustain drive, commitment, passion and engagement" -- by David Maiser

Attend more interviews with better Resume/CV

Get more job offers with better interview preparation

Negotiate better salaries/rates with multiple job offers

Web Services Interview Questions and Answers - RESTful Web Service Overview

2012-02-13T21:12:00.000-08:00

Q. Why would you use a RESTful Web service?
A. RESTful Web service is easy, straightforward, supports multiple data formats like XML, JSON, etc and easily testable. For example,

It can be tested by

1. Directly invoking the service from the browser by typing a URL if the RESTFul service supports GET request with query parameters. For example,

http://localhost:8080/executionservices/execution/1.0/order/create?accountId=123&qty=25

2. You could use a Firefox plugin like "poster" to post an XML request to your service.

3. You could write a Web Service client to consume the Web service from a test class or a separate application client. You could use libraries like HttpClient, CXF Client, URLConnection, etc to connect to the RESTful service.

Q. What are the various implementations of JAX-RS available to choose from in Java?
A. When you're developing with REST in Java, you have a lot of options to choose from in terms of the frameworks. There's Jersey, the reference implementation from Oracle, then you have RestEasy, the JBoss choice, and there is CXF, the Apache choice.

Q. How would you go about implemnting the RESTful Web service using the framework of your choice?
A. Let's look at CXF as it is easy to configure. The steps involved include

Bringing in the relevant framework jar files for Spring and CXF. For example, via Maven using a pom.xml file.
If the request and responses are XML based POST, then define an XSD file and generate JAXB annotated classes for marshalling and unmarshalling the request and response.
Define the WebService interface and implementation classes.
Define any interceptor and filter classes if required to intercept the request and responses for implementing the cross-cutting concerns like security validation, logging, auditing, setting up or initializing the locale, etc
Wire up the classes via Spring and CXF config files. For example, webservices-config.xml and cxf.xml.
Finally define the CXF servlet and bootstrap the relevant config files via the web.xml file.

Firstly, configure the maven pom.xml file to include the relevant jar files.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>3.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>3.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxrs</artifactId>
    <version>2.2.3</version>
</dependency>

Define the request and response objects with JAXB annotations as our Web service payload is XML, hence it needs to be marshalled (i.e. convert from object to XML) and unmarshalled (XML to object). OrderRequest & OrderResponse classes can be generated from XSD file OrderRequestResponde.xsd shown below.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema version="1.0" xmlns:xs="http://www.w3.org/2001/XMLSchema">

   <xs:complexType name="OrderResponse">
      <xs:sequence>
         <xs:element name="orderId" type="xs:string" minOccurs="0" />
         <xs:element name="responseCode" type="responseCode" minOccurs="0" />
         <xs:element name="accountId" type="xs:string" minOccurs="0" />
      </xs:sequence>
   </xs:complexType>

   <xs:complexType name="OrderRequest">
      <xs:sequence>
         <xs:element name="accountId" type="xs:string" minOccurs="0" />
         <xs:element name="quantity" type="xs:int" minOccurs="0" />
      </xs:sequence>
   </xs:complexType>

   <xs:simpleType name="responseCode">
      <xs:restriction base="xs:string">
         <xs:enumeration value="SUCCESS" />
         <xs:enumeration value="FAILED" />
         <xs:enumeration value="REJECTED" />
         <xs:enumeration value="UNKNOWN" />
      </xs:restriction>
   </xs:simpleType>

</xs:schema>

The .java files can be generated via the xjc command to generate JAXB annotated classes. The OrderRequest.java, OrderResponse.java, ResponseCode.java and ObjectFactory.java files are generated under the package "com.myapp.data.order".

xjc -d "c:\temp" -p "com.myapp.data.order" "C:\temp\xsd\OrderRequestResponde.xsd" -extension

Here are the generated files:

OrderRequest.java

//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.3 in JDK 1.6 
// See http://java.sun.com/xml/jaxb 
// Any modifications to this file will be lost upon recompilation of the source schema. 
// Generated on: 2012.02.07 at 05:07:31 PM EST 
//


package com.myapp.data.order;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;


/**
 * Java class for OrderRequest complex type.
 * 
 * 
The following schema fragment specifies the expected content contained within this class.
 * 
 * 
* <complexType name="OrderRequest">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <element name="accountId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="quantity" type="{http://www.w3.org/2001/XMLSchema}int" minOccurs="0"/>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 * * 
 * 
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "OrderRequest", propOrder = {
    "accountId",
    "quantity"
})
public class OrderRequest {

    protected String accountId;
    protected Integer quantity;

    /**
     * Gets the value of the accountId property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getAccountId() {
        return accountId;
    }

    /**
     * Sets the value of the accountId property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setAccountId(String value) {
        this.accountId = value;
    }

    /**
     * Gets the value of the quantity property.
     * 
     * @return
     *     possible object is
     *     {@link Integer }
     *     
     */
    public Integer getQuantity() {
        return quantity;
    }

    /**
     * Sets the value of the quantity property.
     * 
     * @param value
     *     allowed object is
     *     {@link Integer }
     *     
     */
    public void setQuantity(Integer value) {
        this.quantity = value;
    }

}

OrderResponse.java

//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.3 in JDK 1.6 
// See http://java.sun.com/xml/jaxb 
// Any modifications to this file will be lost upon recompilation of the source schema. 
// Generated on: 2012.02.07 at 05:07:31 PM EST 
//


package com.myapp.data.order;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;


/**
 * Java class for OrderResponse complex type.
 * 
 * 
The following schema fragment specifies the expected content contained within this class.
 * 
 * 
* <complexType name="OrderResponse">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <element name="orderId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="responseCode" type="{}responseCode" minOccurs="0"/>
 *         <element name="accountId" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 * * 
 * 
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "OrderResponse", propOrder = {
    "orderId",
    "responseCode",
    "accountId"
})
public class OrderResponse {

    protected String orderId;
    protected ResponseCode responseCode;
    protected String accountId;

    /**
     * Gets the value of the orderId property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getOrderId() {
        return orderId;
    }

    /**
     * Sets the value of the orderId property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setOrderId(String value) {
        this.orderId = value;
    }

    /**
     * Gets the value of the responseCode property.
     * 
     * @return
     *     possible object is
     *     {@link ResponseCode }
     *     
     */
    public ResponseCode getResponseCode() {
        return responseCode;
    }

    /**
     * Sets the value of the responseCode property.
     * 
     * @param value
     *     allowed object is
     *     {@link ResponseCode }
     *     
     */
    public void setResponseCode(ResponseCode value) {
        this.responseCode = value;
    }

    /**
     * Gets the value of the accountId property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getAccountId() {
        return accountId;
    }

    /**
     * Sets the value of the accountId property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setAccountId(String value) {
        this.accountId = value;
    }

}

ResponseCode.java

//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.3 in JDK 1.6 
// See http://java.sun.com/xml/jaxb 
// Any modifications to this file will be lost upon recompilation of the source schema. 
// Generated on: 2012.02.07 at 05:07:31 PM EST 
//


package com.myapp.data.order;

import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlType;


/**
 * Java class for responseCode.
 * 
 * 
The following schema fragment specifies the expected content contained within this class.
 * 
* 
* <simpleType name="responseCode">
 *   <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *     <enumeration value="SUCCESS"/>
 *     <enumeration value="FAILED"/>
 *     <enumeration value="REJECTED"/>
 *     <enumeration value="UNKNOWN"/>
 *   </restriction>
 * </simpleType>
 * * 
 */
@XmlType(name = "responseCode")
@XmlEnum
public enum ResponseCode {

    SUCCESS,
    FAILED,
    REJECTED,
    UNKNOWN;

    public String value() {
        return name();
    }

    public static ResponseCode fromValue(String v) {
        return valueOf(v);
    }

}

The ObjectFactory.java

//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.3 in JDK 1.6 
// See http://java.sun.com/xml/jaxb 
// Any modifications to this file will be lost upon recompilation of the source schema. 
// Generated on: 2012.02.07 at 05:07:31 PM EST 
//


package com.myapp.data.order;

import javax.xml.bind.annotation.XmlRegistry;


/**
 * This object contains factory methods for each 
 * Java content interface and Java element interface 
 * generated in the com.myapp.data.order package. 
 * An ObjectFactory allows you to programatically 
 * construct new instances of the Java representation 
 * for XML content. The Java representation of XML 
 * content can consist of schema derived interfaces 
 * and classes representing the binding of schema 
 * type definitions, element declarations and model 
 * groups.  Factory methods for each of these are 
 * provided in this class.
 * 
 */
@XmlRegistry
public class ObjectFactory {


    /**
     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: com.myapp.data.order
     * 
     */
    public ObjectFactory() {
    }

    /**
     * Create an instance of {@link OrderResponse }
     * 
     */
    public OrderResponse createOrderResponse() {
        return new OrderResponse();
    }

    /**
     * Create an instance of {@link OrderRequest }
     * 
     */
    public OrderRequest createOrderRequest() {
        return new OrderRequest();
    }

}

Define the Web service interface ExecutionWebService.java.

package com.myapp.webservice.orderexecutionservices;


import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

import  com.myapp.data.order.*;

@Path("execution/1.0")
public interface ExecutionWebService {


    // -------------------------
    // Create Order
    // -------------------------
     
    @POST
    @Path("/order/create")
    @Consumes("application/xml") 
    @Produces("text/xml")
    OrderResponse createOrder(OrderRequest orderRequest);
    
    // -------------------------
    // Amend Order
    // -------------------------
    
    @POST
    @Path("/order/amend")
    @Consumes("application/xml")
    @Produces("text/xml")
    OrderResponse amendOrder(OrderRequest orderRequest);
    
    //--------------------------
    // Cancel Order
    //--------------------------
    
    @POST
    @Path("/order/cancel")
    @Consumes("application/xml")
    @Produces("text/xml")
    OrderResponse cancelOrder(OrderRequest orderRequest);

}

Define the Web service implementation class ExecutionWebServiceImpl.java. This class makes use of the back-end service class OrderService.java to talk to to the DAO layer, which is not shown here.

package com.myapp.webservice.orderexecutionservices.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.WebApplicationException;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;


import com.myapp.data.order.OrderRequest;
import com.myapp.data.order.OrderResponse;

public class ExecutionWebServiceImpl implements ExecutionWebService {

    private OrderService orderService;

    public ExecutionWebServiceImpl() {
    }

    public ExecutionWebServiceImpl(OrderService orderService) {
        this.setOrderService(orderService);
    }

    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }

    public OrderService getOrderService() {
        return orderService;
    }

    @Override
    public OrderResponse createOrder(OrderRequest orderRequest) {
        OrderResponse response = null;
        try {
      //call to back end service 
            response = getOrderService().createOrder(orderRequest);
        } catch (Exceprion e) {
            throw new WebApplicationException(e);
        }
  
        return response;
    }

    @Override
    public OrderResponse amendOrder(OrderRequest orderRequest) {
       OrderResponse response = null;
        try {
            response = getOrderService().amendOrder(orderRequest);
        } catch (Exception e) {
            throw new WebApplicationException(e);
        } 

        return response;
    }

    @Override
    public OrderResponse cancelOrder(OrderRequest orderRequest) {

        OrderResponse response = null;

        try {
            response = getOrderService().cancelOrder(orderRequest, null);
        } catch (Exception e) {
            throw new WebApplicationException(e);
        } 

        return response;
    }
}

Now, wire up the above classes using Spring and CXF configuration files.

The webservices-config.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:cxf="http://cxf.apache.org/core" 
 xmlns:jaxrs="http://cxf.apache.org/jaxrs" 
 xmlns:jaxws="http://cxf.apache.org/jaxws"
 xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd
    http://cxf.apache.org/jaxrs 
    http://cxf.apache.org/schemas/jaxrs.xsd">

 <import resource="classpath:META-INF/cxf/cxf.xml" />
 <import resource="classpath:META-INF/cxf/cxf-extension-jaxrs-binding.xml" />
 <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
 <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
 <import resource="classpath:META-INF/cxf/cxf-extension-http.xml" />

 
    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!-- Configure Execution Web Services Beans -->
    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <bean id="executionWebService" class="com.myapp.webservice.orderexecutionservices.impl.ExecutionWebServiceImpl">
  <constructor-arg ref="orderService" />
 </bean>
 
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <!-- CONFIGURE ENDPOINTS            -->
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <jaxrs:server id="executionservices" address="/executionservices/">
  <jaxrs:inInterceptors>
   <ref bean="myAppInInterceptor" />
  </jaxrs:inInterceptors>
  <jaxrs:outInterceptors>
   <ref bean="myAppOutInterceptor" />
  </jaxrs:outInterceptors>
  <jaxrs:providers>
   <ref bean="exceptionMapperInterceptor" />
  </jaxrs:providers>
  <jaxrs:serviceBeans>
   <ref bean="executionWebService" />
  </jaxrs:serviceBeans>
 </jaxrs:server>
    

 <!-- define orderService, interceptors etc. left out for brevity -->
 <!-- This can be defined in other Spring context files as well-->
 
</beans>

The cxf.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sec="http://cxf.apache.org/configuration/security"
 xmlns:http="http://cxf.apache.org/transports/http/configuration"
 xsi:schemaLocation="
          http://cxf.apache.org/configuration/security
          http://cxf.apache.org/schemas/configuration/security.xsd
          http://cxf.apache.org/transports/http/configuration
          http://cxf.apache.org/schemas/configuration/http-conf.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">

 <http:conduit name="*.http-conduit">
  <http:tlsClientParameters secureSocketProtocol="SSL" disableCNCheck="true"/>
  <http:client AllowChunking="false" ReceiveTimeout="60000"/>
 </http:conduit>
</beans>

Finally, register the CXF servlet and bootstrap the above config files via web.xml file. The web.xml file snippet is shown below.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 id="services" version="2.5">
 <display-name>webservices</display-name>

 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <!-- CONFIGURE SPRING CONTAINER -->
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->

 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
   classpath*:transactionContext.xml
   classpath*:daoContext.xml
           
   /WEB-INF/webservice-config.xml
   classpath*:/cxf.xml
   
  </param-value>
 </context-param>
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <!-- CONFIGURE CXF SERVLET      -->
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <servlet>
  <servlet-name>CXFServlet</servlet-name>
  <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>CXFServlet</servlet-name>
  <url-pattern>/*</url-pattern>
 </servlet-mapping>

 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <!-- CONFIGURE JNDI RESOURCES   -->
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <resource-ref>
  <description>My App Data Source</description>
  <res-ref-name>jdbc/dataSource/MyDB</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
 </resource-ref>
 
</web-app>

Now, the sample client that consumes the Web service.

Note that the interface classes like ExecutionWebService, OrederRequest, OrderResponse, etc will be required by both the client (i.e. the Web service consumer) and the service implementation classes like ExecutionWebServiceImpl (i.e. service provider). Hence, the interface classes need to be packaged as separate jar file to be used by both the client and the service implementation.

package com.myapp.webservice.client;

import org.apache.cxf.jaxrs.client.Client;
import org.apache.cxf.jaxrs.client.JAXRSClientFactory;

//...other imports

public class ExecutionWebServiceClient {

    private static final String EXECUTION_SERVICES_CONTEXT_ROOT = "executionservices";
    
   
    public void consumeRestWebService( ) Throws Exception {
        ExecutionWebService serviceClient = JAXRSClientFactory.create("http://localhost:8080" + EXECUTION_SERVICES_CONTEXT_ROOT, ExecutionWebService.class);
        OrderRequest request = constructOrderReqObj(); // not shown
        OrderResponse response = serviceClient.createOrder(request); 
        //... do something with the response.  
    }   
}

The URLs that we be used will be like

http://localhost:8080/executionservices/execution/1.0/order/create
http://localhost:8080/executionservices/execution/1.0/order/amend
http://localhost:8080/executionservices/execution/1.0/order/cancel

That's all to it. You can also test your Web service using the "poster" plugin for Firefox.

The request payload will be something like:

<?xml version="1.0" encoding="UTF-8"?>
<OrderRequest>
  <orderId>orderId</orderId>
  <responseCode>responseCode</responseCode>
  <accountId>accountId</accountId>
</OrderRequest>

The response payload will be something like

<?xml version="1.0" encoding="UTF-8"?>
<OrderResponse>
  <orderId>orderId</orderId>
  <responseCode>responseCode</responseCode>
  <accountId>accountId</accountId>
</OrderResponse>

Note: You could generate the payload from the XSD file within eclipse IDE by selecting the schema file and then right clicking to click on Generate --> XML. Make sure you check optional elements to be included. It will also require a root element, henc you need to wrap you r schema with something like

<xs:element name="OrderRequest" >
   
   .......
 
</xs:element>

to generate the request payload and

<xs:element name="OrderResponse" >
   
   .......
 
</xs:element>

to generate the response payload within eclipse IDE.

Other relevant links on Web Services

Web Services Interview Questions and Answers - Overview

Java Web Services Interview Questions and Answers: Overview

2012-02-09T17:31:00.000-08:00

Q. What are the different application integration styles?
A. There are a number of different integration styles like

1. Shared database
2. batch file transfer
3. Invoking remote procedures (RPC)
4. Exchanging asynchronous messages over a message oriented middle-ware (MOM).

Q. What are the different styles of Web Services used for application integration?
A. SOAP WS and RESTful Web Service

Q. What are the differences between both SOAP WS and RESTful WS?
A.

The SOAP WS supports both remote procedure call (i.e. RPC) and message oriented middle-ware (MOM) integration styles. The Restful Web Service supports only RPC integration style.

The SOAP WS is transport protocol neutral. Supports multiple protocols like HTTP(S), Messaging, TCP, UDP SMTP, etc. The REST is transport protocol specific. Supports only HTTP or HTTPS protocols.

The SOAP WS permits only XML data format.You define operations, which tunnels through the POST. The focus is on accessing the named operations and exposing the application logic as a service. The REST permits multiple data formats like XML, JSON data, text, HTML, etc. Any browser can be used because the REST approach uses the standard GET, PUT, POST, and DELETE Web operations. The focus is on accessing the named resources and exposing the data as a service. REST has AJAX support. It can use the XMLHttpRequest object. Good for stateless CRUD (Create, Read, Update, and Delete) operations.

         GET - represent()
         POST - acceptRepresention()
         PUT - storeRepresention()
         DELETE - removeRepresention()

SOAP based reads cannot be cached. REST based reads can be cached. Performs and scales better.

SOAP WS wupports both SSL security and WS-security, which adds some enterprise security features like maintaining security right up to the point where it is needed, maintaining identities through intermediaries and not just point to point SSL only, securing different parts of the message with different security algorithms, etc. The REST supports only point-to-point SSL security. The SSL encrypts the whole message, whether all of it is sensitive or not.

The SOAP has comprehensive support for both ACID based transaction management for short-lived transactions and compensation based transaction management for long-running transactions. It also supports two-phase commit across distributed resources. The REST supports transactions, but it is neither ACID compliant nor can provide two phase commit across distributed transactional resources as it is limited by its HTTP protocol.

The SOAP has success or retry logic built in and provides end-to-end reliability even through SOAP intermediaries. REST does not have a standard messaging system, and expects clients invoking the service to deal with communication failures by retrying.

Q. How would you decide what style of Web Service to use? SOAP WS or REST?
A. In general, a REST based Web service is preferred due to its simplicity, performance, scalability, and support for multiple data formats. SOAP is favored where service requires comprehensive support for security and transactional reliability.

The answer really depends on the functional and non-functional requirements. Asking the questions listed below will help you choose.

Does the service expose data or business logic? (REST is a better choice for exposing data, SOAP WS might be a better choice for logic).Do the consumers and the service providers require a formal contract? (SOAP has a formal contract via WSDL)
Do we need to support multiple data formats?
Do we need to make AJAX calls? (REST can use the XMLHttpRequest)
Is the call synchronous or asynchronous?
Is the call stateful or stateless? (REST is suited for statless CRUD operations)
What level of security is required? (SOAP WS has better support for security)
What level of transaction support is required? (SOAP WS has better support for transaction management)
Do we have limited band width? (SOAP is more verbose)
What’s best for the developers who will build clients for the service? (REST is easier to implement, test, and maintain)

Q. What tools do you use to test your Web Services?
A. SoapUI tool for SOAP WS and the Firefox "poster" plugin for RESTFul services.

Q. What is the difference between SOA and a Web service?
A.

SOA is a software design principle and an architectural pattern for implementing loosely coupled, reusable and coarse grained services. You can implement SOA using any protocols such as HTTP, HTTPS, JMS, SMTP, RMI, IIOP (i.e. EJB uses IIOP), RPC etc. Messages can be in XML or Data Transfer Objects (DTOs).

Web service is an implementation technology and one of the ways to implement SOA. You can build SOA based applications without using Web services – for example by using other traditional technologies like Java RMI, EJB, JMS based messaging, etc. But what Web services offer is the standards based and platform-independent service via HTTP, XML, SOAP, WSDL and UDDI, thus allowing interoperability between heterogeneous technologies such as J2EE and .NET.

Q. Web services when you can use traditional style middle-ware such as RPC, CORBA, RMI and DCOM?
A.

The traditional middle-wares tightly couple connections to the applications and it can break if you make any modification to your application. Tightly coupled applications are hard to maintain and less reusable. Generally do not support heterogeneity. Do not work across Internet. Can be more expensive and hard to use.

Web Services support loosely coupled connections. The interface of the Web service provides a layer of abstraction between the client and the server. The loosely coupled applications reduce the cost of maintenance and increases re-usability. Web Services present a new form of middle-ware based on XML and Web. Web services are language and platform independent. You can develop a Web service using any language and deploy it on to any platform, from small device to the largest supercomputer. Web service uses language neutral protocols such as HTTP and communicates between disparate applications by passing XML messages to each other via a Web API. Do work across internet, less expensive and easier to use.

Q. What are the different approaches to developing a SOAP based Web service?
A. 2 approaches.

The contract-first approach, where you define the contract first with XSD and WSDL and the generate the Java classes from the contract.
The contract-last approach where you define the Java classes first and then generate the contract, which is the WSDL file from the Java classes.

Note: The WSDL describes all operations that the service provides, locations of the endpoints (i.e.e where the services can be invoked), and simple and complex elements that can be passed in requests and responses.

Q. What are the pros and cons of each approach, and which approach would you prefer?

A.

Contract-first Web service

PROS:

Clients are decoupled from the server, hence the implementation logic can be revised on the server without affecting the clients.
Developers can work simultaneously on client and server side based on the contract both agreed on.
You have full control over how the request and response messages are constructed -- for example, should "status" go as an element or as an attribute? The contract clearly defines it. You can change OXM (i.e. Object to XML Mapping) libraries without having to worry if the "status" would be generated as "attribute" instead of an element. Potentially, even Web service frameworks and tool kits can be changed as well from say Apache Axis to Apache CXF, etc

CONS:

More upfront work is involved in setting up the XSDs and WSDLs. There are tools like XML Spy, Oxygen XML, etc to make things easier. The object models need to be written as well.
Developers need to learn XSDs and WSDLs in addition to just knowing Java.

Contract-last Web service

PROS:

Developers don't have to learn anything related to XSDs, WSDLs, and SOAP. The services are created quickly by exposing the existing service logic with frameworks/tool sets. For example, via IDE based wizards, etc.
The learning curve and development time can be smaller compared to the Contract-first Web service.

CONS:

The development time can be shorter to initially develop it, but what about the on going maintenance and extension time if the contract changes or new elements need to be added? In this approach, since the clients and servers are more tightly coupled, the future changes may break the client contract and affect all clients or require the services to be properly versioned and managed.
In this approach, The XML payloads cannot be controlled. This means changing your OXM libraries could cause something that used to be an element to become an attribute with the change of the OXM.

So, which approach will you choose?

The best practice is to use "contract-first", and here is the link that explains this much better with examples --> contract-first versus contract-last web services In a nutshell, the contract-last is more fragile than the "contract-first". You will have to decide what is most appropriate based on your requirements, tool sets you use, etc.

Note: More Java Web Services interview questions and answers including WSDL, SOAP, UDDI, JAXR, SAAJ, etc are covered in Java/J2EE Job Interview Companion with diagrams.

More Web services Interview Questions and Answers

Java Web Services Interview Questions and Answers: RESTful Web services

Hibernate Interview Questions and Answers: integration testing the DAO layer

2012-02-08T04:25:00.000-08:00

Before this, please refer to Hibernate Interview Questions and Answers: with annotations and Spring framework , as the examples below are extension of this blog.

Q. How would you go about integration testing your DAO (i.e. Data Access Objects) layer or your Hibernate Repository classes?
A. It is a bit tricky to write integration tests because any changes to the underlying data can make your tests to fail. For example, addition of new records, modification to existing data , etc. The key is to keep the data as static as possible. There are two possible strategies.

1. Use a separate in memory database like HSQL (i.e. Hyper Structured Query Language) Database. The data can be stored in flat text files -- say in pipe delimited format and loaded into the in memory database during test set up phase, and deleted during the test tear down phase.

2. The second alternative is to use a framework like DBUnit to extract the relevant data from a given database and convert it into XML based data sets that can be inserted into your test database during the test setUp phase and deleted in the test tear-down phase. The DBUnit takes care of the data extraction and data load.

Both the above approaches maintain static data in either xml or text based flat files and load the data during the test setup.

Q. How would you go about using an in memory database like HSQL DB?
A. It involves the following steps.

Define the data in flat files. Say in pipe delimited format.
Write the parser classes to read the data and convert them into SQL insert statements to be loaded into the HSQL DB. This is known as ETL (i.e. Extract Transform Load) operation.
Override the default hibernate datasource proprties with the HSQL DB related configuration.
Wire up the datasource override file via override-daoContext.xml, which uses the HSQL DB, and overrides the hibernate proprties from the file daoContext.xml.
Write a mock HSQL DB JNDI bootstrap class and wire it up using a Spring context file (e.g. hsqlBootstrapContext.xml).
Write a database populator class that makes use of a number of parser classes to populate the database. Also, wire this up via a Spring context file (e.g. databasePopulatorContext.xml)
Finally, the test class that bootstraps all the relevant classes via the Spring context files using dependency injection.

Define the data in a flat file say employeeSearch.txt

#employee_id, emp_code, manager_code, type, base_salary
A342|XSMITH|A456|IM|Permanent|43,500.00
A342|YSMITH|A678|IM|Contract|57,700.00

Define the parser that loads the data by reading from the above flat file. For e.g. EmployeeParser.java. This class can be further improved by moving out the methods that will be shared by other parsers to a parent class or a helper class.

package com.myapp.database;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;

public class EmployeeParser {

 private static final String DROP_SQL = "drop table tbl_employee";
    private static final String CREATE_SQL =
            "create table tbl_employee(employee_id varchar(12), emp_code varchar(12), " + 
            "manager_code  varchar(12), type  varchar(12), base_salary decimal";


    private static final String INSERT_SQL =
            "insert into tbl_employee (employee_id, emp_code, manager_code, type, base_salary) values (";

   
    public void parseEmployee(Session session) throws ParserException, IOException {
        createDatabaseTable(session);
        BufferedReader file = findFile(getFileName());
        String[] data = readLine(file);
        while (data != null) {
            Query query =
                    session.createSQLQuery(INSERT_SQL + "'" + data[0] + "','" + data[1] + "','"
                            + data[2] + "'," + data[3] +  "','" + data[4] + ")");
            query.executeUpdate();
            data = readLine(file); // read next line from the file
        }
    }
    
    
    protected String[] readLine(BufferedReader file) throws IOException {
     String[] data = null;
        String line = file.readLine();
        while (line != null && line.startsWith("#")) {
            line = file.readLine();
        }
        if (line != null) {
         data =  line.split("\\|"); //split by "|" 
        }
        return data;
    }


    private void createDatabaseTable(Session session) {
        Query query = session.createSQLQuery(DROP_SQL);
        try {
            query.executeUpdate();
        } catch (HibernateException e) {
        }
        query =  session.createSQLQuery(CREATE_SQL);
        query.executeUpdate();
    }
    
    protected BufferedReader findFile(String fileName) {
        final InputStreamReader file =
                new InputStreamReader(getClass().getClassLoader().getResourceAsStream(fileName));
        BufferedReader stream = new BufferedReader(file);
        return stream;
    }

  

    public String getFileName() {
        return "employeeSearch.txt";
    }

}

Define an override spring context file to override the actual datasource properies. For example, the actual database could be Sybase or Oracle. The override-daoContext.xml is shown below.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd"
 default-autowire="byName">

    <bean id="hibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="properties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
                <prop key="hibernate.generate_statistics">true</prop>
                <prop key="hibernate.hbm2ddl.auto">create-drop</prop>
                <prop key="hibernate.jdbc.batch_size">1000</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.use_sql_comments">true</prop>
                <prop key="hibernate.cache.use_query_cache">false</prop>
                <prop key="hibernate.cache.use_second_level_cache">false</prop>
                <prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
            </props>
        </property>
        <property name="location">
            <value>classpath:/hibernate.properties</value>
        </property>
    </bean>


</beans>

Write a JNDI based bootstrapper class HsqlDevBootstrapper.java that emulates JNDI boot strapping for your test classes. This is achieved via the Spring mock class SimpleNamingContextBuilder.

package com.myapp.test.db;
 
import javax.naming.NamingException;
 
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.mock.jndi.SimpleNamingContextBuilder;
 
/**
 * helper class to bootstrap the sybase database datasources
 */
public class HsqlDevBootstrapper  {
     
 public static final String JNDI_BINDING_DB = "java:comp/env/jdbc/dataSource/mydb";
    public static final String DRIVER_CLASS = "org.hsqldb.jdbcDriver";
 
 private SimpleNamingContextBuilder builder;  //Spring JNDI mock class
 
 /**
  * setup HSQL DB, and bind it to jndi tree
  */
 public void start() {
        try {
            builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
 
            DriverManagerDataSource ds = new DriverManagerDataSource();
            ds.setDriverClassName(DRIVER_CLASS);
            ds.setUrl("jdbc:hsqldb:mem:my_db"); //in memory HSQL DB URL
            ds.setUsername("user");
            ds.setPassword("pwd");
            builder.bind(JNDI_BINDING_DB, ds);
             
             
        } catch (NamingException e) {
            throw new BeanCreationException(e.getExplanation());
        }
    }
  
 public void stop() {
    builder.deactivate();
    builder.clear();
 }
 
}

Wire up the JNDI bootstrap class via Spring the config file hsqlBootstrapContext.xml.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd"
 default-autowire="byName">

 <bean id="hsqlBootstrapper" class="com.myapp.test.db.HsqlBootstrapper" init-method="start" destroy-method="stop"/>

</beans>

Define a DatabasePopulator.java class that populates all the relevant (i.e. associated) database tables incling tbl_employee.

package com.myapp.database;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.orm.hibernate3.HibernateTemplate;


public class DatabasePopulator {

    private final HibernateTemplate daoTemplate;

   

    public DatabasePopulator(HibernateTemplate daoTemplate) throws Exception {
        this.daoTemplate = daoTemplate;
        try {
            createDB();
        } catch (Exception e) {
            throw e;
        }
    }

 /**
   * This is where all the loading happens
   */
    public void createDB() throws HibernateException, SQLException, IOException {
        Session session = daoTemplate.getSessionFactory().openSession();
  
  Transaction tran = session.beginTransaction();
  
  //make use of the parser to read the data from a file and load it (i.e. ETL operation - Extract, Transaform, and Load)
        EmployeeParser empParser = new EmployeeParser();
  empParser.parseEmployee(session);
        
  //load other relevant data
  
        session.flush();
        tran.commit();   
    }
 
}

Wire the DatabasePopulator via Spring config file databasePopulatorContext.xml.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd"
 default-autowire="byName">

    <bean name="databasePopulator" class="com.myapp.database.DatabasePopulator">
        <constructor-arg ref="daoTemplate" />
    </bean>
 
</beans>

Finally the test class. Some of the missing Spring context files and classes were defined in a different blog entry mentioned at the beginning of this blog. The context files need to be loaded in the right order.

package com.myapp.repository;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.joda.time.DateTime;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;



@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
  "classpath:hsqlBootstrapContext.xml",
  "classpath:transactionContext.xml",
  "classpath:daoContext.xml",
        "classpath:override-daoContext.xml",
        "classpath:databasePopulatorContext.xml"
})
@TestExecutionListeners(value = { 
  DependencyInjectionTestExecutionListener.class,
  SessionBindingHibernateListener.class
})

public class EmployeeRepositoryTest {

 @Resource
 EmployeeTableRepository  tableRepository;
    
    @Test
    public void testLoadEmployee() {
 
     Assert.assertTrue(tableRepository != null);
        Emplyee employee = null; 
        try {
            employee = tableRepository.loadEmployee("A342");
        } catch (RepositoryException e) {
            fail("Load employee threw an exception " + e);
        }
  
  assertTrue(employee != null);
        assertEquals(employee.getType(), "Permanent");
  //...more assertions
       
    }
 
 
 //....test other repository methods like saveEmployee, etc.
}

Spring and Hibernate Interview Questions and Answers: AOP, interceptors, and deadlock retry

2012-02-05T21:53:00.000-08:00

Define an annotation to annotate the methods that needs deadlock retry service. E.g. DeadlockRetry.java
Define the interceptor that gets wired up via AOP to perform the retry functionality by invoking the annotated method. E.g. DeadlockRetryMethodInterceptor
Wire up the annotation and deadlock retry classes via Spring config. E.g. transactionContext.xml
Finally, annotate the method that needs perform the retry service. E.g. EmployeeServiceImpl --> saveEmployee (....)

Define a custom annotation class DeadlockRetry.java.

package com.myapp.deadlock;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface DeadlockRetry {

    int maxTries() default 21;
    int tryIntervalMillis() default 100;
    
}

Define the DeadlockRetryMethodInterceptor for performing retries. The above annotation will be bound to the following implementation via Spring.

package com.myapp.deadlock;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.exception.LockAcquisitionException;
import org.springframework.dao.DeadlockLoserDataAccessException;


public class DeadlockRetryMethodInterceptor implements MethodInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(DeadlockRetryMethodInterceptor.class);
        
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object obj = invocation.getThis();
        Method method = invocation.getMethod();
        Method targetMethod = obj.getClass().getMethod(method.getName(), method.getParameterTypes());
        DeadlockRetry dlRetryAnnotation = targetMethod.getAnnotation(DeadlockRetry.class);
        int maxTries = dlRetryAnnotation.maxTries();
        int tryIntervalMillis = dlRetryAnnotation.tryIntervalMillis();
        for (int i = 0; i < maxTries; i++) {
            try {
                LOGGER.info("Attempting to invoke " + invocation.getMethod().getName());
                Object result = invocation.proceed();    // retry
                LOGGER.info("Completed invocation of " + invocation.getMethod().getName());
                return result;
            } catch (Throwable e) {
                Throwable cause = e;
    
      //... put the logic to identify DeadlockLoserDataAccessException or LockAcquisitionException
      //...in the cause. If the execption is not due to deadlock, throw an exception 
    
            if (tryIntervalMillis > 0) {
              try {
                  Thread.sleep(tryIntervalMillis);
              } catch (InterruptedException ie) { 
                LOGGER.warn("Deadlock retry thread interrupted", ie);
              }
            }
    
        }
  
        //gets here only when all attempts have failed
        throw new RuntimeException
            ("DeadlockRetryMethodInterceptor failed to successfully execute target " 
                    + " due to deadlock in all retry attempts", 
              new DeadlockLoserDataAccessException("Created by DeadlockRetryMethodInterceptor", null));
    }    
}

Wire up the annotation and the interceptor via Spring config transactionContext.xml. Only the snippet is shown.

<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!-- Deadlock Retry AOP             -->
    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <bean id="deadlockRetryPointcut" class="org.springframework.aop.support.annotation.AnnotationMatchingPointcut">
            <constructor-arg><null/></constructor-arg>
            <constructor-arg value="com.myapp.deadlock.DeadlockRetry" />
    </bean>
 
    <bean id="deadlockRetryMethodInterceptor" lass="com.myapp.deadlock.DeadlockRetryMethodInterceptor" />
 
    <bean id="deadlockRetryPointcutAdvisor"
        class="org.springframework.aop.support.DefaultPointcutAdvisor">
            <constructor-arg ref="deadlockRetryPointcut" />
            <constructor-arg ref="deadlockRetryMethodInterceptor" />        
    </bean>

Finally, annotate the method that needs to be reried in the event of dead lock issues.

package com.myapp.service;


import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
//....other imports

public class EmployeeServiceImpl implements EmployeeService {
    
    private final EmployeeTableRepository employeeRepository;
    private PlatformTransactionManager transactionManager;
   
    public EmployeeServiceImpl(EmployeeTableRepository employeeRepository, PlatformTransactionManager transactionManager) {
        this.employeeRepository = employeeRepository;
        this.transactionManager = transactionManager;
    }


    @DeadlockRetry
    public Employee saveEmployee(Employeee employee) throws RepositoryException {
        TransactionStatus transactionStatus =
                transactionManager.getTransaction(new DefaultTransactionDefinition(
                        TransactionDefinition.PROPAGATION_REQUIRED));
        try {
            employee = this.employeeRepository.saveEmployee(employee);
        } catch (Exception e) {
            transactionManager.rollback(transactionStatus);
            throw new RepositoryException(e);
        } finally {
            if (!transactionStatus.isCompleted()) {
                transactionManager.commit(transactionStatus);
            }
        }
        return employee;
    }
 
 
 //....other methods omitted for brevity

}

The above example gives a real life example using a custom annotation and AOP (i.e. Aspect Oriented Programming).

Note: Also refer to Spring Interview Questions and Answers for explanation on interceptors.

Hibernate Interview Questions and Answers: with annotations and Spring framework

2012-01-31T19:43:00.000-08:00

Q. What are the general steps involved in creating Hibernate related class?
A. The general steps involved in creating Hibernate related classes involve the following steps

Define the domain (aka entity) objects like Employee, Address, etc to represent relevant tables in the underlying database with the appropriate annotations or using the *.hbm.xml mapping files.
Define the Repository (aka DAO -- Data Access Objects) interfaces and implementations classes that use the domain objects and the hibernate session to perform data base CRUD (Create, Read, Update and Delete) operations the hibernate way.
Define the service interfaces and the classes that make use of one or more repositories (aka DAOs) in a transactional context.A transaction manager will be used to coordinate transactions (i.e. commit or rollback) between a number of repositories.
Finally, use an IoC container like Spring framework to wire up the Hibernate classes like SessionFactory, Session, transaction manager, etc and the user defined repositories, and the service classes. A number of interceptors can be wired up as well for deadlock retry, logging, auditing, etc using Spring.

For more detail, refer to Spring and Hibernate integration Interview questions and answers

Q. How would you define a hibernate domain object with table mappings, native named queries, and custom data conversion using annotations?
A.

Firstly, define a parent domain object class for any common method implementations.

package com.myapp.domain.model;

public class MyAppDomainObject {
    
 //for example
    protected boolean isPropertyEqual(Object comparee, Object compareToo) {
        if (comparee == null) {
            if (compareToo != null) {
                return false;
            }
        } else if (!comparee.equals(compareToo)) {
            return false;
        }
        return true;
    }

}

Now, extend the common DomainObject for specific DomainObject classes.

package com.myapp.domain.model;

@Entity
@org.hibernate.annotations.Entity(selectBeforeUpdate = true)
@Table(name = "tbl_employee")
@TypeDefs(value = { @TypeDef(name = "dec", typeClass = DecimalUserType.class)})  // custom data type conversion

@NamedNativeQueries({
    @NamedNativeQuery(name = "HighSalary", query = "select * from tbl_employee where salary > :median_salary " , resultClass = Employee.class),
 @NamedNativeQuery(name = "LowSalary", query = "select * from tbl_employee where salary < :median_salary " ,  resultClass = Employee.class)
})

public class Employee extends MyAppDomainObject implements Serializable {
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "employee_id")
    private Long id;
 
    @Column(name = "emp_code")
    private String accountCode;

    @Column(name = "manager_code")
    private String adviserCode;

 
 
    @Column(name = "type")
    @Enumerated(EnumType.STRING)
    private EmployeeType type = EmployeeType.PERMANENT;
 

    @Type(type = "dec")
    @Column(name = "base_salary")
    private Decimal salary = Decimal.ZERO;
 
    @Transient
    private Decimal salaryWithBonus; //not persisted to database
 
    @Formula("base_salary*2")
    private Decimal doubleSalary;   //derived or calculated read only property
 
    @Formula("(select base_salary where type = 'Permanent' )")
    private Decimal permanantLeaveLoading;   //derived or calculated read only property
 
 
    @OneToOne(cascade = { CascadeType.REFRESH })
    @JoinColumn(name = "emp_code", insertable = false, updatable = false)
    private EmployeeExtrInfo extraInfo;

    @ManyToOne(cascade = { CascadeType.REFRESH })
    @JoinColumn(name = "manager_code", insertable = false, updatable = false)
    private Manager manager;

    @OneToMany(cascade = { ALL, MERGE, PERSIST, REFRESH }, fetch = FetchType.LAZY)
    @JoinColumn(name = "emp_code", nullable = false)
    @Cascade({ org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE_ORPHAN })
    private List<PaymentDetail> paymentDetails = new ArrayList<PaymentDetail>();

 //getters and setters omitted for brevity
 
}

The dependency classes like EmployeeExtrInfo, Manager, and PaymentDetail will be mapped in a similar manner as the Employee class. The EmployeeType enum class is shown below. Also note the verys usefull annotations like @NamedNativeQueries, @TypeDefs, and @Formula. The @Formula marks a property as derived, or calculated, read-only property, where its value is calculated at fetch time using SQL expressions.

package com.myapp.domain.model;


public enum EmployeeType {
    
    PERMANENT("Permanent"),
    CONTRACTOR("Contractor"),
    CASUAL("Casual");
    
    private String type;
    
    private EmployeeType (String type) {
        this.type = type;
    }
    
    public String getType() {
        return this.type;
    }
}

The "dec" is a custom data type, you need to define the custom data type class. The "salary" attribute will be making use of this special data type. This is ust a trivial example, but more powerful custom type conversion classes can be created.

package com.myapp.domain.model;

import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Properties;

import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType;

public class DecimalUserType implements UserType, ParameterizedType {
    public static final int PRECISION = 28;
    public static final int SCALE = 15;

    public int[] sqlTypes() {
        return new int[]{Types.DECIMAL};
    }

    public Class<Decimal> returnedClass() {
        return BigDecimal.class;
    }

    public boolean equals(Object x, Object y) {
        if (x == y) {
            return true;
        }
        if (x == null || y == null) {
            return false;
        }
        return x.equals(y);
    }

    public int hashCode(Object x) {
        return 0;
    }

    public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws SQLException {
        BigDecimal forReading = rs.getBigDecimal(names[0]);

        if (forReading == null) {
            return null;
        }

        return forReading.setScale(2, RoundingMode.HALF_EVEN);   //round to 2 decimal places
    }


    public void nullSafeSet(PreparedStatement st, Object value, int index) throws SQLException {
        if (value == null) {
            st.setNull(index, Types.NUMERIC);
            return;
        }
  
  
        BigDecimal forSaving = (BigDecimal) value;
        st.setBigDecimal(index, forSaving.setScale(2, RoundingMode.HALF_EVEN));
    }

    public Object deepCopy(Object value) {
        return value;
    }

    public boolean isMutable() {
        return false;
    }

    public Serializable disassemble(Object value) {
        return null;
    }

    public Object assemble(Serializable cached, Object owner) {
        return null;
    }

    public Object replace(Object original, Object target, Object owner) {
        return original;
    }

    public void setParameterValues(Properties parameters) {
    }
}

The named queries are also shown above with the @NamedNativeQueries and @NamedNativeQuery annotations. The parametrized values like :median_salary needs to be supplied via the Hibernate repository class that makes use of the Employee domain object. Firstly define the interface.

package com.myapp.domain.repo;

import java.util.List;


public interface EmployeeTableRepository {

 Employee saveEmployee(Employee employee) throws RepositoryException ; 
 Employee loadEmployee(Long employeeId) throws RepositoryException ;
 List<Employee> findAllEmployeesWithHighSalary(BigDecimal medianSalary) throws RepositoryException;
 List<Employee> findAllEmployeesWithLowSalary(BigDecimal medianSalary) throws RepositoryException 

}

Next the implementation of the above interface.

package com.myapp.domain.repo;


@SuppressWarnings("unchecked")
public class EmployeeTableHibernateRepository extends HibernateDaoSupport implements EmployeeTableRepository {

    public EmployeeTableHibernateRepository (HibernateTemplate hibernateTemplate) {
        setHibernateTemplate(hibernateTemplate);
    }

 //The employee objects gets constructed and passed to repo via the Business Service layer
    public Employee saveEmployee(Employee employee) throws RepositoryException {
        Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
        session.saveOrUpdate(employee);
        session.flush();
        session.evict(employee);
        return this.loadEmployee(employee.getId());
    }
 
 public Employee loadEmployee(Long employeeId) throws RepositoryException {
        Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
        Criteria crit = session.createCriteria(Employee.class);
        crit.add(Restrictions.eq("id",employeeId));
        List<Employee> employees = crit.list();
        if (employees.size() == 1) {
            return employees.get(0);
        }
  
  //this is a custom exception class
        throw new RepositoryException("Found more than one or no employee with Id:" + employeeId);
    }
 
 
 public List<Employee> findAllEmployeesWithHighSalary(BigDecimal medianSalary) throws RepositoryException {
        Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
        Query query = session.getNamedQuery("HighSalary");    // query name defined in Employee class
        query.setBigDecimal(":median_salary", medianSalary);  // query parameter defined in Employee class 
        return (List<Employee>) query.list();
    }
 
 public List<Employee> findAllEmployeesWithLowSalary(BigDecimal medianSalary) throws RepositoryException {
        Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
        Query query = session.getNamedQuery("LowSalary");     // query name defined in Employee class
        query.setBigDecimal(":median_salary", medianSalary);  // query parameter defined in Employee class 
        return (List<Employee>) query.list();
    }

    
  //other methods can be defined here
}

The Service classes shown below will be making use of the repository (or DAO) classes. The service class can use any number of the repository classes, and also responsible for cordinating the transaction as well with a TransactionManger. In the example below, we will be using the "PlatformTransactionManager" implementation provided by the Spring framework.

package com.myapp.service;

public interface EmployeeService {

   Employee saveEmployee(Employeee employee) throws RepositoryException;
   Employee loadEmployee(Long employeeId) throws RepositoryException;

}

The implementation class is shown with the transaction manager. The employeeRepository and transactionManager are dependency injected

package com.myapp.service;


import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
//....other imports

public class EmployeeServiceImpl implements EmployeeService {

    
    private final EmployeeTableRepository employeeRepository;
 private PlatformTransactionManager transactionManager;
   
    public EmployeeServiceImpl (EmployeeTableRepository employeeRepository, PlatformTransactionManager transactionManager) {
        this.employeeRepository = employeeRepository;
  this.transactionManager = transactionManager;
    }


    public Employee saveEmployee(Employeee employee) throws RepositoryException {
        TransactionStatus transactionStatus =
                transactionManager.getTransaction(new DefaultTransactionDefinition(
                        TransactionDefinition.PROPAGATION_REQUIRED));
        try {
            employee = this.employeeRepository.saveEmployee(employee);
        } catch (Exception e) {
            transactionManager.rollback(transactionStatus);
            throw new RepositoryException(e);
        } finally {
            if (!transactionStatus.isCompleted()) {
                transactionManager.commit(transactionStatus);
            }
        }
        return employee;
    }
 
 public Employee loadEmployee(Long employeeId) throws RepositoryException {
        return this.employeeRepository.loadEmployee(employeeId);
    }
 
 
 //....other methods

}

Q. How will you wire up the code snippet discussed above using Spring?
A. The following 3 Spring configuration files are used for wiring up the classes defined above.

The daoContext.xml file to define the hibernate session factory, jndi data source, hibernate properties, and the user defined domain class and the repository.
The transactionContext.xml file to define the transaction manager.
The servicesContext.xml to define the custom services class

Firstly the daoContext.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

 <bean id="dataSourceMyDB" class="org.springframework.jndi.JndiObjectFactoryBean" scope="singleton">
  <property name="jndiName">
   <value>java:comp/env/jdbc/dataSource/mydb</value>
  </property>
 </bean>

 <bean id="hibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="properties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.SybaseDialect</prop>
    <prop key="hibernate.generate_statistics">false</prop>
    <prop key="hibernate.hbm2ddl.auto">verify</prop>
    <prop key="hibernate.jdbc.batch_size">50</prop>
    <prop key="hibernate.show_sql">false</prop>
    <prop key="hibernate.format_sql">false</prop>
    <prop key="hibernate.cache.use_query_cache">false</prop>
    <prop key="hibernate.cache.use_second_level_cache">false</prop>
    <prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
   </props>
  </property>
  <property name="location">
   <value>classpath:/hibernate.properties</value>
  </property>
 </bean>
 
    <bean id="hibernateAnnotatedClasses" class="org.springframework.beans.factory.config.ListFactoryBean">
        <property name="sourceList">
            <list>
                <value>com.myapp.domain.model.Employee</value>
            </list>
        </property>
    </bean>

 <bean id="hibernateSessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  <property name="dataSource" ref="dataSourceShadow" />
  <property name="hibernateProperties">
   <ref local="hibernateProperties" />
  </property>
  <property name="entityInterceptor">
        </property>
  <property name="annotatedClasses">
      <ref local="hibernateAnnotatedClasses" />
  </property>
  <property name="annotatedPackages">
   <list></list>
  </property>
 </bean>
 
 <bean id="daoTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
  <constructor-arg index="0" ref="sessionFactory" />
  <constructor-arg index="1" value="true" />
 </bean>

 <!-- Repository beans -->
 <bean id="employeeTableRepository" class="com.myapp.domain.repo.EmployeeTableHibernateRepository">
  <constructor-arg ref="daoTemplate" />
 </bean>
 
</beans>

The transactionContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" 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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
    
    <alias name="hibernateSessionFactory" alias="sessionFactory"/>
       
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="advisorAutoProxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
    <bean id="transactionAttrSource" class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
        <property name="transactionInterceptor" ref="transactionInterceptor" />
    </bean>
    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="transactionManager" />
        <property name="transactionAttributeSource">
            <bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource" />
        </property>
    </bean>

</beans>

Finally the servicesContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <!-- CONFIGURE SERVICE BEANS         -->
 <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
 <bean id="employeeService" class="com.myapp.service.EmployeeService">
  <constructor-arg ref="employeeTableRepository" />
  <constructor-arg ref="transactionManager" />
 </bean>
 
</beans>

Q. How will you go about writing an integration or unit test for the EmployeeService described above?
A. Since the dataSource is looked up via JNDI, you need to emulate the JNDI lookup. This can be achieved with the Spring helper classes SimpleNamingContextBuilder and DriverManagerDataSource.

This involves 3 steps.

Define a bootsrapper class that emulates JNDI lookup using Spring helper classes like SimpleNamingContextBuilder and DriverManagerDataSource. For example, SybaseDevBootstrapper.java file.
Wire-up this via a Spring config file named sybaseDevBootstrapContext.xml.
Finally, write the JUnit test class EmployeeServicesSybTest.java.
Define the TestExecutionListeners if required.

Firstly the SybaseDevBootstrapper.java

package com.myapp.test.db;

import javax.naming.NamingException;

import org.springframework.beans.factory.BeanCreationException;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.mock.jndi.SimpleNamingContextBuilder;

/**
 * helper class to bootstrap the sybase database datasources
 */
public class SybaseDevBootstrapper  {
    
 public static final String JNDI_BINDING_DB = "java:comp/env/jdbc/dataSource/mydb";
    public static final String DRIVER_CLASS = "com.sybase.jdbc3.jdbc.SybDriver";

 private SimpleNamingContextBuilder builder;  //Spring JNDI emulator class

 /**
  * setup sybase databases, and bind to specific places in jndi tree
  */
 public void start() {
        try {
         builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();

         DriverManagerDataSource ds = new DriverManagerDataSource();
            ds.setDriverClassName(DRIVER_CLASS);
            ds.setUrl("jdbc:sybase:Tds:host-name:10004/my_db");
            ds.setUsername("user");
            ds.setPassword("pwd");
            builder.bind(JNDI_BINDING_DB, ds);
            
            
        } catch (NamingException e) {
            throw new BeanCreationException(e.getExplanation());
        }
    }
 
 public void stop() {
  builder.deactivate();
  builder.clear();
 }
}

Next, wire the above Java class.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd"
 default-autowire="byName">

 <bean id="sybaseDevBootstrapper" class="com.myapp.test.db.SybaseDevBootstrapper" init-method="start" destroy-method="stop"/>

</beans>

Finally the test class EmployeeServicesSybTest.java

package com.myapp.test.services;

import javax.annotation.Resource;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

//...other imports


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
  "classpath:/sybaseDevBootstrapContext.xml",
  "classpath:/transactionContext.xml",
  "classpath:/daoContext.xml",
  "classpath:/servicesContext.xml",
})
@TestExecutionListeners(value = { 
  DependencyInjectionTestExecutionListener.class,
  SessionBindingHibernateListener.class
})

public class EmployeeServicesSybTest {
 
 @Resource
 EmployeeService employeeService;
    
    @Test
    public void testSaveEmployee() throws RepositoryException {
      Assert.assertTrue(employeeService != null);
      
      Employee employee = new Emloyee();
      //....assign values here
      
      employeeService.seaveEmployee(employee);
      
    }

}

The JUnit's way of setting up cross cutting concerns like security, locale, currency, timezone, and any other pre-initilization rules for the test cases function correctly is via annoattions like @Before and @After. The Spring's TestContext framework uses the anootation @TestExecutionListeners to acheive setting up of these cross cutting concerns. In the above example, we are using the DependencyInjectionTestExecutionListener.class from the Spring framework to provide support for dependncy injection and the custom SessionBindingHibernateListener.class to bind the session to the current thread. The custom implementation shown below extends the AbstractTestExecutionListener, which is the abstract implementation of TestExecutionListener class from the Spring framework.


/**
 * Helper class for binding sessions to the current thread
 * 
 */
public class SessionBindingHibernateListener extends SessionBindingListener {
    
 private static final String BEAN_NAME = "hibernateSessionFactory";

 public SessionBindingHibernateListener() {
  super(BEAN_NAME);
 }
}


import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.orm.hibernate3.SessionHolder;
import org.springframework.test.context.TestContext;
import org.springframework.test.context.support.AbstractTestExecutionListener;
import org.springframework.transaction.support.TransactionSynchronizationManager;


/**
 * Helper class for binding sessions to the current thread
 * 
 */
public class SessionBindingListener extends AbstractTestExecutionListener {
    
    private final String beanName;
    
 public SessionBindingListener(String beanName) {
  this.beanName = beanName;
 }
    
 @Override
 public void prepareTestInstance(TestContext testContext) throws Exception {
  ApplicationContext context = testContext.getApplicationContext();
  SessionFactory sessionFactory = (SessionFactory) context.getBean(beanName);
  
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);
        session.setFlushMode(FlushMode.MANUAL);
        if (!TransactionSynchronizationManager.hasResource(sessionFactory)) {
            TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
        }
 }
}

JavaScript Interview Questions and Answers: Coding and putting all together

2012-01-26T17:18:00.000-08:00

Q. How would you go about implementing a mechanism to log clien-side JavaScript errors to the server-side log?

A. Generally a Web application will log any exceptions that occur during server-side processing. These logs are key in identifying and debugging issues with the application. But when you build rich client-side applications with lots of JavaScript code, it is really worth implementing a mechanism to log all the client side errors to the server side. The following code sample demonstrates an AJAX POST being made from the client side to the server side with the data -- error msg, the URL of the JavaScript file, and the line number where the error occured.

(function () {
    'use strict'; // throws more xecpetions, prevents, or throws errors, when relatively "unsafe" actions are taken such as accessing global object, 
                 // and disables features that are confusing or poorly thought out.

  //Return if the project and module are already present
  if (window.MYPROJECT && window.MYPROJECT.errorHandler) {
   return;
  }
 
 // Create MYPROJECT namespace if does not exist
  if (!window.MYPROJECT) {
   window.MYPROJECT = {};
  }
 
  // Create MYPROJECT.errorHandler namespace if does not exist
  if (!window.MYPROJECT.errorHandler) {
   window.MYPROJECT.errorHandler =  (function () {
 
    var config, init, logError;                             
 
    config = {
     timeout: '5000',
     errorLogURL: '/ApplicationName/LogError'   //default URL 
    };
 
    /**
     * private function to register the logError handler
     */
    init = function (errorLogURL) {
     window.onerror = logError;                                           //the onerror event on windows invoke the logerror function
     config.errorLogURL = errorLogURL || config.errorLogURL;   // if not defined use default URL
    };
 
    /**
     * private function to log error
     */
    logError = function (msg, url, lineNo) {
     
    //makes an ajax post to the server using the jQuery library
     jQuery.ajax({
      url: config.errorLogURL,                                  //URL for the AJAX POST 
      type: 'POST',
      data: {'msg' : msg, 'url' : url, 'lineNo' : lineNo},  //log msg, the URL of the .js file containing the error, and the line number of the error
      timeout: config.timeout
     });
 
     return false;
    };
 
            //public methods that can be invoked from outside 
    return { init: init, logError: logError };
   
   }());
  }
}());

The above code can be used as follows.

STEP1: Initialize when the document loads

jQuery(document).ready(function () {
 'use strict';
 MYPROJECT.ajaxErrorHandler.init('/myapp/logError');
});

STEP2: Log the error where required

if(someErrorCondition) {
    MYPROJECT.errorHandler.logError('Error message is .... ', 'test.js','36');
}

try {
    //some logic
} catch (ex) {
       MYPROJECT.errorHandler.logError(ex.message, ex.fileName, ex.lineNumber);
}

On the serverside, you could write a Java Servlet to recieve and process this ajax request by writing to the serevr log using a library like log4j.

package somepkg;
 
import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

public class ErrorLoggingServlet extends HttpServlet {

 private static Logger logger = Logger.getLogger(ErrorLoggingServlet.class);

  public void service(HttpServletRequest req, HttpServletResponse res)
             throws ServletException, IOException {
  
        //extract the request parameters  
  String msg = req.getParameter("msg");
  String file = req.getParameter("url");
  String lineNo = req.getParameter("lineNo");

   // extract the user-agent, ie browser.
   String userAgent = req.getHeader("user-agent");
        
  //log the client-side error to the server side log file
  logger.error(String.format("JSError: %s \n%s(Line:%s)\nBrowser: %s",
    trim(msg), trim(file), trim(lineNo), trim(userAgent)));
 }
 
 /**
   * Trim the input parameters before logging to avoid unfiltered input 
  * from the client side filling up the log files.
  */
  private String trim(String in) {
  return (in != null) ? in.substring(0, 100) : "";
  }
}

Q. How would you go about making an AJAX call using a JavaScript framework like jQuery to retrieve json data?
A. The sample code below uses 3 files

test3.html -- The html file with the button to click
test3.js -- The JavaScript file that makes use of the jQuery framework to make the AJAX call.
test3.json -- The json data file containing data to be retrieved via AJAX requests.

Firstly, the test3.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script language="javascript" type="text/javascript" src="jquery-1.4.2.js">
</script>
<script language="javascript" type="text/javascript" src="test3.js">
</script>


<title>Insert title here</title>
</head>
<body>
  <form>  
Click the button to fetch json data:  
     <input id="go" type="button" value="go"/>  
  </form>

</body>
</html>

Note that jquery-1.4.2.js is jQuery library.

Next, the the test3.json file

{"data" :
 { 
  "topics": 
          [
              "Java",
     "JEE",
     "JavaScript",
     "Unix"
          ]
 }
}

Finalyy, the test3.js

$(document).ready(function(){
  $('input#go').click(function() {
 $.ajax({
  type: "GET",
  url: "http://localhost:8080/webdav/test3.json",
     beforeSend: function(xhr){
          if (xhr.overrideMimeType)
         {
           xhr.overrideMimeType("application/json");
         }
       },
   dataType: "JSON",
 

  success: function(data) {
     console.log(data);
           var obj = jQuery.parseJSON(data);
     alert(obj.data.topics);
  } 
    
  
 });
  
  });
});

To run the above sample files, you need an HTTP Web server. I downloaded and installed the tomcat server (version 5), and copied the above 3 files to the sample webapp that comes with the installation. The copied folder is <tomcat-home>/webapps/webdav. The "webdav" is the web appplication context. Copy the 3 files to "webdav". Start the tomcat server via <tomcat-home>/bin/startup.bat (or startup.sh for Unix). You can now open up a browser like Firefox and enter the URL as http://localhost:8080/webdav/test3.html invoke test3.html. Click on the button, and you will the json data getting alerted.

You could also check the webconsole in Firefox via Tools --> Web Developer --> Web Console (available in version 4.0 onwards). Also, download the Firebug plugin, and open the plugin. Go to the "Net" and then "XHR" tab in the plugin to view the AJAX requests being made. Also, feel free to get more familarized with the firebug, which is very handy for debugging your Web application on client side.

More JavaScript Q&A

UNIX Interview questions and answers

2012-01-23T22:49:00.000-08:00

In Core Java Career Essentials book, I had covered some of the core UNIX commands that are useful to Java developers with practical and real life examples. This blog expands on it with some handy UNIX features to complement the book.

Q. Where would you use the control operators like ";", "&&", and "||" in UNIX?
A. These control operators are used to combine different commands in a single line. There is a difference between the characters in a sense how the subsequent commands are executed. For example,

The following commands use a ";" to separate commands. This means both the commands will be executed regardless of the first command is successful (i.e. exit code of 0) or not (i.e. exit code other than 0);

$ cd Temp; echo $(pwd)

You could get an output shown below if there is folder named Temp.

/c/Temp

If the folder named Temp is not present, you will get an error and the current directory printed.

sh: cd: Temp: No such file or directory
/c

So, what if you want to only print the current directory if the first change directory command is successful? This is where the "&&" operator comes in handy.

$ cd Temp && echo $(pwd)

In the above example, the echo command will only be excuted if the change directory command is successful. If not successful, only an error will be thrown, and the current directory will not be printed. There are situations where
you might want to do the reverse. That is, execute the second command only if the first command fails. For example, make a "Temp" directory only if the change directory fails. This where the "||" operator comes in handy.

$ cd temp ||  mkdir temp && cd temp  && echo $(pwd)

If, temp directory is not found, make a new directory named temp, and if make direcory is successful, change to that directory and echo the current directory.

Q. What do you uderstand by 2>&1 in UNIX?
A. In UNIX you have STDIN, which is denoted by number 0, STDOUT, which is denoted by 1, and STDERR, which is denoted by 2. So, the above line means, the error messages go to STDERR, which is redirected to STDOUT. So, the error messages go to where ever the STDOUT goes to. For example, The following command creates a multiple directories for a maven based Java project. if the the directory creation is successful, change directory to "project" and print the directory tree structure. The STDOUT and STDERR are directed to the file named maven-project.log under the project folder.

$ mkdir -p project/{src/{main/{java,resources},test/{java,resources}}} && cd project ; find . -type  d -print  > maven-project.log

The output will be something like

.
./src
./src/main
./src/main/java
./src/main/resources
./src/test
./src/test/java
./src/test/resources

Q. What is /dev/null?
A. It is a blackhole. For example, in the earlier example, if you want to ignore error like "sh: cd: Temp: No such file or directory" being printed, you can redirect your output to /dev/null. For example

$ cd temp > /dev/null 2>&1 && echo $(pwd)

will fail silently and nothing will be printed if there is no "temp" folder. The message has gone into the blackhole. If there is a "temp" folder, the present working directory (i.e. pwd) will be printed out.

Q. How would you go about the following scenario -- You had to move to another directory temporarily to look at a file, and then move back to the directory where you were?
A. One way is to start with "/c/Temp" folder

$ cd ../projects/JMeter
$ cd ../../Temp

The better way is to use the pushd and popd commands. These commands make use of a "stack" data structure using the "Last In First Out" approach.

changes to the /c/Projects/JMeter folder and prints the stack

$ pushd ../projects/JMeter

The stack is printed as shown below.

/c/projects/JMeter /c/Temp

The /c/projects/JMeter will be popped out of the stack and the directory will change back to /c/Temp

$ popd

If you want pushd to not print the stack, you could direct the output to the black hole /dev/null as shown below.

$ pushd ../projects/JMeter > /dev/null

The above is a trivial example, but in real life, you may want to navigate between more number of directories and this stack based approach will come in very handy without having to use the "cd" command. Also, very useful in UNIX scripts. Use it astutely without having to build up a gigantic directory stack full of useless directories.

Q. In UNIX, only nine command line arguments can be accessed using positional parameters. How would you go about having access to more than 9 argumnets?
A. Using the shift command. For example, in unix, when you run a command like

$ sh test-bash.sh file1 file2 file3 file4 file5 file6 file7 file8 file9, file10, fil11

The ${0} is test-bash.sh, and ${1} is file1, ${2} file2 and so on till ${9}, which is file9. In the program, if you want to access file10 after processing file1 to file9, you need to use the "shift" command.

$ shift

All it does is move all the command line arguments to the left by 1 position. Which means the file1 will be moved out, and file2 becomes ${1} and file10 becomes ${2}. If you shift it agian, the file3 becomes ${1} and file11 becomes ${9}. In a nutshell

${#} - Total number of arguments
${0} - Command or the script name
${1},${2}, ${3} - First, second and third args respectively.
${*} - All the command line arguments starting from $1.
${@} - Same as ${*} except when it is quoted "${@}" will pass the positional parameters unevaluated. For example, echo "${@}" will print

echo "$1" "$2" ...

Q. How will you go about writing a UNIX shell script, that reads one or more data files like the one shown below and perform a particular task like logging the information in the file or making database calls to patch some data?

The test-data.txt

Server Name:Database Name:username: password
Line2-file-name1.sql
Line2-file-name2.sql
Line2-file-name3.sql

The usage of the script will be something like

$ sh test-bash.sh test-data.txt test-data2.txt test-data3.txt

A. The sample script below will be predominantly making use of the commands discussed above. If not clear, try to read and understand the above Q&As. The best way to learn is to try it out yourself. The lines starting with "#" are comments. If you do not have a UNIX environment, download a windows UNIX emularor like MSYS or CYGWIN to run it on your WINTEL platform.

The test-bash.sh.

#!/bin/bash

# usage is -->  sh Temp/test-bash.sh Temp/test-data.txt
# ${0} is  Temp/test-bash.sh 
# ${1} is  Temp/test-data.txt

echo No of arguments:  ${#}
echo Arguments are: ${*}
echo Arguments are: ${@}

#usage sub function that gets invoked by the main function.
#Echo the usage pattern and exit the script.   
usage () {
 echo Usage : $(basename ${0}) file
 exit 1
}


#log sub function that gets invoked by the main function.
log () {
 echo ${@}
 echo ${@} >> ${LOGFILE}
}


#-r means FILE exists and is readable. 
#If the file does not exists or not readable, invoke the "usage" sub routine  to print the usage
[[ -r ${1} ]] || usage


#dirname prints the directory & basename prints the file-name
echo script directory name is: $(dirname ${0})   #
echo script-name is:   $(basename ${0}) 
echo data directory name is: $(dirname ${1})
echo data-file-name is:   $(basename ${1}) 

CMDFILE=$(basename ${1})

#this will be test-data.txt.log
LOGFILE=$(basename ${1}).log

#  take the first line in the data file and
#  translate ':" to ' ' (i.e. translate colon to empty space) 
COMMAND=($(head -1 ${1} | tr ':'  ' '))

#log the first line values in the data file 
#separate with a comma
log ${COMMAND[0]},${COMMAND[1] },${COMMAND[2]}


pushd $(dirname ${1}) > /dev/null

#log an empty line
log

#log start timestamp
log BEGIN $(date)


for SQLFILE in $(sed -n '2,$p' ${CMDFILE}); do
 log  ${SQLFILE}
 # in real life execute the sql commands using an interactive SQL command. For example
 # isql -S ${COMMAND[0]} -D ${COMMAND[1]} -U ${COMMAND[2]} -P ${COMMAND[3]} < ${SQLFILE} > ${LOGFILE} 2>&1
done

#log end time stamp
log END $(date)

popd > /dev/null

# if more data files are supplied as commandline arguments shift so that second file becomes ${1} and so on
shift

#If more filenames are supplied in the commandline arguments, repeat the script for the successive filenames.
[[ ${@} ]] && ${0} ${@}

The output for

$ sh test-bash.sh test-data.txt

will be

No of arguments: 1
Arguments are: test-data.txt
Arguments are: test-data.txt
script directory name is: .
script-name is: test-bash.sh
data directory name is: .
data-file-name is: test-data.txt
Server,Name,Database

BEGIN Tue Jan 24 12:57:16 AUSEDT 2012
Line2-file-name1.sql
Line2-file-name2.sql
Line2-file-name3.sql
END Tue Jan 24 12:57:16 AUSEDT 2012

JavaScript Interview Questions and Answers: Function.call, Function.apply, and Callback functions

2012-01-10T17:16:00.000-08:00

Q. What are the different ways to invoke a function?
A. The functions can be invoked via one of the following 5 ways

function_name(param1, param2, etc); --> "this" refers to global object like window.
obj1.function_name(param1,param2,etc); --> "this" refers to obj1.
The constructor.
function_name.call(objRef, param1); //remember that the functions in JavaScript is like an object and it has it's own methods like toString(..), call(...), apply(...), etc.
function_name.apply(objRef, params[parama1,param2, etc]);

So, why use function_name.call(...) or function_name.apply( ... ) as opposed to just function_name( ... )? Let's look at this with some examples.

var x = 1;           //global variable x;

var obj1 = {x:3};   //obj1 variable x
var obj2 = {x:9};   //obj2 variable x

function function_name(message) {
   alert(message + this.x) ;
}


function_name("The number is ");              //alerts the global x --> The number is 1

//the first argument is the obj reference on which to invoke the function, and the
//the second argument is the argument to the function call
function_name.call(obj1, "The number is ");   //alerts the obj1's x --> The number is 3
function_name.call(obj2, "The number is ");   //alerts the obj2's x --> The number is 5



//the first argument is the obj reference on which to invoke the function, and the
//the second argument is the argument to the function call as an array
function_name.apply(obj1, ["The number is "]);   //alerts the obj1's x --> The number is 3
function_name.apply(obj2, ["The number is "]);   //alerts the obj2's x --> The number is 5

The purpose is of call and apply methods are to invoke the function for any object without being bound to an instance of the this object. In the above example, the this object is the global object with the x value of 1. In a function called directly without an explicit owner object, like function_name(), causes the value of this to be the default object (window in the browser). The call and apply methods allow you to pass your own object to be used as the "this" reference. In the above example, the obj1 and obj2 were used as "this" reference.

Q. What will be the alerted message for buttons 1-5 shown below?

The test.html stored under js_tutorial/html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Insert title here</title>
</head>
<body>
    <form id="someform">
       <input id="btn1" type="button" value="click-me1"/>  
       <input id="btn2" type="button" value="click-me2"/> 
       <input id="btn3" type="button" value="click-me3" onclick="buttonClicked()"/>  
       <input id="btn4" type="button" value="click-me4"/>  
       <input id="btn5" type="button" value="click-me5"/>  
    </form>
    
    <script language="javascript" type="text/javascript" src="../js/test.js">
    </script>
    
</body>
</html>

The test.js stored under js_tutorial/js.

function buttonClicked(){  
    var text = (this === window) ? 'window' : this.id;  
    alert( text );  
}  

var button1 = document.getElementById('btn1');  
var button2 = document.getElementById('btn2');  
var button4 = document.getElementById('btn4');  
var button5 = document.getElementById('btn5');  

button1.onclick = this.buttonClicked; //or just  button1.onclick = buttonClicked; 
button2.onclick = function(){   
 buttonClicked();   
};  

button4.onclick =  function(){   
 buttonClicked.call(button4);   
};  

button5.onclick =  function(){   
 buttonClicked.apply(button5);   
};

A. The "this" object passed to the buttonClicked function are as follows:

click-me1 --> btn1 ("btn1" because it's a method invocation and this will be assigned the owner object - the button input element)
click-me2 --> window (This is the same thing as when we assign the event handler directly in the element's tag as in click-me3 button)
click-me3 --> window (global object)
click-me4 --> btn4
click-me5 --> btn5

When defining event handlers via frameworks likejQuery, the library will take care of overriding the value of "this" reference to ensure that it contains a reference to the source of the event element. For example,

$('#btn1').click( function() {  
     var text = (this === window) ? 'window' : this.id;  //// jQuery ensures 'this' will be the btn1
    alert( text );  
});

The jQuery makes use of apply() and call() method calls to achieve this.

Q. What will be the output for the following code snippet?

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Insert title here</title>
</head>
<body>
    <form id="someform">
       <input id="btn1" type="button" value="click-me1" onclick="test()"/>  
    </form>
    
    <script language="javascript" type="text/javascript" src="../js/test2.js">
    </script>
    
</body>
</html>

the test2.js file.

var myobj1 = {  
  x:9, 
  myfunction:function(){
 
    if(this === window) 
     alert("x is not Defined");
 else if (this === myobj1)
     alert(this.x);
 else 
  alert("Error!");
  }
}


function test(){
 setTimeout(myobj1.myfunction, 1000);
}

A. The output in the alert will be "x is not defined". This is because the "this" will be referring to the default global object -- window. The above code can be fixed by replacing the test() function as shown below.

function test(){
 setTimeout(function(){
  myobj1.myfunction()}, 
 1000); 
}

Note: The setTimeout(..,..) method alerts only after 1 second of clicking the button.

Q. What is a callback function? Why would you need callback functions?
A. As mentioned earlier, the functions in JavaScript are actually objects. For example,

var functionAdd = new Function("arg1", "arg2", "return arg1 * arg2;");
functionAdd(5,9);  // returns 14
functionAdd(2,3);  // returns 5

So, the functions can be passed as arguments to other functions and invoked from other functions. For example,

function functionAdd(arg1, arg2, callback) {
  var result = arg1 + arg2 
  // Since we're done, let's call the callback function and pass the result
  callback(result);
}

 
// call the function
functionAdd(5, 15, function(result) {
    // this anonymous function will run when the callback is called
 console.log("callback called! " + result);
});

Why invoke the callback function when the functionAdd(..) could have executed the results? Client-side is predominantly asynchronous with following types of events.

UI Events like mouse click, on focus, value change, etc. These events are asynchronous because you don't know when a user is going to click on a button. So, callback functions need to be invoked when a button is clicked. For example JavaScript frameworks like jQuery quite often uses callback functions. Whether handling an event, iterating a collection of nodes, animating an image, or applying a dynamic filter, callbacks are used to invoke your custom code at the appropriate time.

The test.js.

$(document).ready(function(){
  $("button").click(function(){
    $("p").hide(2000,function(){
    console.log("Inside the callback function...");
   //called 2 seconds after the paragraph is hidden 
      alert("The paragraph is now hidden");
    });
  });
});

The test.html

<html>
<head>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="test.js"></script>

</head>
<body>
<button>Hide</button>
<p>The praragraph to hide when a button is clicked.</p>
</body>
</html>

Timer functions like setTimeout(function, delay), setInterval(function, delay), etc will delay the execution of a function. For example, you might want to disable a form button after it's been clicked to prevent double form submission, but then re-enable it again after a few seconds. The clearTimeout() function then allows you to cancel the callback from occuring if some other action is done which means the timeout is no longer required.
Another reason why these timers are useful is for some repetitive tasks some milliseconds apartment. The reason why the timers are used instead of a simply while (true) { ... } loop is because Javascript is a single-threaded language. So if you tie up the interpreter by executing one piece of code over and over, nothing else in the browser gets a chance to run. So, these timers allow other queued up events or functions to be executed.

Invoke myObj1.myObj1.myMethod() after 1 second.

var myObj1 = {
     myVar:12, 
  myMethod:function(){
      alert(this.x || "Not defined") ; // "Not defined" is the default if x is not defined
    }
}


setTimeout(function(){myObj1.myMethod()}, 1000);

Ajax calls are made asynchronously and when a response is received from the server, a callback method is invoked to process the response. The Ajax calls do have the following states

AJAX states:

0: The request is uninitialized (before you've called open()).
1: The request is set up, but not sent (before you've called send()).
2: The request was sent and is in process (you can usually get content headers from the response at this point).
3: The request is in process; often some partial data is available from the response, but the server isn't finished with its response.
4: The response is complete; you can get the server's response and use it.

So, you want the callback function to be invoked when the state == 4. Let's look at an example.

Here is the test2.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script language="javascript" type="text/javascript" src="ajax.js">
</script>

<title>Insert title here</title>
</head>
<body>
</body>
</html>

The ajax.js.

function processAjaxRequest(url, callback) {
    var httpRequest; // create our XMLHttpRequest object
    if (window.XMLHttpRequest) {
     //For most browsers
        httpRequest = new XMLHttpRequest();
    } else if (window.ActiveXObject) {
        //For IE
        httpRequest = new ActiveXObject("Microsoft.XMLHTTP");
    }

    //onreadystatechange event registers an anonymous (i.e. no name) function
    httpRequest.onreadystatechange = function() {
       // this is called on every state change
       if (httpRequest.readyState === 4) {
            callback.call(httpRequest.responseXML);   // call the callback function
       }
    };
    httpRequest.open('GET', url);
    httpRequest.send();
}


processAjaxRequest ("http://localhost:8000/simple", function() {
    console.log("Executing callaback function....");
    console.log("1.This will be printed when the ajax response is complete. ");   //LINE A
});

console.log("2. This will be printed before the above console.log in LINE A.");   //LINE B

Note: If you use FireFox, you can vie the console via Tools --> Web Developer --> Web Console. When you run the above example, check the web console output.

Now, for the purpse of learning JavaScript, Ajax, etc, you can create your own HTTP server with a quick and dirty approach as shown below. The Java 6, has a built in non-public API for HTTP. This approach should not be used in real life.

The Java HTTP Server

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;



public class SimpleJavaHTTPServer {

 public static void main(String[] args) throws Exception {
  HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
  server.createContext("/simple", new MyHandler());
  server.setExecutor(null); // creates a default executor
  server.start();
 }

 static class MyHandler implements HttpHandler {
  public void handle(HttpExchange t) throws IOException {
   String response = "<ajax-xml>some text</ajax-xml>";
   t.sendResponseHeaders(200, response.length());
   OutputStream os = t.getResponseBody();
   os.write(response.getBytes());
   os.close();
  }
 }
}

The LINE B will be printed before LINEA.

Note: If you run the above Java code within Java 6 or later, you will get an ajax response of <ajax-xml>some text</ajax-xml> when you invoke http://localhost:8000/simple. You may get a "restricted API" in eclipse IDE, you could overcome this by removing and adding the rt.jar via the build path or you could try the following from the preferences menu go into Java --> Compiler --> Errors/Warnings --> Depricated and Restricted API and change the "forbidden reference" from "Error" to "Warning".

More JavaScript Q&A

JavaScript Interview Questions and Answers: Closure

2012-01-10T17:13:00.000-08:00

We earlier saw that JavaScript functions are like objects, and can be passed as arguments from one function to another, can be assigned to a variable, etc.

Q. What do you understand by the term closure in JavaScript?
A. Whenever you have a function within a function, a closure is used. A closure is like local variables for functions. Let's look at an example.

var calculate = function(x) {     //outer function    
     var myconst = 2; 
     myconst++; //myconst is now 3
     return function(y) {           //inner function
         return x + y + myconst;    // has visibility to parent variable 'myconst'
     }; 
        
}  

//closure 1: each function call has its own closure
var plus5 = calculate(5);       // plus5 is now a closure to the inner function, 
                                // and has access to the outer function's values
                                // when function call exits myconst = 3 and x = 5 

console.log(plus5(3));          // returns 11  i.e. x=5, y=3, myconst=3 


//closure 2: each function call has its own closure
var plus7 = calculate(7);       // plus7 is now a closure to the inner function, 
                                // and has access to the outer function's values
                                // when function call exits const = 3 and x = 7 



console.log(plus7(4));          // returns 14  i.e. x=7, y=4, const=3

In general, when you exit out of a function, all the local variables (e.g.myconst and x) go out of scope. As per the above example, you could think that a closure is created on entry to the outer function, and the local variables are added to the closure. The closure is stored to the variable like plus5, plus7, etc and invoked by passing the value for "y". Each function call will have its own closure (e.g. plus5 and plus7)

So, a closure means the local variables of the outer function is kept alive after the function has returned.

Example 2:

function count() {
    var num = 0;    //local variable that ends up within enclosure
    var display = function() {  // the variable "display" is also part of the closure
       console.log(num++);  
    }
    
    num++; //the num is 1
    
    
    return display;
}


var  increment = count(); // num is 1

increment();    //Can be assigned to a button.
                //every time invoked displays number starting from 2, and incrementing it by 1 as in 2,3,4,etc.

In the above example, the variable "display" is also inside the closure and can be accessed by another function that might be declared inside count() or it could be accessed recursively within the "display" function itself.

Q. What will be the out put of the following JavaScript when you click on the "click-me" button that invokes the function testList()?

<form id="evaluate1">
    <input type="button" value="click-me"  onclick="testList()"/>  
</form>

function listCars (list) {
   var listOfFns = [];
   //construct and store functions
   for(var i=0; i<list.length; i++) {
      listOfFns.push(function() {console.log("The car is: "  + list[i])});
   }

   return listOfFns;
}


function testList() {
    var listOfFns = listCars(["Toyota", "Honda", "Ford", "Mazda"]);   //Line A
    //invoke the functions by looping through             
     for(var i=0; i<listOfFns.length; i++) {                          //Line B 
        listOfFns[i]();
     }

}

A: The output will be "The car is: undefined". This is because when the closure is created in "Line A" the the value of the variable "i" in function listCars(…) is 4, which is the exit condition for the for loop. Now in Line B, when you try to execute the inner function

function() {
   console.log("The car is: "  + list[i]);
}

Since the value of i in the closure is 4, the list only has 4 elements with indices 0,1,2, and 3, the index 4 is undefined. That list[4] is not defined. This is a general gotcha when working with closure and arrays.

Points to remember:

Closures are created every time you create a function in a function.
Closures give you access to variables that are defined in the parent function, and all of its parents.
Closures will help you keep your code clean and easy without having to use the global variables.

//outer function
function createTimer() {
       // inner function invoked from the outer function using closure
       function alertTimerId() {
            // the timerId is a local variable from the outer function, which is in the closure
            alert("The timer id is " + timerId);
       }
     
       //invoke the inner function from the outer.
       var timerId = window.setTimeout(alertTimerId, 1000); // alerts after 1000 ms or 1 second.
}
     
createTimer();

The setTimeout() method calls a function or evaluates an expression after a specified number of milliseconds.

setTimeout(code,millisec,lang)

code (Required) -- A reference to the function or the code to be executed
millisec (Required) -- The number of milliseconds to wait before executing the code
lang (Optional) -- The scripting language: JScript | VBScript | JavaScript

Q. What is a "module pattern"?
A. The module pattern emulates familiar OO concepts of private and public methods and attributes. It does so by utilizing closures to "hide" elements from the global scope. The public behavior is achieved by returning the private members from your object. Public functions can access the private members.

Global variables are evil, and Douglas Crockford has been teaching a useful singleton pattern for avoiding global variables. The "module pattern" creates an anonymous function, and executes it immediately. All of the code that runs inside the function lives in a closure, which provides privacy and state throughout the lifetime of our application.

(function () {
 // all vars and functions are in this scope only
 // still maintains access to all globals
}());

Note that the () around the anonymous function is required by the language, since statements that begin with the token function are always considered to be function declarations. Including () creates a function expression instead. Here is an example

var  myProject = {};   //some namespace



myProject.myModule = (function () {



 //"private" variables:

 var myPrivateVar = "myPrivateVar can be accessed only from within myProject.myModule.";



 //"private" method:

 var myPrivateMethod = function () {

  console.log("myPrivateMethod can be accessed only from within myProject.myModule");

 }



 return  {

  myPublicProperty: "myPublicProperty is accessible as myProject.myModule.myPublicProperty.",

  myPublicMethod: function () {

   console.log("myPublicMethod is accessible as myProject.myModule.myPublicMethod.");



   //Within myProject.myModule, I can access "private" vars and methods:

   console.log(myPrivateVar);

   myPrivateMethod();



   //access public members using "this" as the native scope of myPublicMethod is myProject.

   console.log(this.myPublicProperty);

  }

 };



}());





function test() {

    alert(myProject.myModule.myPublicProperty); //defined -- accessing public property

    myProject.myModule.myPublicMethod();        //defined -- accessing public method

    alert(myProject.myModule.myPrivateVar);     //undefined -- accessing private property -- NOT OKAY

    myProject.myModule.myPrivateMethod();       //myProject.myModule.myPrivateMethod is not a function -- accessing private method -- NOT OKAY

}

Pros and Cons

Pros:

Easy to pick up for software engineers, as this emulates a familiar pattern
Clean encapsulated code
Private methods and attributes

Cons:

Dependent on ordering
Accessing public methods requires repeating the parent object name
Lack of full support for private members

The Revealing Module Pattern is an extension of the Module Pattern, the main difference being that all methods and attributes are declared as private and optionally exposed in the return of the object. In the process of exposing the methods/attributes we additionally have the option of providing a different name for the exposed reference.

var  myProject = {};        //some namespace

myProject.myObject = (function() {
    var myPrivateVar = "private";
    var myPrivateFunction = function() {
     console.log("private function is called");
        return myPrivateVar;
    }
 
    return {
        publicFunctionName: myPrivateFunction
    }
}())


function test() {
    myProject.myObject.publicFunctionName();       //defined -- accessing public method
    myProject.myObject.myPrivateFunction();        // myProject.myObject.myPrivateFunction is not a function -- NOT OKAY
}

Pros and Cons

Pros:

Easier to read structure
All methods/attributes are referenced in the same way
Ability to expose members with a different name

Cons:

Lack of full support for private members

You can learn more about the JavaScript design patterns at Essential JavaScript Design Patterns For Beginners, Volume 1.-- Addy Osmani.

More JavaScript Q&A

JavaScript Interview Questions and Answers: Working with the objects

2012-01-10T15:43:00.000-08:00

Q. What are the built-in objects in JavaScript?
A. String, Date, Array, Boolean, and Math.

Q. What are the different ways to create objects in JavaScript?
A.

By invoking the built-in constructor.

var personObj1 = new Object(); // empty object with no properties and methods.
personObj1.name = "John"  ;     //add a property
personObj1.status = "Active";     //add a property
//add a method by associating a function to variable isActive variable.
personObj1.isActive = function() {
     return this.status;
}

By creating a constructor (i.e. a template), and creating an object from the constructor. The Person constructor is like any other function, and it is a convention to start the function name with an uppercase letter to differentiate it with other functions.

function Person(name, status) {
    this.name = name;
    this.status = status;
    //add a method by associating a function to variable isActive variable.
    personObj1.isActive = function() {
       return this.status;
    }  
   
}

var personObj1 = new Person("John", "Active");

Creating the object as a Hash Literal. This is what used by the JSON, which is a subset of the object literal syntax.

var personObj1 = { };    // empty object

var personObj2 = { 

   name: "John",
   status: "Active",
   isActive: function() {
       return this.status;
   }  
 
};

Q. Does JavaScript has a built-in concept of inheritance?
A. It does to some extent. You can think of every object as inheriting from it's "prototype".

Q. What is a "prototype" property?
A. A prototype is a built-in property of every JavaScript object. For example,

var personObj1 = new Object();  // empty object with no properties and methods.
personObj1.name = "John"  ;     //add a property
personObj1.status = "Active";   //add a property

Now, if you create another person object as shown below, all the properties will be empty, and needs to be reassigned.

var personObj2 = new Object();  // empty object with no properties and methods.
personObj2.name = "John"  ;     //add a property
personObj2.status = "Active";   //add a property

What if you want to set all the Person object status to be "Active" by default without having to explicitly assign it every time? This is where the "prototype" property comes in handy as shown below.

var personObj1 = new Object();            //empty object with no properties and methods.
personObj1.name = "John"  ;               //add a property
personObj1.prototype.status = "Active";   //add a prototype property that will set "Active" as the default


var personObj2 = new Object();  // empty object with status="Active" will be created.
personObj2.name = "John"  ;     // add a property

When you create an object via a constructor as in var personObj1 = new Person("John", "Active"), the prototype property is also set. When you actually create an object via a constructor, the new operator actually performs the following tasks.

STEP 1: Creates an empty object as in var personObj1 = new Object();

STEP 2: Attach all properties and methods of the prototype of the function to the resulting object.

STEP 3: Invoke the function "Person" by passing the new object as the "this" reference.

It is important to understand that, all the objects that are created via a constructor function will have the same prototype. This means, if you modify any one object that has been created via the constructor, you will be modifying all the objects that have been created and the new ones you will be creating via the constructor function. You can think of this as every object is inheriting from it's prototype. So, the above approach of individually adding to some properties as in

personObj1.prototype.status = "Active";

can be very handy for methods and constants, and this "prototype" approach is used by many JavaScript frameworks.

Q. What are some of the best practices relating to coding with JavaScript?
A.

Use proven frameworks like jQuery, EXT JS, etc to ensure cross browser compatibility, and quality code.

Provide a clean separation of content, CSS, and JavaScript. This means store all Javascript code in external script files and build pages that do not rely on Javascript to be usable.

Instead of:
```
<input id="btn1" type="button" value="click-me1" onclick="test()"/>
```
Use:
```
<input id="btn1" type="button" class="something" value="click-me1" />  
```
The above page snippet does not depend on the JavaScript function. The JQuery function below
```
$('input.something').click(function(){
    //do something here
    alert('The button is clicked');
});
```
jQuery allows you to easily attach a click event to the result(s) of your selector. So the code will select all of the <input /> tags of class “something” and attach a click event that will call the function.

Also instead of
```
if(someCondition)
    document.write("write something ........... ");
```
Use:
```
<div title="something"> ... </div>
```
```
var titleElement = $('div[title="something"]');
titleElement.text('Better Approach');
```
The above page is renedred as 100% (X)HTML without requiring the JavaScript to write something.

Use code quality tools like JSLint.

Use unit testing frameworks like Jasmine, qUnit, etc.

Use "===" instead of "==". If two operands are of the same type and value, then === produces true and !== produces false. If you use "==" or !="" you may run into issues if the operands are of different types.

Avoid using the eval(…) function as it poses a security risk and can also adversely affect performance as it accesses the JavaScript compiler.

Namespaces are essential for avoiding type name collisions. JavaScript does not have packages as in Java. But in JavaScript, this can be simulated with empty objects. For example

var MyPage1 = { };   // empty object acting as a namespace

MyPage1.Person = function(name, status) {
    this.name = name;
    this.status = status;
}

MyPage1.Person.protoyype  = 

{
    isActive: function() {
         return this.status;
    }

}


var personObj1 = new MyPage1.Person("John", "Active");
console.log(personObj1.isActive());

Simulate encapsulation with Douglas Crawford's approach as shown below as JavaScript does not have access modifiers like private, protected, etc as in Java.

function Person(name, status) {
      this.get_name = function( ) { return name; }
      this.get_status = function( ) {return status; }
}

Person.prototype.isActive = function( )
{
      return this.get_status();
}


var personObj1 = new Person("John","Active");
console.log(personObj1.isActive( )) ;

Favor the JavaScript literal way with { … } as opposed to the new Object() to create new objects as the literal way is much more robust and also makes it simpler to code and read.

Favor [ ] to declare an array as opposed to an array object with new Array( ). For example,

var vehicles = ['Car', 'Bus'] ; // creates an array


var vehicles = new Array( ); // creates an array object
vehicles[0] = ''Car" ;
vehicles[1] = 'Bus' ;

Favor using semicolons (;), and use comma separated variables as opposed to repeating vars. For example

//okay
var x = 5;
var y = 6;
var z = 9;

var x =5, y=6,z = 9; // better

Use console.log(...) as oppose to alert(...); for debugging.

More JavaScript Q&A

JavaScript Interview Questions and Answers: Overview

2012-01-08T15:14:00.000-08:00

Like me, many have a love/hate relationship with JavaScript. Now a days, JavaScript is very popular with the rich internet applications (RIA). So, it really pays to know JavaScript. JavaScript is a client side (and server side with node.js) technology that is used to dynamically manipulate the DOM tree. There are a number of JavaScript based frameworks like jQuery available to make your code more cross browser compatible and simpler. Firstly, it is much easier to understand JavaScript if you stop comparing it with Java or understand the key differences. Both are different technologies.

If you need more motivation to learn JavaScript, look at the Node.js, which is a software system designed for writing highly-scalable internet applications in JavaScript, using event-driven, asynchronous I/O to minimize overhead.

Q. What is the difference between Java and JavaScript?
A. Don't be fooled by the term Java in both. Both are quite different technologies. The key differences can be summarized as follows:

JavaScript variables are dynamically typed, whereas the Java variables are statically typed.

var myVar1 = "Hello";         //string type
var myVar2 = 5;               //number type
var myVar3 = new Object( );   //empty object type
var myVar4 = {};              //empty object type -- JSON (JavaScript Object Notation) style.

In JavaScript properties and methods are dynamically added, whereas Java uses a template called a class. The myVar3 empty object dynamically adds properties and a method.

myVar3.firstName = "Test1";  // add a property to object
   myVar3.lastName = "Test2";   // add a property to object
   // add a method
   myVar3.someFunction = function( ) {
           //.…………
   }

JavaScript function can take variable arguments. You can call the function shown below as myFunction( ), myFunction(20), or myFunction(20,5).

function myFunction( value ) {
   //.…. do something here
}

myFunction(5,10,15,20); 

function myFunction(value) {
   //value is 5;
   //arguments[0] is 5
   //arguments[1] is 10
   //arguments[2] is 15
   //arguments[3] is 20
   //arguments.length is 4
}

JavaScript objects are basically like name/value pairs stored in a HashMap<string,object>.

For example, a JavaScript object is represented in JSON style as shown below.

var personObj = {
         firstName: "John",
         lastName: "Smith",
         age: 25,
         printFullName: function() {
            document.write(this.firstName + "  " +  this.lastName);
         } ,

         printAge: function () {
            document.write("My age is: " +  this.age);
        }    
   }

You can invoke the methods as shown below

personObj.printFullName();

personObj.printAge();

JavaScript functions are objects as well. Like objects, the functions can be stored to a variable, passed as arguments, nested within each other, etc. In the above example, nameless functions are attached to variables "printFullName" and "printAge" and invoked via these variables. A function that is attached to an object via a variable is known as a "method". So, printFullName and printAge are methods.

function add(val1, val2) {
    var result = val1 + val2;
    alert("The result is:" + result);
    return result;
}

var demo = add;

function sum() {
   var output = demo(5, 2);
}

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<script language="javascript" type="text/javascript" src="../js/temp.js">
</script>

<title>Insert title here</title>
</head>
<body>
    <form id="evaluate1">
       <input type="button" value="evaluate"  onclick="sum()"/>   
       <input type="button" value="evaluate2" onclick="demo(3,2)"/>   
       <input type="button" value="evaluate3" onclick="add(2,2)"/>   
    </form>
</body>
</html>

function add(val1, val2) {
    var result = val1 + val2;
    alert("Result is:" + result);
    return result;
}


var printAdd = add.toString(); //converts the "add" function to string.

function demo() {   
    alert(printAdd); //alerts the whole source code of the "add" function
}

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<script language="javascript" type="text/javascript" src="../js/temp2.js">
</script>

<title>Insert title here</title>
</head>
<body>
    <form id="evaluate1">
       <input type="button" value="evaluate"  onclick="demo()"/>   
    </form>
</body>
</html>

The printAdd cannot be invoked from the HTML because this variable stores the string representation of the source code of the "add"function and not the function itself.

JavaScript variables need to be treated like records stored in a HasMap and referenced by name, and not by memory address or pass-by-reference as in Java. The following code snippet demonstrates this.
```
var x = function () { alert("X"); }
var y = x;
x = function () { alert("Y"); };
y();           // alerts "X" and NOT "Y"
x();           // alerts "Y"
```

Java does not support closure till atleast version 6. A closure is a function plus a binding environment. closures can be passed downwards (as parameters) or returned upwards (as return values). This allows the function to refer to variables of its environment, even if the surrounding code is no longer active. JavaScript supports closure.

In JavaScript a closure is created every time you create a function within a function. When using a closure, you will have access to all the variables in the enclosing (i.e. the parent) function.
```
var calculate = function(x) {    
     var myconst = 2; 
     return function(y) { 
         return x + y + myconst;    // has visibility to parent variable 'const'
     }; 
}  

var plus5 = calculate(5);         //plus5 is now a closure
alert(plus5(3));                  //returns 10  i.e. x=5, y=3, myconst=2 
alert(plus5(7));                  //returns 14  i.e  x=5, y=7, myconst=2 
alert(plus5(10));                 //returns 17  i.e  x=5, y=10, myconst=2 
```

Java programs can be single threaded or multi-threaded. JavaScript engines only have a single thread, forcing events like

Asynchronous UI Events like mouse click, focus, etc. It is asynchronous because you don't know when a user is going to click or change a text.

Timer functions like

var id = setTimeout(function, delay);    // Initiates a single timer which will call the specified function after the delay. The function returns a unique ID with which the timer can be canceled at a later time. 
var id = setInterval(function, delay);   // Similar to setTimeout but continually calls the function (with a delay every time) until it is canceled. 
clearInterval(id);                       // Accepts a timer ID (returned by either of the aforementioned functions) and stops the timer callback from occurring. 
clearTimeout(id);

Ajax responses asynchronously invoking a callback function when the response is sent back from the server. It is asynchronous because, you don't know how long a server will take to process the ajax request and then to send the response.

to execute within the same thread. Even though all the above time based events appear to be run concurrently, they are all executed one at a time by queuing all these events. This also mean that if a timer is blocked from immediately executing, it will be delayed until the next possible point of execution making it to wait longer than the desired delay. This might also cause the intervals execute
with no delay.

Having said this, HTML5 specifies Web Workers, which is a standardized API for multi-threading JavaScript code.

Here are the key points to remember:

JavaScript variables are dynamically typed.
In JavaScript properties and methods are dynamically added.
JavaScript function can take variable arguments.
JavaScript objects are basically like name/value pairs stored in a HashMap<string,object>.
JavaScript functions are objects as well.

Here are some working examples: For the examples shown below, the HTML files are stored under /html sub-folder and JavaScript files are stored under /js sub-folder. The console.log(…) statements are written to your browser's web console. For example, in firefox, you can view the web console via tools - Web Developer - Web Console. Make sure that the version of Firefox you use has this option. The Web Console is handy for debugging as well.

Example 1: two input values are either added or concatenated depending on their types. If both values of type number then add them, otherwise just concatenate the values. Take note of the JavaScript keywords and functions like typeof, isNaN(..), Number(..), parseInt(..), etc. The "document" is part of the DOM tree representing an HTML document in memory. The method "getElementById(...)" will return the relevant "input" element from the DOM tree, and "value" will return the input value that was entered.

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<script language="javascript" type="text/javascript" src="../js/evaluate1.js">
</script>

<title>Insert title here</title>
</head>
<body>

    <form id="evaluate1">
    
     <input id="val1" type="text" value="" />
     <input id="val2" type="text" value="" />
     <input type="button" value="evaluate"  onclick="addOrConcat()"/>
     
       
     <p>
     <div id="result"></div>
     </p>
     
    
    </form>

</body>
</html>

function addOrConcat() {
    var val1 = document.getElementById("val1").value;  //string
    var val2 = document.getElementById("val2").value;  //string
    var result = document.getElementById("result");    //object
    
    
    var ans = -1;  //number
    
    //if val1 and val2 are numbers, add them
    if(!isNaN(val1)  && typeof parseInt(val2) == 'number') {
        ans = Number(val1) + Number(val2);  //add numbers
    }else {
       ans = val1 + val2;                   //string concat
    }
    
    result.innerHTML = "Result is: "  + ans;
    //write to browser console. 
    console.log("val1 is of type " + typeof val1);
    console.log("result is of type " + typeof result);
    console.log("ans is of type " + typeof ans);
}

Example 2: Very similar to Example 1, but uses objects, and passes the relevant values from the call within HTML itself. It also uses the toString( ) method to convert a function object to display its source code.

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<script language="javascript" type="text/javascript" src="../js/evaluate3.js">
</script>

<title>Insert title here</title>
</head>
<body>

    <form id="evaluate1">
    
     <input id="val1" type="text" value="" />
     <input id="val2" type="text" value="" />
     <input type="button" value="evaluate"  onclick="addOrConcat(document.getElementById('val1').value,document.getElementById('val2').value)"/>
     
       
     <p>
     <div id="result"></div>
     </p>
     
    
    </form>

</body>
</html>

function addOrConcat(val1,val2) {
 
 var evalObj = new Object(); //create an empty object
 
 evalObj.input1 = val1;     // add a property of type string
 evalObj['input2'] = val2;  // add a property of type string
 evalObj.result = document.getElementById("result"); // add a property of type object
 
 //add a method
 evalObj.evaluate = function() { 
 
      if(!isNaN(this.input1)  && typeof parseInt(this.input2) == 'number') {
          this.ans = Number(this.input1) + Number(this.input2);  //add numbers
      }else {
          this.ans = evalObj.input1 + this.input2;              //string concat
      }
    
      this.result.innerHTML = "Result is: "  + this.ans;
    
    }
    
    evalObj.evaluate(); //call the method evaluate and "this" refers to evalObj
    console.log(evalObj.evaluate.toString());
   
}

Example 3: Similar to Example 2, with minor modifications to the JavaScript file to demonstrate keywords like "arguments"

function addOrConcat() {
 
 var evalObj = new Object();                          // create an empty object
 
 evalObj.input1 = arguments[0];                       // this is value1
 evalObj['input2'] = arguments[1];                    // this is value2
 evalObj.result = document.getElementById("result");  // add a property of type object
 
 //add a method
 evalObj.evaluate = function() { 
 
      if(!isNaN(this.input1)  && typeof parseInt(this.input2) == 'number') {
          this.ans = Number(this.input1) + Number(this.input2);  //add numbers
      }else {
          this.ans = evalObj.input1 + this.input2;              //string concat
      }
    
      this.result.innerHTML = "Result is: "  + this.ans;
    
    }
    
    evalObj.evaluate(); //call the method evaluate and "this" refers to evalObj
    console.log(evalObj.evaluate.toString());
   
}

Note: I am new to JavaScript, so feel free to point out any errors.

More JavaScript Q&A

Tricky Java interview questions and answers

2011-12-18T23:01:00.000-08:00

Q. Can interfaces contain inner classes?
A. Yes, but not recommended as it can compromise clarity and security of the code.

The interface with an inner class for demo purpose only

package innerstatic;

public interface InterfaceWithInnerClass {
    
    
    public static final Util UTIL = new Util( );
    

    public String getName(); // next node in this list

    public final static InterfaceWithInnerClass FIELD =
      //anonymous inner class as the interface field declaration  
      new InterfaceWithInnerClass() {
          public String getName() {
            return "Peter";
        }
    };

    
 //static inner class
    public static class Util {
        public String getDetail(){
            return FIELD.getName() + " age 25";
        }
    }
}

The class that implemnts the above interface.

package innerstatic;

public class Test implements InterfaceWithInnerClass {

    @Override
    public String getName() {
        return FIELD.getName() + " : " + UTIL.getDetail();
    }
    
    public static void main(String[] args) {
        System.out.println(new Test().getName());
    }
}

The output is:

Peter : Peter age 25

Q. What happens if you pass a primitive int value to a method that accepts

a) long primitive
b) float primitive
c) Float object
d) Number object

A.

a) A widening conversion takes place from int to long. So, no compile or run time error.
b) A widening conversion takes place from int to float. So, no compile or run time error.
c) compile-time error. primitive type int can be auto-boxed to type Integer, but type Integer and Float are derived from type Number, and don't have the parent child relationship. So, they cannot be implicityly or exlplicitly cast to each other.
d) primitive type int can be auto-boxed to type Integer, and then implicitly cast to type Number as Number and Integer have the parent child relationship. So, no compile or run time error.

(More similar type questions are covered with detailed answers in the book "Core Java Career Essentials")

JSF Interview Questions and Answers: event handling

2011-12-13T18:37:00.000-08:00

Q. What are the different types of JSF events?
A. JSF is an event driven framework.

Action Events: bound to UI Command objects like a Command Button or a Hyper-link. Whenever a user presses a Command Button or clicks a hyperlink these Events get generated.
Value Change Events: bound to UI Components like Text Field, Check-Box, List and Radio Buttons. The Value Change Event is fired as soon as the value that is displayed in the view is modified.
Phase Events: As you saw earlier in the JSF overview blog, the request processing life-cycle in JSF includes six phases and any JSF implementation will fire Phase events during the start and end of each phase. If we want to capture the Phase Events, then can define a Phase Listener. These are handy for debugging as well.

Q. How are events handled in JSF? What is the difference between these event handling mechanisms?
A. Action handlers and event listeners provide an event driven mechanism. Every time a user does something like clicking a button, selecting an item from a drop down, or submitting a form, an event occurs. Event notification is then sent via HTTP to the server and handled by the FacesServlet. Events can invoke custom business logic or initiate page navigation.

JSF provides two types of methods for handling events; listeners and action handlers, both of these may be defined within a managed bean. A listener takes an FacesEvent as a parameter and a void return type, while an action handler takes no parameters and returns a String.

Example 1: An event handler

<!-- login.xhtml-->
<h:inputText id="useName" />
<h:inputSecret id="password" />
<h:commandButton action="#{login.submit}">

<!-- faces-config.xml-->
<navigation-rule>
     <from-view-id>/login.xhtml</from-view-id>
  <navigation-case>
     <from-action>#{login.submit}</from-action>
  <from-outcome>success</from-outcome>
  <to-view-id></to-view-id>
  </navigation-case>    
</navigation-rule

//Login managed bean
public String submit(  ) {
      //do some action
       ....

       return "success"  //navigate to /home.jsf     
}

Example 2: An event handler with an event listener

Action listeners are provided by JSF to make it easier to handle action events. An advantage of using a listener is that the FacesEvent object provides additional information, such as the form element that initiated the event. An action handler in contrast has no knowledge of the source of the event, but based upon its return value, can initiate page navigation. The example below shows using both event handlers and event listeners.

<h:commandButton value="Search" actionListener="#{orders.confirm}" action="#{orders.search}" />

In the above example, when the button is clicked the JSF implementation calls the action listener during the Invoke Application phase. The action listener method then has a chance to perform any processing related to the command element selected by the user. You can perform any processing you need to inside the method. The method can have any name, must be public, return void, and accept an ActionEvent as its only parameter.

public void confirm(ActionEvent event) {
       int calculatedAge = calculateAgeFromDOB();
       if (event.getComponent().getId().equals("confirm")) {
            //perform some action
   ....
       }
    
    else if(event.getComponent().getId().equals("validate")){
         //perform some other action
   ....
    }
}

After the action listener method is called, the method bound by the action attribute will be called, and the JSF implementation will determine where to navigate next.

public String search( ) {
    //some action logic
 ...
 //navigation logic
 return "success";
}

Since the action listener method is called before the action handler method, the action listener method can modify the response that the action method returns.

An action listener can also be implemented as shown below.

<h:commandButton id="submitOrderSearch" value="Search" action="#{orders.search}" >
     <f:actionListener type="com.MyAppActionListenerImpl" />
</h:commandButton>

The listener class can be implemented as shown below:

package com;

...

public class MyAppActionListenerImpl implements ActionListener {

    public void processAction(ActionEvent aev) {
      System.out.println(aev.getId());
   ...
   }

}

A ValueChangeEvent is useful whenever you want to be notified when there is a change in the value of a component, such as text modification in a text field or a check box selection. Most JSF components support the valueChangeListener attribute.

<h:inputText  id="orderStatus"  valueChangeListener="#{orders.onStatusChange}" />

The managed bean method:

public void onStatusChange(ValueChangeEvent vce) {
     System.out.println(vce.getId());
  System.out.println(vce.getOldValue());
  System.out.println(vce.getNewValue());
  ....
}

This can also be implemented as shown below.

<h:inputText  id="orderStatus" >
    <f:valueChangeListener type="com.MyAppValueChangeActionListenerImpl" />
</h:imputText>

The managed bean method:

package com;

...

public class MyAppValueChangeActionListenerImpl implements ValueChangeListener {

    public void processValueChange(ValueChangeEvent vce) {
      System.out.println(vce.getId());
   System.out.println(vce.getOldValue());
      System.out.println(vce.getNewValue());
      ....
   }

}

More JSF Interview Questions and Answers

JSF Interview Questions and Answers: postback and viewstate

2011-12-09T16:39:00.000-08:00

Q. What is the difference between initial request and postback?
A. Initial request (e.g. HTTP GET) is the request that is made from a browser in order to display a page. Postback happens when the browser posts the page back to the server with form values, etc. Initial request is created by clicking a link, pasting an URL in address bar, while a postback request is create by posting a form by clicking a submit button or any post request. Initial request passes only restore View & Render Response phases, while postback request process under all phases described in the JSF life cycle diagram.

During the restore view phase of the life cycle, ViewHandler retrieves the ResponseStateManager object in order to test if the request is a postback or an initial request. If a request is a postback, the restoreView method of ViewHandler is called. This method uses the ResponseStateManager object to re-build the component tree and restore state.
The ResponseStateManager object is the only one that knows what rendering technology is being used and is therefore the only one that can look at a request, which is rendering-technology specifiec. Here are the basic steps.

An isPostBack method on ResponseStateManager returns true if the current request is a postback.
A getState method is called by the restoreView method of ViewHandler to retrieve the component tree state from the current request.
A writeState method that writes out the state to the client. This method is called by the renderView method of ViewHandler during the render response phase.

Q. What is a viewstate in JSF?
A. In JSF, there is a viewstate associated with each page, which is passed back and forth with each submits. The reason for the viewtate is that the HTTP is a stateless protocol. The state of the components across requests need to be maintained. The viewstate can change in between requests as new controls like UIInput can be added or modified. The view state is divided into two parts.

Part 1: Structure of the components
Part 2: Defines the state of the components. For example. enabled/disabled, input values, checked/unchecked, selected item, etc.

Understanding the JSF lifecycle helps understand the viewstate.

It can be achieved by either storing the viewstate on the server side in a session and then passing the viewstate id to the client via a hidden field as shown below:

Server side: In web.xml file, set the state saving strategy

<context-param>
     <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
     <param-value>server</param-value>
</context-param>

The hidden field passed to the client

<input type="hidden" name="javax.faces.ViewState" id="javax.faces.ViewState" value="cdx43wedsfdg654ed" />

Client side: serializing the view state on the client. Do the following in web.xml

<context-param>
     <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
     <param-value>client</param-value>
</context-param>

More JSF Interview Questions and Answers

JSF Interview Questions and Answers: Seam

2011-12-08T20:13:00.000-08:00

Q. How does Seam framework fit in with the JSF framework?
A. JSF's major shortcoming is its heavy reliance on the HTTP session, especially when propagating data across a sequence of pages. Seam rectifies this with a conversational scope. Seam provides some hooks into the JSF life cycle to achieve this along with other benefits.

More JSF Interview Questions and Answers

Design patterns interview Questions and answers: observer pattern

2011-12-07T22:53:00.000-08:00

The design patterns are very popular with the interviewers and Java/J2EE Job Interview Companion covers GoF design patterns, J2EEE design patterns, and EJB design patterns. This blog entry covers the observer design pattern.

Q. What is an observer design pattern?
A. The Observer pattern is a behavioral design pattern that allows an object (an Observer) to watch another object (a Subject). The subject and observer to have a publish/subscribe relationship. Observers can register to receive events from the Subject.

Some of the practical uses of observer pattern are:

When a change to one object requires changing of others, and you don't know how many objects need to be changed.
When an object should be able to notify other objects without making assumptions about who these objects are and not tightly coupling them.
When a report is received or an event occurs, a message needs to be sent to the subscribed handlers.

Examples:

Programming Swing based GUI applications where the listeners register them with events like button click, property change, etc.
Programming a stock market application to know when the price of a stock changes.
Programming a order placement or trading application to know the status changes like pending, filled, shipped, rejected, etc.

So, whenever you want to have the state change or other information, instead of polling every few second, register the observers with a subject.

Here is some pseudo code of this third scenario

STEP 1: Define the Subject and Observer interfaces

This is the subject interface

package com;

public interface ReportExecutor {
    public void addHandler(ReportHandler rh);
    public void removeHandler(ReportHandler rh);
    public void processReport(String message);
}

This is the observer interface

package com;

public interface ReportHandler {
    //handles report
    public void handleMessage(String message);
}

STEP 2: Define the concrete subject and observers.

The concrete subject

package com;

import java.util.ArrayList;
import java.util.List;

public class SalesReportExecutor implements ReportExecutor {
    
    //list of observers that register their interest in SalesReport
    private List reportHandlers = new ArrayList();

    @Override
    public void addHandler(ReportHandler rh) {
        reportHandlers.add(rh);
    }

    @Override
    public void processReport(String message) {
        for (ReportHandler reportHandler : reportHandlers) {
            reportHandler.handleMessage(message);
        }
    }

    @Override
    public void removeHandler(ReportHandler rh) {
        reportHandlers.remove(rh);

    }

}

The concrete observers

package com;

public class LoggingReportHandler implements ReportHandler {

    @Override
    public void handleMessage(String message) {
        //handles report by formatting and printing
        System.out.println("Logging report  " + message);
    }
}

package com;

public class EmailReportHandler implements ReportHandler {

    @Override
    public void handleMessage(String message) {
        //handles the report by formatting it differently and emailing.
        System.out.println("Emailing report " + message);
        //logic to email report.
    }
}

STEP 3: Finally, the JMS listener class that uses the subject. The JMS Listener class listens on a queue for presence of a report.

package com.mgl.mts.fix;

import javax.jms.Message;
import javax.jms.TextMessage;

public class MyAppListener {

    public void onMessage(Message message) {
        if (message instanceof TextMessage) {

            ReportExecutor executor = new SalesReportExecutor();
            executor.addHandler(new LoggingReportHandler());
            executor.addHandler(new EmailReportHandler());
            executor.processReport(message.toString());

        } else {
            throw new IllegalArgumentException("Message must be of type TextMessage");
        }
    }
}

Q. Can you list some Java interfaces that use the observer design pattern?
A.

The Java Message Service (JMS) models the observer pattern, with its guaranteed delivery, non-local distribution, and persistence, to name a few of its benefits. The JMS publish-subscribe messaging model allows any number of subscribers to listen to topics of interest. When a message for the published topic is produced, all the associated subscribers are notified.

The Java Foundation Classes (JFC) like JList, JTree and the JTable components manipulate data through their respective data models. The components act as observers of their data models.

In the java.util package, we have the Observer interface and the Observable class.

In an MVC (Model-View-Controller) architecture, the view gets its own data from the model or in some cases the controller may issue a general instruction to the view to render itself. In others, the view acts as an observer and is automatically notified by the model of changes in state that require a screen update.

Q. What are the pros and cons of an Observer design pattern?
A.

PROS:

Loose coupling between Subject and Observer: The subject knows only a list of observers, that implement the Observer interface, it does no know the concrete implementation of the Observer.

Broadcast communication: An event notification is broadcast to observers irrespective of the number of Observers

CONS:

If not used carefully the observer pattern can add unnecessary complexity.

The order of Observer notifications is undependable. Simply registering the observers in a particular order will not enforce their order of notification. You don't necessarily know if the first registered listener is notified first or last. If you need to have cascading notifications, where object X must be notified first, followed by object Y, you must introduce an intermediary object to enforce the ordering.

The possibility of a memory leak. A reference to the Observer is maintained by the Subject. Until the Subject releases the reference, the Observer cannot be removed by the garbage collector.

Spring Interview Questions and Answers: JNDI, JMS, other

2011-12-05T18:19:00.000-08:00

Q. How can you configure JNDI in spring application context?
A. Using "org.springframework.jndi.JndiObjectFactoryBean". For example,

Example 1:

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"   scope="singleton">
  <property name="jndiName">
   <value>java:comp/env/jdbc/dataSource/myapp_ds</value>
  </property>
 </bean>

Example 2:

<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:myapp.properties" />
<property name="ignoreUnresolvablePlaceholders" value="true" />
</bean>

The myapp.properties

jndi.naming.myapp=java:comp/env/jdbc/dataSource/myapp_ds
...

Use the property "jndi.naming.myapp"

<bean id="mfsShyDS" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>${jndi.naming.myapp}</value>
</property>
</bean>

Q. What is difference between singleton and prototype bean?
A. If you had noticed the above examples, the scope was set to "singleton". This means single bean instance per IOC container. n Spring, bean scope is used to decide which type of bean instance should be return from Spring container back to the caller.

Scopes:

singleton – Return a single bean instance per Spring IoC container

prototype – Return a new bean instance each time when requested

the default scope is singleton. The web-aware scopes are

request – Return a single bean instance per HTTP request.
session – Return a single bean instance per HTTP session.
globalSession – Return a single bean instance per global HTTP session.

Q. How would you use Spring to send JMS based messages
A. Here is some pseudocode that uses Spring with JNDI and JMS to send messages. It assumes that the ConnectionFactory and Destination values are configured via JNDI.

To send messages

Locate a ConnectionFactory, typically using JNDI.
Locate a Destination, typically using JNDI.
Create a Spring JmsTemplate with the ConnectionFactory.
Create a JmsTemplate using the ConnectionFactory.
Inject the JmsTemplate and the destination to your "MyAppMessageSender" to send messages using the jmsTemplate and the destination you just injected.
A sessiion needs to be created via the Spring class MessageCreator, and subsequently a message is created on the session created.

To receive messages

Locate a ConnectionFactory, typically using JNDI.
Locate a Destination, typically using JNDI.
Create a message listener class (e.g. com.MyAppListener)
Create a JMS message container by injecting ConnectionFactory, Destination, and the listener. The container is responsible for binding the listener to the queue.

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd"> 

 <!-- JNDI configuration -->
    <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate"> 
        <property name="environment"> 
            <props> 
                <prop key="java.naming.factory.initial">org.jnp.interfaces.NamingContextFactory</prop> 
                <prop key="java.naming.provider.url">jnp://localhost:1099</prop> 
                <prop key="java.naming.factory.url.pkgs">org.jboss.naming:org.jnp.interfaces</prop> 
                <prop key="java.naming.security.principal">admin</prop> 
                <prop key="java.naming.security.credentials">admin</prop> 
            </props> 
        </property> 
    </bean>  
  
  
    <bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean"> 
        <property name="jndiTemplate" ref="jndiTemplate" /> 
        <property name="jndiName" value="MyAppConnectionFactory" /> 
    </bean> 
 
  <bean id="jmsQueueDestination" class="org.springframework.jndi.JndiObjectFactoryBean"> 
        <property name="jndiTemplate" ref="jndiTemplate" /> 
        <property name="jndiName"> 
            <value>queue/MyAppQueue</value> 
        </property> 
    </bean> 
 
 <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
           <property name="connectionFactory" ref="jmsConnectionFactory"/>
 </bean>
 
 
 <bean id="sender" class="com.MyAppMessageSender"> 
         <property name="connectionFactory" ref="connectionFactory"/>
   <property name="queue" ref="jmsQueueDestination"> 
     
    </bean>


 <!-- POJO Messgae Listener -->
 <bean id="jmsMessageListener" class="com.MyAppListener" />
  
   
   <!-- Connects the queue to the POJO message listener -->
    <bean id="jmsContainer"  class="org.springframework.jms.listener.DefaultMessageListenerContainer"> 
        <property name="connectionFactory" ref="jmsConnectionFactory" /> 
        <property name="destination" ref="jmsQueueDestination" /> 
        <property name="messageListener" ref="jmsMessageListener" /> 
    </bean> 

  
</beans>

Here is the message sender -- com.MyAppMessageSender

package com;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;


public class MyAppMessageSender {
    
    private JmsTemplate jmsTemplate; 
    private Destination destination; 

   
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    public void setDestination(Destination destination) {
        this.destination = destination;
    } 
    
    
    public void sendMessage() { 
        this.jmsTemplate.send(this.destination, new MessageCreator() { 
            public Message createMessage(Session session) throws JMSException { 
              return session.createTextMessage("message from myapp"); 
            } 
        }); 
    } 
}

Here is the message receiver -- com.MyAppListener. The onMessage(...) method in invoked asynchronously when a message apper in the destination (e.g. Queue/Topic)

package com;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class MyAppListener implements MessageListener {
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println(((TextMessage) message).getText());
            }
            catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
        }
        else {
            throw new IllegalArgumentException("Message must be of type TextMessage");
        }
    }
}

Hibernate Interview questions and answers: cacheing

2011-12-04T21:40:00.000-08:00

Q. What is a second-level cache in Hibernate?
A. Hibernate uses two different caches for objects: first-level cache and second-level cache. First-level cache is associated with the Session object, while second-level cache is associated with the SessionFactory object. By default, Hibernate uses first-level cache on a per-transaction basis. Hibernate uses this cache mainly to reduce the number of SQL queries it needs to generate within a given transaction. For example, if an object is modified several times within the same transaction, Hibernate will generate only one SQL UPDATE statement at the end of the transaction, containing all the modifications. The second-level cache needs to be explicitly configured. Hibernate provides a flexible concept to exchange cache providers for the second-level cache. By default Ehcache is used as caching provider. However more sophisticated caching implementation can be used like the distributed JBoss Cache or Oracle Coherence.

The Hibernate configuration looks like:

<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

The ehcache.xml can be configured to cache objects of type com.myapp.Order as shown below

<cache name="com.myapp.Order"
   maxElementsInMemory="300"
   eternal="true"
   overflowToDisk="false"
   timeToIdleSeconds="300"
   timeToLiveSeconds="300"
   diskPersistent="false"
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU"       
/>

second-level cache reduces the database traffic by caching loaded objects at the SessionFactory level between transactions. These objects are available to the whole application, not just to the user running the query. The 'second-level' cache exists as long as the session factory is alive. The second-level cache holds on to the 'data' for all properties and associations (and collections if requested) for individual entities that are marked to be cached. It is imperative to implement proper cache expiring strategies as caches are never aware of changes made to the persistent store by another application. he following are the list of possible cache strategies.

Read-only: This is useful for data that is read frequently, but never updated. This is the most simplest and best-performing cache strategy.

Read/write: Read/write caches may be appropriate if your data needs to be updated. This carry more overhead than read-only caches. In non-JTA environments, each transaction should be completed when session.close() or session.disconnect() is called.
Nonstrict read/write: This is most appropriate for data that is read often but only occasionally modified.This strategy does not guarantee that two transactions won't simultaneously modify the same data.
Transactional: This is a fully transactional cache that may be used only in a JTA environment.

It can be enabled via the Hibernate mapping files as shown below:

<class name="com.myapp.Order">

    <cache usage="read-write"/>
    ....
</class>

Note: The usage options are: transactional|read-write|nonstrict-read-write|read-only. The cache can also be enabled at different granular level (e.g. parent, children, etc). The active orders will be cached for 300 seconds.

Q. How does the hibernate second-level cache work?
A. Hibernate always tries to first retrieve objects from the session and if this fails it tries to retrieve them from the second-level cache. If this fails again, the objects are directly loaded from the database. Hibernate's static initialize() method, which populates a proxy object, will attempt to hit the second-level cache before going to the database. The Hibernate class provides static methods for manipulation of proxies.

public final class Hibernate extends Object {
    ....
 public static void initialize(Object proxy)  throws HibernateException 
    .... 
}

As a consequence of using the Hibernate second-level cache, you have to be aware of the fact that each call of a data access method can either result in a cache hit or miss. So, configure your log4j.xml to log your hits and misses.

<logger name="org.hibernate.cache">
   <level value="DEBUG" />
</logger>

Alternatively, you can use Spring AOP to log the cache access on your DAO methods.

The second level cache is a powerful mechanism for improving performance and scalability of your database driven application. Read-only caches are easy to handle, while read-write caches are more subtle in their behavior. Especially, the interaction with the Hibernate session can lead to unwanted behavior.

Q. What is a query cache in Hibernate?
A. The query cache is responsible for caching the results and to be more precise the keys of the objects returned by queries. Let us have a look how Hibernate uses the query cache to retrieve objects. In order to make use of the query cache we have to modify the person loading example as follows.

Query query = session.createQuery("from Order as o where o.status=?");
query.setInt(0, "Active");
query.setCacheable(true); // the query is cacheable
List l = query.list();

You also have to change the hibernate configuration to enable the query cache. This is done by adding the following line to the Hibernate configuration.

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

Q. What ar ethe pitfalls of second level and query caches?
A. Memeory is a finite resource, and over use or incorrect useage like cacheing the Order object and all its referenced objects can cause OutOfMemoryError. Here are some tips to overcome the pitfalls relating to cacheing.

1. Set entity’s keys as query parameters, rather than setting the entire entity object. Critreia representations should also use identifiers as parameters. Write HQL queries to use identifiers in any substitutable parameters such as WHERE clause, IN clause etc.For example

In the example below, the entire customer and everything he/she references would be held in cache until either the query cache exceeds its configured limits and it is evicted, or the table is modified and the results become dirty.

final Customer customer = ... ;
final String hql = "FROM Order as order WHERE order.custOrder = ?"
final Query q = session.createQuery(hql);
q.setParameter(0, customer);
q.setCacheable(true);

Instead of setting the whole customer object as shown above, just set the id.

final Order customer = ... ;
final String hql = "from Order as order where order.cusomer.id = ?"
final Query q = session.createQuery(hql);
q.setParameter(0, customer.getId());
q.setCacheable(true);

2. Hibernate's query cache implementation is pluggable by decorating Hibernate's query cache implementation. This involves overriding the put() method to check if a canonical equivalent of a query results object already exist in the Object[][], and assign the same QueryKey if it exists.

3. If you are in a single JVM using in memory cache only, use hibernate.cache.use_structured_entries=false in your hibernate configuration.

Here are some general performance tips:

1. Session.load will always try to use the cache. Session.find does not use the cache for the primary object, but cause the cache to be populated. Session.iterate always uses the cache for the primary object and any associated objects.

2. While developing, enable the show SQL and monitor the generated SQL.

<property name="show_sql">true</property>

Also enable the "org.hibernate.cache" logger in your log4j.xml to monitor cache hits and misses.

More Hibernate Related Interview Questions and Answers

Spring Interview Questions and Answers: Hibernate integration

2011-11-30T21:03:00.000-08:00

Q. How would you integrate Hibernate with Spring?
A. The hibernate can be wired up via Spring as shown below.

STEP 1: The Hibernate properties.

   
   <!--  hibernate properties-->
   <bean id="myappHibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="properties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.SybaseDialect</prop>
                <prop key="hibernate.show_sql">false</prop>
                <prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.SingletonEhCacheProvider</prop>
            </props>
        </property>
    </bean>

STEP 2: The DataSource.

    
    
 <!-- datasource configured via JNDI-->    
  <bean id="myappDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/dataSource/myapp-ds</value>
        </property>
  </bean>

STEP 3: The hibernate mapping files. The mapping file tells Hibernate what table in the database it has to access, and what columns in that table it should use.

    
 
   <bean name="myappHibernateMappingFiles" class="org.springframework.beans.factory.config.ListFactoryBean">
        <property name="sourceList">
            <list>
                <value>hbm/Order.hbm.xml</value>
                <value>hbm/Trade.hbm.xml</value>
                <value>hbm/Customer.hbm.xml</value>
            </list>
        </property>
    </bean>

STEP 4: An empty interceptor

    
    
    <!-- An interceptor that does nothing. May be used as a base class for application-defined custom interceptors. -->
    <bean id="myappEntityInterceptor" class="org.hibernate.EmptyInterceptor" />

STEP 5: Usually an application has a single SessionFactory instance and threads servicing client requests obtain Session instances from this factory.

    
    
    <!-- Define the session factory -->
    <bean name="myappSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" autowire="byName">
        <property name="hibernateProperties">
            <ref bean="myappHibernateProperties"/>
        </property>
        <property name="dataSource">
            <ref bean="myappDataSource"/>
        </property>
        <property name="mappingResources">
            <ref bean="myappHibernateMappingFiles"/>
        </property>
        <property name="entityInterceptor">
            <ref bean="myappEntityInterceptor"/>
        </property>
    </bean>

STEP 6: The hibernate template. Helper class that simplifies Hibernate data access code.

    
    
    <!-- Hibernate Template -->
    <bean name="myappHibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate" autowire="no" scope="prototype">
        <property name="sessionFactory">
            <ref bean="myappSessionFactory"/>
        </property>
        <property name="allowCreate">
            <value>false</value>
        </property>
        <property name="maxResults">
            <value>50000</value>
        </property>
        <property name="flushMode">
            <value>3</value>
        </property>
    </bean>

STEP 7: The repository class for data access logic.

    
    
    <!-- Constructor Inject the Template into your Repository classes  (Data acess layer)  -->
     <bean id="myappOrderRepository" class="com.HibernateOrderRepository">
        <constructor-arg><ref bean="myappHibernateTemplate" /></constructor-arg>
    </bean>

STEP 8: The service class that uses one or more repositories.

    
     
     <!-- Service Layer: myappOrderRepository is injected via setter injection  -->
     <bean id="myappOrderService" class="com.OrderServiceImpl">
           <property><ref bean="myappOrderRepository" /></property>
    </bean>

STEP 9: The repository interface and class that makes use if the hibernate template.

    
package com;

import com.ObjectNotFoundException;

public interface OrderRepository {
    public Order load(Long identity) throws ObjectNotFoundException;
    public void save(Order order);
}

The template.load, template.save, etc are database operations via the HibernateTemplate.

    
package com;

import org.apache.log4j.Logger;
import org.springframework.orm.hibernate3.HibernateObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.HibernateTemplate;

import com.ObjectNotFoundException;
import com.Order;
import com.OrderRepository;


public class HibernateOrderRepository implements OrderRepository {
    
    private static final Logger LOG = Logger.getLogger(HibernateOrderRepository.class);

    private final HibernateTemplate template;
  

    public HibernateOrderRepository(HibernateTemplate template) {
        this.template = template;
    }

    @Override
    /**
     * Read Order from database
     */
    public Order load(Long identity) throws ObjectNotFoundException {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Loading " + identity);
        }
        try {
            return template.load(Order.class,identity);
        } catch (HibernateObjectRetrievalFailureException e) {
            throw new ObjectNotFoundException(identity + " not found", e);
        } 
    }

    /**
     * Save the record to database
     * @param order     */
    public void save(Order order) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Saving " + order);
        }
        template.save(order);
    }
}

Q: How do you wire up a transaction manager?
A:

STEP 1: Define a transaction manager.

<!-- Transaction Manger -->
 <bean name="myappTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="myappSessionFactory" />
    </bean>

STEP 2: Create a transaction interceptor that uses the above transaction manager.

<bean id="myappHibernateInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="myappTransactionManager" />
        <property name="transactionAttributes">
            <props>
                <prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
            </props>
        </property>
    </bean>

STEP 3: Create other optional interceptors for logging, deadlock retry, etc.

<!-- SERVICE INTERCEPTORS -->
    
    <bean id="myappLoggingInterceptor" class="com.MyAppLoggingInterceptor" />
    <bean id="myappDeadlockRetryInterceptor" class="com.OracleDeadlockRetryInterceptor" />

STEP 4: Wire up the interceptors to an abstract service

<!-- SERVICES -->
    
    <bean id="myappAbstractService" abstract="true" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interceptorNames">
            <list>
                <value>myappLoggingInterceptor</value>
                <value>myappDeadlockRetryInterceptor</value>
                <value>myappHibernateInterceptor</value>
            </list>
        </property>
    </bean>

STEP 5: The concrete service that uses the myappOrderRepository along with the interceptors. Especially the "myappHibernateInterceptor" that performs transaction demarcation.

<bean id="myappOrderService" parent="myappAbstractService">
     <property name="proxyInterfaces">
            <value>com.mgl.mts.oms.model.service.OrderService</value>
        </property>
        <property name="target">
            <bean class="com.OrderServiceImpl">
             <constructor-arg><ref bean="myappOrderRepository" /></constructor-arg>
            </bean>
        </property>
    </bean>

STEP 6 The OrderServiceImpl class looks like

package com;

import ....

public class OrderServiceImpl implements OrderService {

    private final Logger LOG = Logger.getLogger(OrderServiceImpl.class);

    private final OrderRepository orderRepository;

    public OrderServiceImpl(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
    
    //......  
}

Note: The OrderServiceImpl will have the interceptors turned using AOP to manage transaction, logging, and deadlock retry. The diagram below gives a big picture of interceptors, service, and repository.

Note: The deadlock retry filter is an interesting one. When an exception is thrown, it is inspected using a pattern matching (i.e. regular expression) to see if it is due to deadlock. If it is due to deadlock the invocation is repeated. This makes the call again to the target, which is the OrderServiceimpl via the TransactionInterceptor, which starts a new transaction.

Here is an example of the custom interceptor -- myappLoggingInterceptor. Aspect-Oriented Programming (AOP) offers a better solution to many problems. he AOP Alliance project (aopalliance-x.x.jar) is a joint open-source project between several software engineering people who are interested in AOP and Java.

package com.test;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;


public class MyAppLoggingInterceptor implements MethodInterceptor {
    
    private static final Logger LOG = Logger.getLogger(MyAppLoggingInterceptor.class);

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        long begin = System.currentTimeMillis();
        
        //proceed to the next interceptor on the chain 
        Object result = invocation.proceed();
        
        long end = System.currentTimeMillis();;
        
        LOG.info("Time elapsed " + (end - begin) + " ms");
        
        return result;
    }

}

The deadlock retry interceptor

package com.test;

import java.sql.SQLException;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;


public class OracleDeadlockRetryInterceptor implements MethodInterceptor {
    
    private static final Logger LOG = Logger.getLogger(OracleDeadlockRetryInterceptor.class);
    
    private int attempts = 3;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        return doInvoke(invocation, 1);
    }

    private Object doInvoke(MethodInvocation invocation, int count) throws Throwable {
        try {
            //proceed to next interceptor
            return invocation.proceed();
        } catch (Exception exception) {
            if (!isDeadlockException(exception)) {
                throw exception;
            }
            LOG.warn("A Database deadlock occured. Will try again.", exception);
            if (count < attempts) {
                count++;
                return doInvoke(invocation, count);
            }
            throw new SQLException("Service Invocation failed " + attempts
                        + " times with a SQLException.", exception);
        }
    }

}

More Spring Interview Questions and Answers

Are you feeling stagnated?

2011-11-30T04:51:00.000-08:00

One of the dilemmas many professionals face is when to jump the ship? versus when to steady the ship? There is no right or wrong answer to this question, and the answer depends on the individual circumstances. But here are some of my thoughts that might aid in your decision making. With the start of a new year, you may be among the millions of people thinking of making an important change in your life.

"Thanks and farewell" emails

From time to time, I receive goodbye emails, and in fact a recent email similar to the one below prompted me to write this blog entry.

Hello all,

After nearly 5 and a half years working for XYZ, it has been decided that my role will no longer be required beyond 2nd December 2011.
....
Thanks for the good times and ...............

In this scenario, it is fine if you had acquired marketable and sought-after skills to move on with your career, and not fine if your skills and knowledge were not kept up to date. Even if you find your work boring or not challenging, there is no excuse for not motivating yourself to acquire sought-after skills as there are plethora of online tutorials/articles and good books to keep your knowledge up to date. But, in a longer term, it is always better to acquire the much needed hands-on commercial experience. The skills to watch out for include technical skills, soft skills, domain knowledge, and personal traits.

Work at XYZ until you get a gold watch?

There are no more jobs like that – companies are under too much pressure to be lean and flexible (layoffs, downsizing, reorganization), so workers have to be, too (take on new challenges, acquire new skills). People jump the ship for a number of reasons like life style changes, feeling bored, burnt or stressed out, feeling stagnated, and wanting to earn more money. People steady the ship for a number of reasons like already jumped the ship too often, not ready to take on new challenges due to personal reasons, bad economy, etc. About 30 years ago, when my parents were in their working years, the prevailing notion was that an employer would "take care of you" for a long time with a secure job and a decent pension. But that's gone the way of the typewriter and carbon paper. Today, it's not uncommon to change jobs voluntarily every few years. Changing jobs (obviously, not too often) will

enhance your experience and broaden your knowledge and skills
help you build up a wider network
make you progress in your career a lot quicker.
give the confidence to find a job whenever you need to
increase your earning potential. If you are lucky enough to get a promotion with your current company, they will only give you a small increase in salary, just enough to justify the promotion and keep you. If you however require a decent promotion and increased package, changing jobs and employer is the way to go.

In fact, stability is a big goal for new workers today because the old path of staying at the same job for stability does not necessarily work for everyone. Note: Some do progress well within the same organization. Here are a few tell tale signs to jump the ship when the time is right.

Your skills are not respected. If you feel that your employer doesn’t recognize your value to the company, then it may be time for a change. When you hand in your resignation, you are asked questions like -- what can I do to keep you here?
You’re stuck in the same position, doing the same things, for nearly the same pay, for a long time, it’s time to shake things up. Be realistic of the situation, rather than deluding yourselves into believing that things will miraculously improve or what your boss tell you to convince you to stay back.
Constantly looking at your watch and being unhappy at work.

Balance is the key

You need a balance between "changing ships too often" and "not changing ships at all". Some employers in selected industry segments will wonder "what's wrong" with an individual who has not changed jobs in X years, and on the other hand, there are still many employers who will look on frequent changes unfavorably. The obvious implications for them are, that you won't stay long enough to make any significant contributions, and that if you were hired, perhaps your tendency to leave quickly will inspire many otherwise loyal employees to leave as well.

How do you go about steadying the ship?

So, if you jump the ship too often, it is imperative that you find a way to communicate your frequent changes in the past as a positive, not a negative in your resume and at job interviews. For example,

Change in career direction.
Emphasizing that one of your primary objectives in this job change is to find an employer that will provide challenges and growth opportunities over the years.
Emphasizing that stability and permanence are at the top of your list of priorities, and that the targeted company appears to be one .
Providing references to your past employers who will vouch positively for your capabilities. This is why it is vital to always move on in good terms. Never burn bridges. Networking is a key aspect in your career progression.
Focusing more on your past accomplishments in your resume and at job interviews.

Conclusion

You are the captain of your ship, and best placed to solve your dilemma based on your current circumstance and career aspirations. It is not an easy decision to make. What ever your decision is, don't base it on monetary value alone and continuously learn. Use a multi-attribute decision model like the one discussed in blog entry -- How to choose from multiple job offers? to cover all angles.

Spring Interview Questions and Answers: read properties file

2011-11-29T21:14:00.000-08:00

Q. How do you read properties file in spring?
A. PropertyPlaceholderConfigurer allows you to share a properties files. You can simply share one properties file for all of your build info or you can separate things out, and have multiple properties files in your build script.

Managing properties for an enterprise application can be a bit trickier than one might expect. The following link covers some basics around working with properties files.

Working with properties files

STEP 1: Prepare the properties file to use. The myapp.properties file contains name/value pairs as shwon below.

#statuses
order.status.rejected=REJECTED
order.status.filled=FILLED
order.status.shipped=SHIPPED

STEP 2: Define the interface and the implementation classes that read these properties.

package test;

public interface OrderNotification {
    abstract void processOrder();
}

The statuses are read from the above properties file.

package test;

import java.util.Map;

public class OrderNotificationImpl implements OrderNotification {

//read from properties file
private Map statuses;

public OrderNotificationImpl(Map statuses) {
this.statuses = statuses;
}

@Override
public void processOrder() {
//....
System.out.println(statuses.get("REJECTED"));
}
}

STEP 3: The beans3.xml that read properties file and inject relevant values.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">


 <bean id="propertyPlaceholderConfigurer"
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
   <list>
    <value>classpath:test/myapp.properties</value>
   </list>
  </property>
 </bean>


 <!-- inject properties -->
 <bean id="orderStatus" class="java.util.LinkedHashMap">
  <constructor-arg>
   <map key-type="java.lang.String" value-type="java.lang.String">
    <entry key="REJECTED">
     <value>${order.status.rejected}</value>
    </entry>
    <entry key="FILLED">
     <value>${order.status.filled}</value>
    </entry>
    <entry key="SHIPPED">
     <value>${order.status.shipped}</value>
    </entry>
   </map>
  </constructor-arg>
 </bean>

 <!-- Use the order status map-->
 <bean id="orderNotification" class="test.OrderNotificationImpl">
  <constructor-arg>
   <ref bean="orderStatus" />
  </constructor-arg>
 </bean>

</beans>

STEP 4: Finally, the standalone client application that makes use of the OrderNotification.

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring3 {
    
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] {"test/beans3.xml"});
        BeanFactory factory = (BeanFactory) appContext;
        OrderNotification orderNotification = (OrderNotification)factory.getBean("orderNotification");
        orderNotification.processOrder();
       
    }   
}

If you run the above stand-alone application, you get the following output

30/11/2011 4:09:33 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@86c347: startup date [Wed Nov 30 16:09:33 EST 2011]; root of context hierarchy
30/11/2011 4:09:33 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [test/beans3.xml]
30/11/2011 4:09:34 PM org.springframework.core.io.support.PropertiesLoaderSupport loadProperties
INFO: Loading properties file from class path resource [test/myapp.properties]
30/11/2011 4:09:34 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@6c585a: defining beans [propertyPlaceholderConfigurer,orderStatus,orderNotification]; root of factory hierarchy
REJECTED

Q. How would you go about reading environment specific property files?
A. The properties file can be loaded via a file system.

STEP 1: Have the properties files in an external file system and not within the war or ear archives.

STEP 2: The beans3.xml will have the following change -- change classpath: to file:

<bean id="propertyPlaceholderConfigurer"
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
   <list>
    <value>file:${PROPERTIES_HOME}/test/myapp_${ENV}.properties</value>
   </list>
  </property>
</bean>

STEP 3: Provide the JVM arguments PROPERTIES_HOME and ENV.

java test.TestSpring3 -DPROPERTIES_HOME=C:\\opt2\\myapp   -DENV=dev

STEP 4: The rest remain the same as previous example.

Q. How do you inject a java.util.Properties into your OrderNotification?
A.

STEP 1: Modify the OrderNotificationImpl as shown below. As you can se the, the java.utilProperties will be injected via setter injection.

package test;

import java.util.Map;
import java.util.Properties;

public class OrderNotificationImpl implements OrderNotification {
    
    private Map statuses;
    private Properties appProperties;
    
    public OrderNotificationImpl(Map statuses) {
       this.statuses = statuses;
    }

    @Override
    public void processOrder() {
        //....
        System.out.println(statuses.get("REJECTED"));
        System.out.println(appProperties.getProperty("order.status.shipped"));
    }

    public void setAppProperties(Properties appProperties) {
        this.appProperties = appProperties;
    }
}

STEP 2: Make some changes to the wiring. The beans4.xml uses the PropertiesFactoryBean and pass it to the PropertyPlaceholderConfigurer. Also, notice that the myappProperties is injected into orderNotification via setter injection.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">


 <bean id="myappProperties"
  class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="singleton" value="true" />

  <property name="ignoreResourceNotFound" value="true" />
  <property name="locations">
   <list>
    <value>classpath:test/myapp.properties</value>
   </list>
  </property>
 </bean>


    <bean id="propertyPlaceholderConfigurer"
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="properties" ref="myappProperties" /> 
 </bean>

 <!-- inject properties -->
 <bean id="orderStatus" class="java.util.LinkedHashMap">
  <constructor-arg>
   <map key-type="java.lang.String" value-type="java.lang.String">
    <entry key="REJECTED">
     <value>${order.status.rejected}</value>
    </entry>
    <entry key="FILLED">
     <value>${order.status.filled}</value>
    </entry>
    <entry key="SHIPPED">
     <value>${order.status.shipped}</value>
    </entry>
   </map>
  </constructor-arg>
 </bean>

 <!-- Use the order status map-->
 <bean id="orderNotification" class="test.OrderNotificationImpl">
  <constructor-arg>
   <ref bean="orderStatus" />
  </constructor-arg>
  <property name="appProperties" ref="myappProperties" />
 </bean>

</beans>

STEP 3: Finally, modify the TestSpring3 to use beans4.xml.

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring3 {
    
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] {"test/beans4.xml"});
        BeanFactory factory = (BeanFactory) appContext;
        OrderNotification orderNotification = (OrderNotification)factory.getBean("orderNotification");
        orderNotification.processOrder();     
    }   
}

STEP 3: Finally, modify the TestSpring3 to use beans4.xml.

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring3 {
    
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] {"test/beans4.xml"});
        BeanFactory factory = (BeanFactory) appContext;
        OrderNotification orderNotification = (OrderNotification)factory.getBean("orderNotification");
        orderNotification.processOrder();     
    }   
}

The output will be:

01/12/2011 11:15:55 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1f42b49: startup date [Thu Dec 01 11:15:55 EST 2011]; root of context hierarchy
01/12/2011 11:15:55 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [test/beans4.xml]
01/12/2011 11:15:56 AM org.springframework.core.io.support.PropertiesLoaderSupport loadProperties
INFO: Loading properties file from class path resource [test/myapp.properties]
01/12/2011 11:15:56 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@12a55aa: defining beans [myappProperties,propertyPlaceholderConfigurer,orderStatus,orderNotification]; root of factory hierarchy
REJECTED
SHIPPED

Q. How would you use annotations to inject properties?
A. Spring 3.0 makes use of annotations, and the properties can be injected

private @Value("${propertyName}") String propertyField;

More Spring Interview Questions and Answers

Java Interview Questions and Answers: working with proprties files

2011-11-29T19:01:00.000-08:00

Managing properties for an enterprise application can be a bit trickier than one might expect.

Q: How would you go about managing properties files in your application?
A: One great advantage of property files is that they let you change your application's configuration without recompilation. However, you most likely need to restart your application for the new configuration to take effect. However, you most likely need to restart your application for the new configuration to take effect. There are different types of properies files like

1. Environment independent files archived within a war or ear. These can be loaded via the classpath.

classpath:test/myapp.properties

2. Environment independent files stored outside a war or ear. These need to be loaded via a file loader. Define a JVM argument or system property for the path of the file.

file:${PROPERTIES_HOME}/test/myapp.properties

3. Environment specific files stored outside a war or ear. These need to be loaded via a file loader. Define a JVM argument or system property for the path of the file.

file:${PROPERTIES_HOME}/test/myapp_${my_env}.properties

It is a best practice to store environment specific (e.g. test, dev, uat, staging, prod, etc) files outside the war or ear archives as the same archive can be deployed to any environment without having to package environment specific archives.

4. Properties file with sensitive information. Store the property values encrypted (Triple DES) or encoded (base64) with a salt. A salt is a secret that can be stored in a database or a separate file with proper access control.

5. Dynamic information in properties file or loading a property file at runtime. For example, in your .properties file you can use

#messages
greeting=Welcome Mr. {0} {1} !!!

Then use the MessageFormat class in Java

MessageFormat.format((String) props.get("greeting"), firstName, lastName);

You can also dynamically load .properties file with the load and store methods in java.util.Properties. It is recommended to use an existing configuration library like Apache Commons Configuration to load properties file at runtime without having to bring the server or application down. The commons config does support variable interpolation.

application.title = ${application.name} ${application.version}

Finally you can use JMX (Java Management eXtension) to write your own managed bean to change proprty values at runtime. A typical real life example would be to change log4j.xml debug levels. Appropriate log levels are very handy in diagnosing problems in production, but log levels like trace or debug can adversely impact performance. Hence, it is very useful to be able to set log levels at runtime.

Here is a sample .properties file that can be used with Apache's commons configuration.

#database - encrypted
db.password=654fdgtr45#1232

#database - clear
db.host=localhost
db.user=john

#messages
greeting=Welcome Mr. {0} {1} !!!

#statuses
order.status.rejected=REJECTED
order.status.filled=FILLED
order.status.shipped=SHIPPED


# lists and arrays
colors.pie = #FF0000, #00FF00, #0000FF

#File includes -- include other .properties files
include = email.properties

Q. How would you load a properties file from a classpath or a file system?
A. Here is a very basic code snippet.

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Properties;

public class PropertiesUtil {

    public static Properties loadFromClassPath(String fileName) throws Exception {
        Properties props = new Properties();
        URL url = ClassLoader.getSystemResource(fileName);
        props.load(url.openStream());
        System.out.println(props);
        return props;
    }
    
    public static Properties loadFromFile(File propsFile) throws IOException {
        Properties props = new Properties();
        FileInputStream fis = new FileInputStream(propsFile);
        props.load(fis);    
        fis.close();
        System.out.println(props);
        return props;
    }
    
    public static void main(String[] args)  throws Exception {
        loadFromClassPath("test/myapp.properties");
        loadFromFile(new File("C:\\opt2\\myapp\\test\\myapp.properties"));
    }
}

Spring has the ability to load properties files as part of the application configuration, for use internally. The properties can be referenced within spring configuration files using ant-style placeholders, e.g. ${app.var}. Here is the link to step by step tutorial.

Spring Interview Questions and Answers: read from properties file

Spring Interview Questions and Answers : Spring Bean life cycle, DI, and IOC

2011-11-27T22:26:00.000-08:00

Q. Can you describe the bean life cycle?
A. A Spring Bean represents a POJO (Plain Old Java Object) performing useful operation(s). All Spring Beans reside within a Spring IOC Container. The Spring Framework hides most of the complex infrastructure and the communication that happens between the Spring Container and the Spring Beans. The state-chart diagram below highlights these communications.

Q. What is a BeanFactory?
A. The BeanFactory is the actual container which instantiates, configures, and manages a number of beans. These beans typically collaborate with one another, and thus have dependencies between themselves.

Q. How would you go about wiring up the spring managed bean dependencies?
A. In general, the dependencies are wired via the Spring config file. For example, the MyBeanService depends on MyBeanDao, and MyBean depends on MyBeanService, etc via either constructor or setter injection.

Here is the big picture of the collaborating classes and interfaces.

Here are the libraries ( highlighted in blue rectangle) that needs to be in the classpath.The commons-logging is used by the spring-beans-xx.jar.

STEP 1: Firstly define the relevant interfaces. Coding to interfaces is a good design parctice that loosely couples your classes.

package test;

public interface MyBeanDao {
   abstract void daoMethod();
}

package test;

public interface MyBeanService {
    abstract void serviceMethod();
}

Now, define the concrete implementation for the above interfaces.

package test;

public class MyBeanDaoImpl implements MyBeanDao {

    @Override
    public void daoMethod() {
        System.out.println("dao method invoked ...");
    }
}

package test;

public class MyBeanServiceImpl implements MyBeanService {
    
    private MyBeanDao beanDao;

    @Override
    public void serviceMethod() {
       System.out.println("Service method invoked...");
       beanDao.daoMethod();
    }
    
    public void setBeanDao(MyBeanDao beanDao) {
        System.out.println("setter injection .....");
        this.beanDao = beanDao;
    }  
}

Next, define the MyBean class that makes use of the MyBeanService and the

package test;

public class MyBean {
    
    private MyBeanService beanService;
    
    public MyBean(MyBeanService beanService) {
        System.out.println("Constructor injection...");
        this.beanService = beanService;
    }
    
    public void testMethod(){
        System.out.println("My bean method invoked ....");
        beanService.serviceMethod();
    }
}

STEP 2: Wire up the beans and the dependencies via an IOC container like Spring. The beans.xml file is shown below.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee" 
 xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">

 <bean id="myBeanDao" class="test.MyBeanDaoImpl"/>
 
 <bean id="myBeanService" class="test.MyBeanServiceImpl">
    <!-- setter injection of dao into service -->
    <property name="beanDao" ref="myBeanDao" />
 </bean>
 
 <bean id="myBean" class="test.MyBean"> 
    <!-- constructor injection of service into mybean -->
    <constructor-arg><ref bean="myBeanService" /></constructor-arg>
 </bean>
 
</beans>

As you can see, the MyBeanDao is injected via the setter injection into MyBeanService, and the MyBeanService is injected into MyBean via the constructor injection.

Q. How do you bootstrap the initial bean?
A.

STEP 3: The TestSpring class is the client class that makes use of the MyBean. In order to access the initial entry point into your application, which in this case is "MyBean", it needs to be bootstrapped via a BeanFactory implementation class. It can be done a number of ways as demonstrated below.

Using the "ClassPathXmlApplicationContext"

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] {"test/beans.xml"});
        BeanFactory factory = (BeanFactory) appContext;
        MyBean bean = (MyBean)factory.getBean("myBean"); 
        bean.testMethod();  
    }   
}

Using the "FileSystemResource"

package test;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

public class TestSpring {
    
    public static void main(String[] args) {
        Resource res = new FileSystemResource("bin/test/beans.xml");
        XmlBeanFactory factory = new XmlBeanFactory(res);
        MyBean bean = (MyBean)factory.getBean("myBean"); 
        bean.testMethod();  
    }   
}

Using the "ClassPathResource"

package test;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class TestSpring {
    
    public static void main(String[] args) {
        ClassPathResource res = new ClassPathResource("test/beans.xml");
        XmlBeanFactory factory = new XmlBeanFactory(res);
        MyBean bean = (MyBean)factory.getBean("myBean"); 
        bean.testMethod();  
    }   
}

STEP 4: Run the TestSpring as a stand alone application, which prints the following.

setter injection .....
Constructor injection...
My bean method invoked ....
Service method invoked...
dao method invoked ...

When MyBean bean = (MyBean)factory.getBean("myBean"); is executed, the dependent beans are created and wired up by the IOC container. You can further extend this by providing the necessary hooks to further enhance your understanding.

Q. What would you do if it’s not practical (or impossible) to wire up your entire application into the Spring framework, but you still need a Spring loaded bean in order to perform a task?

A. For example,

an auto generated web service client class! But you do want to use the dependency injection feature of Spring to get some of the other beans injected in to this class.
A legacy code that needs to make use of a Spring bean.

The ApplicationContextAware interface provided by Spring allows you to wire some java classes which are unable (or you don’t want it) to be wired to the Spring application context.

STEP 1: The ApplicationContextAware interface makes sense when an object requires access to a set of collaborating beans.

package test;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class MyServiceFactory implements ApplicationContextAware {
    
    private ApplicationContext context;

    public void testMethod2(){
        System.out.println("Test method2 invoked ....");
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx)
            throws BeansException {
       System.out.println("setting application context ..."); 
       this.context = ctx;
    }
    
    
    public MyBeanService getInstance(String accessCode) {
        //.....some logic
        MyBeanService beanService = (MyBeanService) context.getBean("myBeanService");
        return beanService;
    }
}

STEP 2: The beans2.xml file. The MyServiceFactory is not wired up.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee" 
 xsi:schemaLocation="
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">
 
 
 <bean id="myBeanDao" class="test.MyBeanDaoImpl"/>
 
 <bean id="myBeanService" class="test.MyBeanServiceImpl">
    <!-- setter injection of dao into service -->
    <property name="beanDao" ref="myBeanDao" />
 </bean>
 
 <!-- No DI wiring -->
 <bean id="myServiceFactory" class="test.MyServiceFactory" /> 
   
</beans>

STEP 3: Finally, the client code that makes use of the MyServiceFactory class.

package test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring2 {
    
    public static void main(String[] args) {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] {"test/beans2.xml"});
        BeanFactory factory = (BeanFactory) appContext;
        MyServiceFactory servicefactory = (MyServiceFactory)factory.getBean("myServiceFactory"); 
        MyBeanService service = servicefactory.getInstance("111");
        service.serviceMethod();
    }   
}

The output will be:

29/11/2011 3:59:29 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@145e044: startup date [Tue Nov 29 15:59:29 EST 2011]; root of context hierarchy
29/11/2011 3:59:29 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [test/beans2.xml]
29/11/2011 3:59:29 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1a42792: defining beans [myBeanDao,myBeanService,myServiceFactory]; root of factory hierarchy
setter injection .....
setting application context ...
Service method invoked...
dao method invoked ...

Q. How would you create an application context from a web application?
A. As opposed to the BeanFactory, which will often be created programmatically, ApplicationContexts can be created declaratively using a ContextLoader. You can register an ApplicationContext using the ContextLoaderListener as shown below in the web.xml file. The Spring context listener provides more flexibility in terms of how an application is wired together. It uses the application's Spring configuration to determine what object to instantiate and loads the objects into the application context used by the servlet container.

<web-app>
  .....
  <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  ....
</web-app>

By default, it looks for a file named applicationContext.xml file in WEB-INF folder. But, you can configure the org.springframework.web.context.ContextLoaderListener class to use a context parameter called contextConfigLocation to determine the location of the Spring configuration file. The context parameter is configured using the context-parameter element. The context-param element has two children that specify parameters and their values. The param-name element specifies the parameter's name. The param-value element specifies the parameter's value.

<web-app>
  ...
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>WEB-INF/beans.xml</param-value>
  </context-param>

  <listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  ...
</web-app>

Note: There will be only one ServletContext for each web application. ServletContext will be created while deploying the application. Once the ServletContext is created, it will be used by all the servlets and jsp files in the same application. ServletContext is also called as the application scope variables in the web application scenario. The ContextLoaderListener is in the spring-web-xxx.jar. It is quite handy to check the Spring API for org.springframework.web.context.support.XmlWebApplicationContext class that describes this.

For a WebApplicationContext that reads in a different bean definition format, you could define your own implementation, and define your implementation with the "contextClass" init parameter.

Here is another example with multiple Spring files.

<webapp>
   ..
   <context-param>
  <param-name>contextClass</param-name>
  <param-value>com.myapp.MyappXmlWebApplicationContext</param-value>
 </context-param>

   <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
   classpath*:/com/myapp/transactionContext.xml
   classpath*:/com/myapp/daoContext.xml  
   classpath*:/com/myapp/override-daoContext${my.env}.xml
            /WEB-INF/webservice-interceptor-config.xml
   /WEB-INF/webservice-config.xml
   classpath*:/cxf.xml
  </param-value>
 </context-param>   
 
   <listener> 
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
   
</web-app>

The contextClass can be defined something like.

package com.myapp;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;

import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.web.context.support.ServletContextResourcePatternResolver;
import org.springframework.web.context.support.XmlWebApplicationContext;

public class MyappXmlWebApplicationContext extends XmlWebApplicationContext {
    private static final String MY_ENV = "my.env";
    private static final String MY_ENV_PLACEHOLDER = "\\$\\{" + MY_ENV + "\\}";

    protected ResourcePatternResolver getResourcePatternResolver() {
        return new PatchedResourcePatternResolver(this);
    }

    private static class PatchedResourcePatternResolver extends ServletContextResourcePatternResolver {

        public PatchedResourcePatternResolver(ResourceLoader resourceLoader) {
            super(resourceLoader);
        }

        public Resource[] getResources(String locationPattern) throws IOException {
            locationPattern = locationPattern.replaceAll(MY_ENV_PLACEHOLDER, System.getProperty(MY_ENV, ""));
            Resource[] resources = super.getResources(locationPattern);

            if (0 < locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()).length()) {
                return resources;
            }

            Collection<Resource> filteredResources = new ArrayList<Resource>();
            for (int i = 0; i < resources.length; i++) {
                Resource resource = resources[i];
                if (!resource.getURL().getProtocol().equals("jar")) {
                    filteredResources.add(resource);
                }
            }
            return (Resource[]) filteredResources.toArray(new Resource[filteredResources.size()]);
        }
    }
}

More Spring Interview Questions and Answers

400+ Java Interview Questions and Answers

400+ Java Interview Questions and Answers with lots of diagrams, examples, & code

Free PDF downloads:

What do others say:

Web Services Interview Questions and Answers - RESTful Web Service Overview

Java Web Services Interview Questions and Answers: Overview

Hibernate Interview Questions and Answers: integration testing the DAO layer

Spring and Hibernate Interview Questions and Answers: AOP, interceptors, and deadlock retry

Hibernate Interview Questions and Answers: with annotations and Spring framework

JavaScript Interview Questions and Answers: Coding and putting all together

UNIX Interview questions and answers

JavaScript Interview Questions and Answers: Function.call, Function.apply, and Callback functions

JavaScript Interview Questions and Answers: Closure

Pros and Cons

JavaScript Interview Questions and Answers: Working with the objects

JavaScript Interview Questions and Answers: Overview

Tricky Java interview questions and answers

More Java multi-threading interview questions and answers?

JSF Interview Questions and Answers: event handling

JSF Interview Questions and Answers: postback and viewstate

JSF Interview Questions and Answers: Seam

Design patterns interview Questions and answers: observer pattern

Spring Interview Questions and Answers: JNDI, JMS, other

Hibernate Interview questions and answers: cacheing

Spring Interview Questions and Answers: Hibernate integration

Are you feeling stagnated?

Spring Interview Questions and Answers: read properties file

Java Interview Questions and Answers: working with proprties files

Spring Interview Questions and Answers : Spring Bean life cycle, DI, and IOC